/**
  * Find out the type of a resource.
  * @param  $resource
  * @return type of $resource
  */
 private function findType($resource)
 {
     $model = OntoWiki::getInstance()->selectedModel;
     $query = 'SELECT ?type WHERE { <' . $resource . '> a ?type }';
     $result = $model->sparqlQuery($query);
     return $result[0]['type'];
 }
 private function executeFullHelper($matches)
 {
     $tag = $matches[0];
     $helper = strtolower($matches['helper']);
     $attributes = trim($matches['attributes']);
     // split the attributes part of the helper markup and fill it to the
     // options array
     preg_match_all($this->keyValuePattern, $attributes, $matches, PREG_SET_ORDER);
     $options = array();
     foreach ($matches as $i => $match) {
         $key = $match['key'];
         $value = $match['value'];
         $options[$key] = $value;
     }
     // pre-set some standard values
     $options['selectedResource'] = OntoWiki::getInstance()->selectedResource;
     // return the output of the helper or its error message
     try {
         $helperInstance = $this->view->getHelper($helper);
         if (!$helperInstance) {
             throw new Exception("Helper '{$helper}' not found.");
         }
         if (!$helperInstance instanceof Site_View_Helper_MarkupInterface) {
             throw new Exception("Helper '{$helper}' is not a markup helper and cannot be used in this way.");
         }
         return $this->view->{$helper}($options);
     } catch (Exception $e) {
         $message = htmlspecialchars($e->getMessage(), ENT_NOQUOTES);
         $message = str_replace('"', '', $message);
         $message = str_replace('\'', '', $message);
         return $this->returnError($message . " ({$tag})");
     }
 }
 /**
  * search GUI to import CKAN packages into ontowiki
  * TODO: finish :)
  */
 public function browserAction()
 {
     $t = $this->_owApp->translate;
     $this->view->placeholder('main.window.title')->set($t->_('CKAN Package Browser'));
     $this->addModuleContext('main.window.ckan.browser');
     OntoWiki::getInstance()->getNavigation()->disableNavigation();
     echo "not finished yet";
     return;
     //$scriptBaseUrl = $this->_owApp->extensionManager->getComponentUrl('ckan').'ckanjs/lib/';
     //$clientScript  = $scriptBaseUrl . 'client.js';
     //$this->view->headScript()->appendFile($clientScript);
     //$newIncludePath = ONTOWIKI_ROOT . '/extensions/ckan/api/';
     //set_include_path(get_include_path() . PATH_SEPARATOR . $newIncludePath);
     //require_once('Ckan_client.php');
     //// Create CKAN object
     //// Takes optional API key parameter. Required for POST and PUT methods.
     //$ckan        = new Ckan_client();
     //$search_term = 'street';
     //$result      = $ckan->search_package($search_term, array('limit' => 5, 'tags' => 'format-rdf'));
     //$packageIds  = $result->results;
     //foreach ($packageIds as $key => $id) {
     //$package = $ckan->get_package_entity($id);
     //$data[$id] = $package;
     //}
     //$this->view->data = $data;
 }
 /**
  * init() Method to init() normal and add tabbed Navigation
  */
 public function init()
 {
     parent::init();
     OntoWiki::getInstance()->getNavigation()->disableNavigation();
     // provide basic view data
     $action = $this->_request->getActionName();
     $this->view->placeholder('main.window.title')->set('Import Data');
     $this->view->formActionUrl = $this->_config->urlBase . 'basicimporter/' . $action;
     $this->view->formEncoding = 'multipart/form-data';
     $this->view->formClass = 'simple-input input-justify-left';
     $this->view->formMethod = 'post';
     $this->view->formName = 'importdata';
     $this->view->supportedFormats = $this->_erfurt->getStore()->getSupportedImportFormats();
     if (!$this->isSelectedModelEditable()) {
         return;
     } else {
         $this->_model = $this->_owApp->selectedModel;
     }
     // add a standard toolbar
     $toolbar = $this->_owApp->toolbar;
     $toolbar->appendButton(OntoWiki_Toolbar::SUBMIT, array('name' => 'Import Data', 'id' => 'importdata'))->appendButton(OntoWiki_Toolbar::RESET, array('name' => 'Cancel', 'id' => 'importdata'));
     $this->view->placeholder('main.window.toolbar')->set($toolbar);
     if ($this->_request->isPost()) {
         $this->_post = $this->_request->getPost();
     }
 }
