Пример #1
0
 public function process($page, $stylesheet, $templatePath)
 {
     $i = 0;
     $templates = array();
     $xmlString = "";
     $templArray = array();
     $linkArray = array();
     //------------------------------------------------------------------------------
     // parse site
     if (count($page->structure())) {
         $areas = $page->structure()->children();
         if (count($areas)) {
             foreach ($areas as $entry) {
                 // check for read access rights
                 // if not, clear node to hide from rendering
                 if (OLIVRight::r($entry)) {
                     if ($mod = $entry->attributes()->mod) {
                         $script = OLIVModule::getModuleByName($mod);
                         $originScript = $script;
                         //------------------------------------------------------------------------------
                         // script found
                         if (isset($script->script)) {
                             // insert parameters
                             olivxml_insert($script, OLIVPreprocessor::parse_param((string) $entry), "ALL");
                             // create paths for module, content, template, image
                             $script->path = system::OLIV_MODULE_PATH() . (string) $script->name . "/";
                             // insert script access rights
                             $script->access->r = OLIVRight::r($entry);
                             $script->access->w = OLIVRight::w($entry);
                             $script->access->x = OLIVRight::x($entry);
                             //------------------------------------------------------------------------------
                             // load module script
                             $this->loadScript($script->script->main, system::OLIV_MODULE_PATH() . $script->name . "/");
                             //------------------------------------------------------------------------------
                             // call module class and merge template and content
                             if ($script->script->main) {
                                 $tempArray = explode(".", $script->script->main);
                                 $class = $tempArray[0];
                                 if (class_exists($class)) {
                                     //------------------------------------------------------------------------------
                                     //------------------------------------------------------------------------------
                                     // create and execute module class
                                     $module = new $class($script);
                                     //------------------------------------------------------------------------------
                                     //------------------------------------------------------------------------------
                                     if (is_object($module)) {
                                         if (!method_exists($module, "template")) {
                                             OLIVError::fire("preprocessor.php::process - module '" . $script->name . "' don't extend OLIVModule");
                                         } else {
                                             $tempTemplate = $module->template();
                                             // set path to insert module-template-link stylesheet
                                             // link only if template and content found
                                             if ($module->template() and $module->content()) {
                                                 if (is_object($module->content())) {
                                                     //TODO register template
                                                     // load template array
                                                     array_push($linkArray, array("module" => (string) $mod, "area" => $entry->getName(), "content" => $module->content()->getName(), "templatePath" => $tempTemplate));
                                                     $templates[$entry->getName() . "::" . $module->content()->getName()] = $tempTemplate;
                                                 }
                                             }
                                             //------------------------------------------------------------------------------
                                             // module didn't return content and template
                                             // clear content entry
                                             if (!$module->content() and !$module->template()) {
                                                 $page->clear($entry->getName());
                                             }
                                             // insert module content in page content
                                             $page->insert($module->content(), $entry->getName());
                                         }
                                     } else {
                                         $page->clear($entry->getName());
                                     }
                                     // destroy module object
                                     //									unset($module);
                                 }
                             } else {
                                 OLIVError::fire("render::callModule - no main script declared");
                             }
                         } else {
                             OLIVError::warning("processor::process - required module '" . $mod . "' not found");
                         }
                     }
                     //------------------------------------------------------------------------------
                 } else {
                     $page->clear($entry->getName());
                 }
             }
             //echoall($page->structure());
         } else {
             OLIVError::fire("processor::process - page is empty");
         }
     }
     //------------------------------------------------------------------------------
     // include module templates in page template
     // create temporary xslt for include process
     $tempXsl = new XSLTProcessor();
     $tempXsl->registerPHPFunctions();
     // include page template
     if (sessionfile_exists($templatePath . ".xslt")) {
         $xmlString = "<xsl:include href='" . session_path($templatePath) . ".xslt'/>";
         OLIVTemplate::link_css($templatePath);
     } else {
         OLIVError::fire("preprocessor.php::process - no page template found");
     }
     //		status::set("debug",$linkArray);
     //------------------------------------------------------------------------------
     // create module link templates
     foreach ($linkArray as $entry) {
         // create stylesheet to link module template to page area
         $tempString = "<xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>";
         $tempString .= "<xsl:template match='" . $entry['area'] . "'>";
         $tempString .= "<xsl:apply-templates select='" . $entry['content'] . "'/>";
         $tempString .= "</xsl:template>";
         $tempString .= "</xsl:stylesheet>";
         $tempXsl = new simpleXmlElement($tempString);
         $fileName = explode("/", $entry['templatePath']);
         array_pop($fileName);
         $fileName = implode("/", $fileName);
         $filePath = session_path($fileName) . "/link_" . $entry['area'] . "_to_" . $entry['content'] . ".xslt";
         // write link file to disk
         $fileHandle = fopen($filePath, "w");
         if ($fileHandle) {
             fputs($fileHandle, $tempXsl->asXML());
             fclose($fileHandle);
         }
         //------------------------------------------------------------------------------
         // insert link template
         $xmlString .= "<xsl:include href='" . $filePath . "'/>";
         //------------------------------------------------------------------------------
         // insert module template only once
         if (!array_key_exists($entry['templatePath'], $templArray)) {
             $templArray[$entry['templatePath']] = $filePath;
             if (sessionfile_exists($entry['templatePath'] . ".xslt")) {
                 // insert module template
                 $xmlString .= "<xsl:include href='" . session_path($entry['templatePath']) . ".xslt'/>";
                 // link css file
                 OLIVTemplate::link_css($entry['templatePath']);
             }
         }
     }
     //------------------------------------------------------------------------------
     // create temporary include template
     $xmlString = "<xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>" . $xmlString . "</xsl:stylesheet>";
     $tempXml = new simpleXmlElement($xmlString);
     $stylesheet->importStylesheet($tempXml);
     //echoall($tempXml->children('http://www.w3.org/1999/XSL/Transform')->asXML());
     //status::set("debug",$page->structure());
 }
