public static function selector($langXml) { // create lang selector $langSelector = new simpleXmlElement("<lang_selector/>"); if ($langXml) { foreach ($langXml as $entry) { $langCode = $entry->getName(); //echoall($langCode); $countryCode = OLIVLang::defaultCountry($langCode); // make current language bigger $id = "oliv_lang_flag"; if ($langCode == status::lang()) { $id = "oliv_lang_flag_selected"; } //get string for url title language name $title = OLIVText::_("change_language", $langCode); $title .= " - " . OLIVText::_($langCode, $langCode); // full language name // create flag image // $img = new simpleXmlElement("<img url='" . status::url() . "' urllang='" . $langCode . "' urltitle='{$title}' src='oliv_flag' id='{$id}' lang='" . $countryCode . "' />"); $img = new simpleXmlElement("<selector><a href='current()' title='{$title}' lang='" . $langCode . "'/><img id='{$id}' lang='" . $countryCode . "'>oliv_flag</img></selector>"); // insert image olivxml_insert($langSelector, $img, "ALL"); } //echoall($langSelector->asXML()); return $langSelector; } }
public static function __callStatic($method, $options) { $content = $options[0]; $tag = $options[1]; // get include information $nodes = $content->XPath("//include"); // include all page informations if (count($nodes)) { foreach ($nodes as $node) { $page = OLIVPage::_load((string) $node); olivxml_insert($content, $page->content); } } return $content; }
public function __construct($header) { // create temporary content xml // name different if used with different templates $templateName = (string) $header->param->template; if ($templateName) { $this->content = new simpleXmlElement("<search_{$templateName}/>"); } else { $this->content = new simpleXmlElement("<search/>"); } $tempContent = OLIVModule::load_content($header); $this->template = OLIVModule::load_template($header); olivxml_insert($this->content, $tempContent); olivxml_insert($this->content->search_result, status::search_result()); // add search result target page $this->content->target = $header->param->target; }
public static function __callStatic($method, $options) { $content = $options[0]; $tag = $options[1]; $type = $options[2]; switch ($type) { // call text search case 'search': // merge result with status::set() $searchString = argv::search(); $result = textPlugin::search(); if ($result) { // get translation of pages $pages = $result->XPath("./result"); // insert text snippets with highlighted searchString foreach ($pages as $page) { $moduleName = (string) $page->type; $name = (string) $page->name; $value = (string) $page->value; $article = OLIVModule::load_xml("", $moduleName . "/" . "content/", $name . ".xml"); if ($article) { $texts = $article->XPath("//text"); foreach ($texts as $text) { // highlight seachstring if ($highlighted = OLIVText::highlight((string) $text, $searchString, "highlight", 25)) { $page->summary = $highlighted; // add language $page->lang = (string) $text['lang']; } } // insert page name olivxml_insert($page->pagename, OLIVRoute::getName((string) $page->page)); } } olivxml_insert($content, $result); } break; // call renderer // call renderer case 'render': textPlugin::render($content); break; } }
public static function search($string) { global $_INDEX; $search = new simpleXmlElement("<search/>"); // prepare string for search $string = strtolower(OLIVText::remove_accents($string)); // search index $result = OLIVIndex::_search($_INDEX->root, $string); if (count($result)) { // create search xml foreach ($result as $entry) { $resArray = explode(":", (string) $entry); $page = $resArray[0]; $type = $resArray[1]; $name = $resArray[2]; $lang = $resArray[3]; $value = $resArray[4]; $newResult = new simpleXmlElement("<result><page>{$page}</page><type>{$type}</type><name>{$name}</name><lang>{$lang}</lang><value>{$value}</value></result>"); olivxml_insert($search, $newResult, "ALL"); } return $search; } }
public function text($node, $name) { olivxml_insert($this->content->{$node}, $this->content->{$name}); }
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()); }
private static function scan($path) { global $_PLUGIN; // $_PLUGIN = new simpleXmlElement("<plugin></plugin>"); $_PLUGIN = new simpleXmlElement("<plugins></plugins>"); if ($pluginDir = olivopendir($path)) { $cnt = 0; while ($file = readdir($pluginDir)) { if (olivis_dir($path . $file) and $file != "." and $file != "..") { $file .= "/"; // get define.xml if (olivfile_exists($path . $file . "define.xml")) { $xml = olivxml_load_file($path . $file . "define.xml"); //TODO include plugin script // get type of plugin olivxml_insert($_PLUGIN, $xml, "ALL"); } } } closedir($pluginDir); return $cnt; } else { OLIVError::fire("plugin::scan - directory {$path} not found"); } return FALSE; }
public static function getGroup($user) { global $_access; if ($user) { $groupArray = array(); $groupXml = new simpleXmlElement("<group></group>"); $groups = $_access->group->XPath("*/users[{$user}]"); foreach ($groups as $entry) { $group = $entry->XPath(".."); olivxml_insert($groupXml, $group[0], "ALL"); } return $groupXml; } return FALSE; }
function olivxml_changeNode($node, $xml) { $temp = new simpleXmlElement("<{$node}>" . (string) $xml . "</{$node}>"); foreach ($xml->attributes() as $key => $value) { $temp->addAttribute($key, $value); } if (count($xml)) { foreach ($xml->children() as $entry) { olivxml_insert($temp, $entry); } } return $temp; }
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"); }
public function insert($xml, $root) { if ($xml) { $insertName = $xml->getName(); // insert content only once if (!$this->structure->{$root}->{$insertName}) { $tempXml = new simpleXmlElement("<{$root}/>"); olivxml_insert($tempXml, $xml, "ALL"); olivxml_insert($this->structure, $tempXml, "ALL"); } } }
private static function updatePageXml($url) { // get page information xml $pageInfo = OLIVPage::getPageInfo($url); // page exists => write pageInfo in page.xml if ($pageInfo) { $pageXml = sessionxml_load_file(system::OLIV_PAGE_PATH() . "page.xml"); // insert if url don't exist if (!$pageXml->define->{$url}) { olivxml_insert($pageXml->define->{$url}, $pageInfo->define); // write file back to disk $pageXml->asXML(session_path(system::OLIV_PAGE_PATH() . "page.xml")); } return $pageInfo; } }
private function create() { $structure = $this->content->structure; $content = $this->content->content; if ($content) { foreach ($content->children() as $entry) { $name = $entry->getName(); // insert translated text in attibutes // text tag with leading $ $tempName = "\$" . $name; $nodes = $structure->XPath("//*[@* = '{$tempName}']"); foreach ($nodes as $node) { $text = OLIVText::xml($entry); foreach ($node->attributes() as $key => $value) { if ((string) $value == $tempName) { $node[$key] = $text; } } } // insert content at name attribute $nodes = $structure->XPath("//*[@name = '{$name}']"); foreach ($nodes as $node) { // insert text into node olivxml_insert($node, $entry); } } } //echoall($this->content->structure); }