Beispiel #5
0
 public function link($options = array())
 {
     $model = OntoWiki::getInstance()->selectedModel;
     $titleHelper = new OntoWiki_Model_TitleHelper($model);
     // check for options and assign local vars or null
     $uri = isset($options['uri']) ? (string) $options['uri'] : null;
     $literal = isset($options['literal']) ? $options['literal'] : null;
     $text = isset($options['text']) ? $options['text'] : null;
     $property = isset($options['property']) ? $options['property'] : null;
     $class = isset($options['class']) ? ' class="' . $options['class'] . '"' : '';
     $prefix = isset($options['prefix']) ? $options['prefix'] : '';
     $suffix = isset($options['suffix']) ? $options['suffix'] : '';
     $iprefix = isset($options['iprefix']) ? $options['iprefix'] : '';
     $isuffix = isset($options['isuffix']) ? $options['isuffix'] : '';
     $direct = isset($options['direct']) ? true : false;
     // resolve short forms (overwrite full name values with short forms values)
     $uri = isset($options['r']) ? (string) $options['r'] : $uri;
     $literal = isset($options['l']) ? $options['l'] : $literal;
     $text = isset($options['t']) ? $options['t'] : $text;
     $property = isset($options['p']) ? $options['p'] : $property;
     // if an uri is given, we do not need to search for
     if (isset($uri)) {
         // resolve qnames and check uri input
         $uri = Erfurt_Uri::getFromQnameOrUri((string) $uri, $model);
     } else {
         // if no uri is given, we need to search by using the literal
         if (!isset($literal)) {
             throw new Exception('The link helper needs at least one parameter literal or uri');
         }
         // if a property is given, use <properyuri> instead of a variable part in the query
         $property = $property ? '<' . Erfurt_Uri::getFromQnameOrUri($property, $model) . '>' : '?property';
         // build the query including PREFIX declarations
         $query = '';
         foreach ($model->getNamespaces() as $ns => $nsprefix) {
             $query .= 'PREFIX ' . $nsprefix . ': <' . $ns . '>' . PHP_EOL;
         }
         $query .= 'SELECT DISTINCT ?resourceUri WHERE {?resourceUri ' . $property . ' ?literal
             FILTER (!isBLANK(?resourceUri))
             FILTER (REGEX(?literal, "^' . $literal . '$", "i"))
             }  LIMIT 1';
         $result = $model->sparqlQuery($query);
         if (!$result) {
             // resource not found, so return plain literal or given text
             return isset($text) ? $text : $literal;
         } else {
             $uri = $result[0]['resourceUri'];
         }
     }
     // generate the link URL from the resource URI
     if ($direct == true) {
         $url = $uri;
     } else {
         $url = new OntoWiki_Url(array('route' => 'properties'), array('r'));
         $url->setParam('r', $uri, true);
         $url = (string) $url;
     }
     // link text comes from title helper or option
     $text = isset($text) ? $text : $titleHelper->getTitle($uri);
     return "{$prefix}<a{$class} href='{$url}'>{$iprefix}{$text}{$isuffix}</a>{$suffix}";
 }
 public function onCreateMenu($event)
 {
     $modelUri = (string) $event->resource;
     $baseUrl = OntoWiki::getInstance()->config->urlBase;
     $extensionManager = OntoWiki::getInstance()->extensionManager;
     // do NOT create the menu entry ...
     switch (true) {
         // ... for resources
         case !$event->isModel:
             // ... for localhost models (can't be registered at CKAN)
         // ... for localhost models (can't be registered at CKAN)
         case substr_count($modelUri, 'http://localhost') > 0:
             // ... if the model is not part of the base url (no Linked Data)
         // ... if the model is not part of the base url (no Linked Data)
         case substr_count($modelUri, $baseUrl) !== 1:
             // ... if we do not have a linked data server online
         // ... if we do not have a linked data server online
         case !$extensionManager->isExtensionRegistered('linkeddataserver'):
             return;
     }
     // finally, create the holy menu entry and PREPEND it on top of the menu
     $url = new OntoWiki_Url(array('controller' => 'ckan', 'action' => 'register'), array('m'));
     $url->setParam('m', $modelUri);
     $event->menu->prependEntry('Register Knowledge Base @ CKAN', (string) $url);
 }