Пример #2
0
 public static function writeSource($xml, $path)
 {
     $UUID = 0;
     // process permissions
     $nodes = $xml->XPath("//*[@access]");
     foreach ($nodes as $entry) {
         $parentNode = $entry->XPath(".");
         //			$parentName = $parentNode[0]->getName();
         $parentName = $entry->getName();
         // if access-tag -> display/hide whole content
         if ($parentName == "access") {
             //TODO remove all nodes
         } else {
             if (!OLIVRight::x($entry)) {
                 unset($entry->href);
             }
             if (!OLIVRight::r($entry)) {
                 $childArray = array();
                 foreach ($entry->children() as $child) {
                     array_push($childArray, $child->getName());
                 }
                 foreach ($childArray as $child) {
                     unset($entry->{$child});
                 }
             }
         }
         //TODO use edit attribute to set attribute -> source="path"
         // plugin uses edit and source for editor call
     }
 }
Пример #3
0
 public static function tagEditString($tag, $value, $options)
 {
     $content = $options['template'];
     $source = $content->attributes()->source;
     //echoall($options);
     $retArray = imgRender::tagString($tag, $value, $options);
     // set link if permission granted && source found
     if (OLIVRight::x($content) and $source) {
         $retArray['link']['url'] = status::url();
         $retArray['link']['val'] = OLIVText::_("edit");
         $retArray['link']['lang'] = status::lang();
         $retArray['value'] = "edit";
     }
     return $retArray;
 }