Beispiel #7
0
 public function query($options = array())
 {
     $this->templateData = $this->view->getHelper('Renderx')->templateData;
     $store = OntoWiki::getInstance()->erfurt->getStore();
     $model = OntoWiki::getInstance()->selectedModel;
     // check for options and assign local vars or null
     $where = isset($options['where']) ? $options['where'] : '?resourceUri a foaf:Project.';
     $template = isset($options['template']) ? $options['template'] : 'li';
     $limit = isset($options['limit']) ? $options['limit'] : 100;
     $prefix = isset($options['prefix']) ? $options['prefix'] : '';
     $suffix = isset($options['suffix']) ? $options['suffix'] : '';
     $orderby = isset($options['orderby']) ? $options['orderby'] : null;
     // create template name {site}/items/{name}.phtml
     $siteId = $this->templateData['siteId'];
     $template = $siteId . '/items/' . $template . '.phtml';
     // build the query including PREFIX declarations
     $query = '';
     foreach ($model->getNamespaces() as $ns => $usedPrefix) {
         $query .= 'PREFIX ' . $usedPrefix . ': <' . $ns . '>' . PHP_EOL;
     }
     $query .= 'SELECT DISTINCT ?resourceUri WHERE {' . PHP_EOL;
     $query .= $where . PHP_EOL;
     $query .= 'FILTER (!isBLANK(?resourceUri))' . PHP_EOL;
     $query .= '}' . PHP_EOL;
     if ($orderby !== null) {
         $query .= 'ORDER BY ' . $orderby . PHP_EOL;
     }
     $query .= 'LIMIT ' . $limit . PHP_EOL;
     // prepare the result string
     $result = $this->view->querylist($query, $template, $options);
     if ($result != '') {
         $result = $prefix . $result . $suffix;
     }
     return $result;
 }
 public function viewAction()
 {
     $this->view->placeholder('main.window.title')->set('Historyproxy');
     $this->addModuleContext('main.window.historyproxy.search');
     OntoWiki::getInstance()->getNavigation()->disableNavigation();
     $model = $this->_owApp->selectedModel;
     $event = new Erfurt_Event('onQueryHistory');
     // $model->getModelIri()
     /**
      * Get last imports
      */
     $event->function = 'getLastImports';
     $event->parameters = array();
     $event->trigger();
     $this->view->importsFunction = $event->function;
     $this->view->importsParameters = $event->parameters;
     $this->view->importsCallback = $event->callback;
     /**
      * Get last changes
      */
     $event->function = 'getChangesFromRange';
     $event->parameters = array($model->getModelIri(), '01-01-2014', '30-01-2014');
     $event->trigger();
     $this->view->changeFunction = $event->function;
     $this->view->changeParameters = $event->parameters;
     $this->view->changeCallback = $event->callback;
 }
Beispiel #9
0
    public function toc($options = array())
    {
        // check for options and assign local vars or default
        $startlevel = isset($options['startlevel']) ? $options['startlevel'] : '1';
        $depth = isset($options['depth']) ? $options['depth'] : '2';
        $tag = isset($options['tag']) ? $options['tag'] : 'ul';
        $view = $this->view;
        $store = OntoWiki::getInstance()->erfurt->getStore();
        $model = OntoWiki::getInstance()->selectedModel;
        $titleHelper = new OntoWiki_Model_TitleHelper($model);
        $script = OntoWiki::getInstance()->getUrlBase() . 'extensions/site/js/jquery.tableofcontents.js';
        $return = PHP_EOL;
        $return .= '<script type="text/javascript" src="' . $script . '"></script>' . PHP_EOL;
        $return .= '<script type="text/javascript" charset="utf-8">
    $(document).ready(function(){
        $.TableOfContents.defaultOptions.startLevel = "' . $startlevel . '";
        $.TableOfContents.defaultOptions.depth      = "' . $depth . '";
        $("#toc").tableOfContents($("div.content[property=\'site:content\']"));
    })
</script>' . PHP_EOL;
        $return .= '<details><summary>Table of Contents</summary>';
        $return .= '<' . $tag . ' id="toc"></' . $tag . '>';
        $return .= '</details>';
        return $return;
    }
Beispiel #10
0
 /**
  * Retieves user credentials from the current request and tries to
  * authenticate the user with Erfurt.
  *
  * @param Zend_Controller_Request_Abstract $request The current request object
  */
 public function routeShutdown(Zend_Controller_Request_Abstract $request)
 {
     if ($credentials = $this->_getAuthHeaderCredentials($request)) {
         switch ($credentials['type']) {
             case 'basic':
                 $erfurt = OntoWiki::getInstance()->erfurt;
                 $logger = OntoWiki::getInstance()->logger;
                 // authenticate
                 $authResult = $erfurt->authenticate($credentials['username'], $credentials['password']);
                 if ($authResult->isValid()) {
                     $logger = OntoWiki::getInstance()->logger;
                     $logger->info("User '{$credentials['username']}' authenticated via HTTP.");
                 } else {
                     // if authentication attempt fails, send appropriate headers
                     $front = Zend_Controller_Front::getInstance();
                     $response = $front->getResponse();
                     $response->setRawHeader('HTTP/1.1 401 Unauthorized');
                     echo 'HTTP/1.1 401 Unauthorized';
                     return;
                 }
                 break;
             case 'foaf+ssl':
                 $adapter = new Erfurt_Auth_Adapter_FoafSsl();
                 $authResult = $adapter->authenticateWithCredentials($credentials['creds']);
                 Erfurt_App::getInstance()->getAuth()->setIdentity($authResult);
                 if ($authResult->isValid()) {
                     $logger = OntoWiki::getInstance()->logger;
                     $logger->info('User authenticated with FOAF+SSL via HTTPS.');
                 }
                 break;
         }
     }
 }
Beispiel #11
0
 public function __construct()
 {
     $this->_owApp = OntoWiki::getInstance();
     if (!isset($this->_owApp->session->managedLists)) {
         $this->_owApp->session->managedLists = array();
     }
 }
 public function postAction()
 {
     // service controller needs no view renderer
     $this->_helper->viewRenderer->setNoRender();
     // disable layout for Ajax requests
     $this->_helper->layout()->disableLayout();
     $response = $this->getResponse();
     $request = $this->_request;
     $output = false;
     try {
         $model = $this->_owApp->selectedModel;
         $store = $this->_owApp->erfurt->getStore();
         //$store->addMultipleStatements((string) $model, $activity->toRDF());
         $classname = OntoWiki::getInstance()->selectedResource;
         //$resource = $response->r;
         $manchester = $request->manchester;
         $structuredOwl = $this->initParser($manchester);
         $triples = $structuredOwl->toTriples();
         $output = array('message' => 'class saved', 'class' => 'success', 'out' => $triples);
     } catch (Exception $e) {
         // encode the exception for http response
         $output = array('message' => $e->getMessage(), 'class' => 'error');
         $response->setRawHeader('HTTP/1.1 500 Internal Server Error');
     }
     // send the response
     $response->setHeader('Content-Type', 'application/json');
     $response->setBody(json_encode($output));
 }
Beispiel #13
0
 public function lastchange($uri)
 {
     // TODO: fill this value with the erfurt versioning api
     $versioning = Erfurt_App::getInstance()->getVersioning();
     $history = $versioning->getLastModifiedForResource($uri, (string) OntoWiki::getInstance()->selectedModel);
     if (empty($history)) {
         return array('resourceUri' => $uri, 'resourceTitle' => '', 'timeStamp' => '', 'timeIso8601' => '', 'timeDuration' => '', 'userTitle' => '', 'userUri' => '', 'userHref' => '');
     }
     $th = new OntoWiki_Model_TitleHelper(OntoWiki::getInstance()->selectedModel);
     $th->addResource($history['useruri']);
     $th->addResource($uri);
     $return = array();
     $userUrl = new OntoWiki_Url(array('route' => 'properties'));
     $userUrl->setParam('r', $history['useruri']);
     $return['resourceUri'] = $uri;
     $return['resourceTitle'] = $th->getTitle($uri);
     $return['timeStamp'] = $history['tstamp'];
     //unix timestamp
     $return['timeIso8601'] = date('c', $history['tstamp']);
     // ISO 8601 format
     try {
         $return['timeDuration'] = OntoWiki_Utils::dateDifference($history['tstamp'], null, 3);
         // x days ago
     } catch (Exception $e) {
         $return['timeDuration'] = '';
     }
     $return['userTitle'] = $th->getTitle($history['useruri']);
     $return['userUri'] = $history['useruri'];
     $return['userHref'] = $userUrl;
     //use URI helper
     return $return;
 }
 /**
  * Constructor
  */
 public function __construct($model, $titleHelperLimit, $dimensionElementLimit)
 {
     $this->_dimensionElementLimit = $dimensionElementLimit;
     $this->_model = $model;
     $this->_titleHelperLimit = $titleHelperLimit;
     // caching
     $this->_objectCache = OntoWiki::getInstance()->erfurt->getCache();
 }
 public function __construct()
 {
     $this->_owApp = OntoWiki::getInstance();
     $patternManagerConfig = $this->_owApp->componentManager->getComponentPrivateConfig("patternmanager");
     $this->_engine = new PatternEngine();
     $this->_engine->setConfig($patternManagerConfig);
     $this->_engine->setBackend($this->_owApp->erfurt);
 }