Пример #4
0
 private function parse($menus, $menuName, $templateName, $access, $url, $level = 0)
 {
     $menu = $menus->{$menuName};
     $active = FALSE;
     if ($menu) {
         // get name of menu
         $menuName = $menu->getName();
         $menuXml = new simpleXmlElement("<menu></menu>");
         // open path to actice menu
         $this->openPath($menus, $url);
         //------------------------------------------------------------------------------
         // loop over menu entries
         foreach ($menu->children() as $entry) {
             $visible = FALSE;
             $subMenuVisible = $entry['visible'];
             if ($subMenuVisible) {
                 $entry->visible = "visible";
             }
             //------------------------------------------------------------------------------
             // display item if read permission
             if (OLIVRight::r($entry) and OLIVRight::r($menu)) {
                 $internUrl = "";
                 $menuItemName = $entry->getName();
                 //------------------------------------------------------------------------------
                 // is intern link
                 if (!$entry->url) {
                     // look for module link
                     $mod = (string) $entry["mod"];
                     $page = (string) $entry["page"];
                     $name = $entry->getName();
                     if ($mod and $page) {
                         olivxml_insert($entry, OLIVModule::getContentFriendlyName($mod, $name), "ALL");
                         olivxml_insert($entry, OLIVModule::getContentName($mod, $name), "ALL");
                         olivxml_insert($entry, OLIVModule::getContentTitle($mod, $name), "ALL");
                         $internUrl = "href():" . $page;
                         $entry->url = $internUrl;
                         //							echoall($internUrl);
                     } else {
                         // create correct url
                         $internUrl = $name;
                         $entry->url = $internUrl;
                         $urlName = OLIVText::xml(OLIVRoute::getPageName(status::lang(), $internUrl));
                         // expand url with val
                         if ($val = (string) $entry['val']) {
                             $valArray = OLIVModule::parse_param_string($val);
                             /*							if (array_key_exists("mod",$valArray) and array_key_exists("content",$valArray))
                             								{
                             									$contentName = OLIVModule::getContentName($valArray['mod'],$valArray['content']);
                             									olivxml_insert($entry->val,OLIVModule::getContentFriendlyName($valArray['mod'],$valArray['content']));
                             									$contentTitle = OLIVModule::getContentTitle($valArray['mod'],$valArray['content']);
                             
                             									olivxml_insert($entry->title,$contentTitle);
                             									olivxml_insert($entry->name,$contentName);
                             								}*/
                         } else {
                             olivxml_insert($entry, OLIVRoute::getTitle($internUrl), "ALL");
                             olivxml_insert($entry, OLIVRoute::getPageName(status::lang(), $internUrl), "ALL");
                         }
                     }
                 }
                 //------------------------------------------------------------------------------
                 // set display class
                 //------------------------------------------------------------------------------
                 // aktive / inactive
                 if ($internUrl == $url) {
                     $visible = $url;
                     $entry->status = "active";
                     $entry->class = "{$templateName} menu_{$templateName}_active";
                 } else {
                     $entry->class = "{$templateName} menu_{$templateName}_inactive";
                 }
                 // submenu level
                 if ($level) {
                     $entry->class = "menu{$level}_" . $entry->class;
                 } else {
                     $entry->class = "menu_" . $entry->class;
                 }
                 //------------------------------------------------------------------------------
                 // remove link if no x permission
                 // check for menu_item, menu and page permissions
                 // set display class to disabled
                 $pageXAccess = (string) $access->x;
                 $menuXAccess = OLIVRight::x($menu);
                 if (!(OLIVRight::x($entry) and $menuXAccess and $pageXAccess)) {
                     $entry->url = "";
                     $entry->class = "menu_{$templateName}_disabled";
                 }
                 // get submenu name
                 $subName = (string) $entry['submenu'];
                 if ($subName) {
                     $entry->submenu = $subName;
                 }
                 // create menu_item xml
                 $menu_item = new simpleXmlElement("<menu_item_{$templateName}></menu_item_{$templateName}>");
                 olivxml_insert($menu_item, $entry);
                 // insert menu_item into new menu structure
                 olivxml_insert($menuXml, $menu_item, "ALL");
                 //------------------------------------------------------------------------------
                 // look if aktive menu is in submenu
                 // display sub menus
                 if ($subName and $visible or $subMenuVisible) {
                     // call menu recursive
                     $subMenu = $this->parse($menus, $subName, $templateName, $access, $url, $level + 1);
                     olivxml_insert($menuXml, $subMenu);
                 }
             }
         }
         //echoall($menuXml);
         return $menuXml;
     }
     //    else
     //      OLIVError::fire("menu::parse - no menu defined");
 }