Beispiel #16
0
 /**
  * Constructor
  */
 public function __construct($config = array(), $translate = null)
 {
     parent::__construct($config);
     $this->_translate = $translate;
     $this->_placeholderRegistry = Zend_View_Helper_Placeholder_Registry::getRegistry();
     if (array_key_exists('use_module_cache', $config) && (bool) $config['use_module_cache']) {
         $this->_moduleCache = OntoWiki::getInstance()->getCache();
     }
 }
 /**
  * We enable GET authentication and test that we do not get a
  * 405 Method No Allowed response.
  */
 public function testAuthActionGetAllowed()
 {
     $config = OntoWiki::getInstance()->config;
     $config->service->allowGetAuth = true;
     $this->dispatch('/service/auth');
     $this->assertController('service');
     $this->assertAction('auth');
     $this->assertResponseCode(400);
 }
 public function __construct()
 {
     if (Erfurt_App::getInstance()->getAc()->isActionAllowed('ExtensionConfiguration')) {
         $owApp = OntoWiki::getInstance();
         $translate = $owApp->translate;
         $url = new OntoWiki_Url(array('controller' => 'exconf', 'action' => 'list'), array());
         $extrasMenu = OntoWiki_Menu_Registry::getInstance()->getMenu('application')->getSubMenu('Extras');
         $extrasMenu->setEntry($translate->_('Configure Extensions'), (string) $url);
     }
 }
Beispiel #19
0
 /**
  * sleeps an amount of time and calls the next job
  *
  * @param mixed $load       the load of the next job
  * @param int   $inXSeconds time in seconds when the next job is called
  *
  * @return void
  */
 private function _next($load = null, $inXSeconds = 2)
 {
     if ((int) $inXSeconds > 0) {
         sleep((int) $inXSeconds);
     }
     if ($load == null) {
         OntoWiki::getInstance()->callJob('cron');
     } else {
         OntoWiki::getInstance()->callJob('cron', $load);
     }
 }
 public function setUpExtensionIntegrationTest()
 {
     $this->setUpIntegrationTest();
     if (null !== $this->_extensionName) {
         $extensionManager = OntoWiki::getInstance()->extensionManager;
         if (!$extensionManager->isExtensionActive($this->_extensionName)) {
             Erfurt_Event_Dispatcher::reset();
             $this->markTestSkipped('extension is not active');
         }
     }
 }
 public function testMessagesActionMultipleMessages()
 {
     $owApp = OntoWiki::getInstance();
     $owApp->appendMessage(new OntoWiki_Message('Test Message 123', OntoWiki_Message::INFO));
     $owApp->appendMessage(new OntoWiki_Message('Error Message 456', OntoWiki_Message::ERROR));
     $this->dispatch('/index/messages');
     $this->assertController('index');
     $this->assertAction('messages');
     $this->assertQueryContentContains('p.messagebox.info', 'Test Message 123');
     $this->assertQueryContentContains('p.messagebox.error', 'Error Message 456');
 }
 /**
  * Returns the content
  */
 public function getContents()
 {
     $from = $this->_owApp->selectedModel;
     $classname = OntoWiki::getInstance()->selectedResource;
     $structured = Erfurt_Owl_Structured_Util_Owl2Structured::mapOWL2Structured(array((string) $from), (string) $classname);
     $data = new StdClass();
     $formUrl = new OntoWiki_Url(array('controller' => 'manchester', 'action' => 'post'), array());
     $data->formUrl = (string) $formUrl;
     $data->manchesterString = (string) $structured;
     $content = $this->render('modules/manchester', $data, 'data');
     return $content;
 }
 /**
  *
  */
 public function __construct()
 {
     $owApp = OntoWiki::getInstance();
     $translate = $owApp->translate;
     $extrasMenu = OntoWiki_Menu_Registry::getInstance()->getMenu('application')->getSubMenu('Extras');
     // If a model is selected, add entry to analyze action
     if (true === isset(OntoWiki::getInstance()->selectedModel)) {
         $extrasMenu->setEntry($translate->_('ApplicationExtrasMenu_Label'), (string) new OntoWiki_Url(array('controller' => 'cubeviz', 'action' => 'analyze'), array()));
     }
     // add entry to comparing action
     $extrasMenu->setEntry($translate->_('ApplicationExtrasMenu_ComparingLabel'), (string) new OntoWiki_Url(array('controller' => 'cubeviz', 'action' => 'compare'), array()));
 }
 public function getContents()
 {
     $this->view->infoMessage = 'Use this Bookmarklet to add content to this Knowledge Base.';
     $this->view->rdfAuthorBase = $this->_config->libraryUrlBase . 'RDFauthor/';
     $this->view->defaultGraph = (string) OntoWiki::getInstance()->selectedModel;
     $this->view->defaultUpdateService = $this->_config->urlBase . 'update/';
     $this->view->defaultQueryService = $this->_config->urlBase . 'sparql/';
     $this->view->ontoWikiUrl = $this->_config->urlBase;
     $frontController = Zend_Controller_Front::getInstance();
     $request = $frontController->getRequest();
     return $this->render('bookmarklet');
 }
 public function __construct()
 {
     $owApp = OntoWiki::getInstance();
     // if a model has been selected
     if ($owApp->selectedModel) {
         // register with extras menu
         $translate = $owApp->translate;
         $url = new OntoWiki_Url(array('controller' => 'queries', 'action' => 'editor'));
         $extrasMenu = OntoWiki_Menu_Registry::getInstance()->getMenu('application')->getSubMenu('Extras');
         $extrasMenu->setEntry($translate->_('Queries'), (string) $url);
         //$extrasMenu->setEntry('Query Builder', (string) $url);
     }
 }
 private function importModels()
 {
     // read config for models to import
     $owApp = OntoWiki::getInstance();
     $models = $this->_privateConfig->setup->model->toArray();
     foreach ($models as $info) {
         // import models
         $path = ONTOWIKI_ROOT . '/' . $info['path'];
         $uri = $info['uri'];
         $hidden = $info['hidden'];
         $this->_import($uri, $path);
     }
 }
Beispiel #27
0
 /**
  * Constructor
  *
  * @see OntoWiki_Model_Abstract
  */
 public function __construct(Erfurt_Store $store, $graph, array $options = array())
 {
     parent::__construct($store, $graph);
     $this->_options = array_merge($this->_options, $options);
     $this->_current = (string) OntoWiki::getInstance()->selectedResource;
     $this->_session = OntoWiki::getInstance()->session;
     // HACK: if the graph itself is one that is normally ignored in other
     // models, don't ignore it
     if (in_array($this->_graph, $this->_options['ignore_ns'])) {
         // TODO: remove only graph and imported namespaces
         $this->_options['ignore_ns'] = array();
     }
 }
 /**
  * Returns the message of the module
  *
  * @return array
  */
 public function getMessage()
 {
     if ($authResult = $this->_owApp->authResult) {
         // Translate partial messages before creation of message box
         $translate = OntoWiki::getInstance()->translate;
         $message = $translate->translate($authResult[0]);
         $message .= '<a href="' . $this->view->urlBase . 'account/recover"> ' . $translate->translate('Forgot your password?') . ' </a>';
         // create messagebox for loginbox (no escape for html code)
         $message = new OntoWiki_Message($message, OntoWiki_Message::ERROR, array('escape' => false, 'translate' => false));
         unset($this->_owApp->authResult);
         return $message;
     }
 }
 public function init()
 {
     /*
      * check for $request->getParam('mode') == 'multi' if tab should also be displayed for
      * multiple resources/lists ($request->getActionName() == 'instances')
      * And set 'mode' => 'multi' to tell the controller the multi mode
      *
      * Multi mode was disabled because it doesn't seam to work
      */
     $owApp = OntoWiki::getInstance();
     if ($owApp->lastRoute == 'properties' && $owApp->selectedResource != null) {
         $owApp->getNavigation()->register('community', array('controller' => 'community', 'action' => 'list', 'name' => 'Community', 'mode' => 'single', 'priority' => 50));
     }
 }
Beispiel #30
0
 public function __construct(Erfurt_Sparql_Query2_IriRef $iri, $withChilds = false)
 {
     $this->iri = $iri;
     if ($withChilds) {
         // TODO what the heck???
         $owApp = OntoWiki::getInstance();
         $store = $owApp->erfurt->getStore();
         $graph = $owApp->selectedModel;
         $types = array_keys($store->getTransitiveClosure($graph->getModelIri(), EF_RDFS_SUBCLASSOF, array($iri->getIri()), true));
         foreach ($types as $type) {
             $this->subclasses[] = new Erfurt_Sparql_Query2_IriRef($type);
         }
     }
 }