public static function import($graphUri, $uri, $locator, $all = true, $presets = array(), $exceptedProperties = array(), $wrapperName = 'linkeddata', $fetchMode = 'none', $action = 'add', $versioning = true, $filterCallback = null)
{
// Check whether user is allowed to write the model.
$erfurt = Erfurt_App::getInstance();
$store = $erfurt->getStore();
$storeGraph = $store->getModel($graphUri);
if (!$storeGraph || !$storeGraph->isEditable()) {
return self::IMPORT_NOT_EDITABLE;
}
$r = new Erfurt_Rdf_Resource($uri);
$r->setLocator($locator);
// Try to instanciate the requested wrapper
$wrapper = null;
try {
$wrapper = Erfurt_Wrapper_Registry::getInstance()->getWrapperInstance($wrapperName);
} catch (Erfurt_Wrapper_Exception $e) {
return self::IMPORT_WRAPPER_INSTANCIATION_ERR;
}
if (null == $wrapper) {
return self::IMPORT_WRAPPER_NOT_AVAILABLE;
}
$wrapperResult = null;
try {
$wrapperResult = $wrapper->run($r, $graphUri, $all);
} catch (Erfurt_Wrapper_Exception $e) {
return self::IMPORT_WRAPPER_ERR;
}
if ($wrapperResult === false) {
return self::IMPORT_WRAPPER_RESULT_NOT_AVAILABLE;
} else {
if (is_array($wrapperResult)) {
if (isset($wrapperResult['status_codes'])) {
if (in_array(Erfurt_Wrapper::RESULT_HAS_ADD, $wrapperResult['status_codes'])) {
$newStatements = $wrapperResult['add'];
//default filter
$newStatements = self::filterStatements($newStatements, $uri, $all, $presets, $exceptedProperties, $fetchMode);
//custom filter
if ($filterCallback != null && is_array($filterCallback)) {
try {
$newStatements = call_user_func($filterCallback, $newStatements);
} catch (Exception $e) {
return self::IMPORT_CUSTOMFILTER_EXCEPTION;
}
}
$stmtBeforeCount = $store->countWhereMatches($graphUri, '{ ?s ?p ?o }', '*');
if ($versioning) {
// Prepare versioning...
$versioning = $erfurt->getVersioning();
$actionSpec = array('type' => self::VERSIONING_IMPORT_ACTION_TYPE, 'modeluri' => $graphUri, 'resourceuri' => $uri);
// Start action
$versioning->startAction($actionSpec);
}
if ($action == 'add') {
try {
$store->addMultipleStatements($graphUri, $newStatements);
} catch (Exception $e) {
$versioning->abortAction();
if (defined('_EFDEBUG')) {
throw $e;
}
return self::IMPORT_GENERAL_EXCEPTION;
}
} else {
if ($action == 'update') {
$queryoptions = array('use_ac' => false, 'result_format' => Erfurt_Store::RESULTFORMAT_EXTENDED, 'use_additional_imports' => false);
$oldStatements = $store->sparqlQuery('SELECT * FROM <' . $graphUri . '> WHERE { ?s ?p ?o }', $queryoptions);
//transform resultset to rdf/php statements
$modelOld = new Erfurt_Rdf_MemoryModel();
$modelOld->addStatementsFromSPOQuery($oldStatements);
$modelNew = new Erfurt_Rdf_MemoryModel($newStatements);
$storeGraph->updateWithMutualDifference($modelOld->getStatements(), $modelNew->getStatements());
}
}
if ($versioning) {
$versioning->endAction();
}
$stmtAfterCount = $store->countWhereMatches($graphUri, '{ ?s ?p ?o }', '*');
$stmtAddCount = $stmtAfterCount - $stmtBeforeCount;
if ($stmtAddCount > 0) {
// TODO test ns
// If we added some statements, we check for additional namespaces and add them.
if (in_array(Erfurt_Wrapper::RESULT_HAS_NS, $wrapperResult['status_codes'])) {
$namespaces = $wrapperResult['ns'];
$erfurtNamespaces = $erfurt->getNamespaces();
foreach ($namespaces as $ns => $prefix) {
try {
$erfurtNamespaces->addNamespacePrefix($graphUri, $prefix, $ns, false);
} catch (Exception $e) {
// Ignore...
}
}
}
return self::IMPORT_OK;
} else {
if (count($newStatements) > 0) {
return self::IMPORT_NO_NEW_DATA;
} else {
return self::IMPORT_NO_DATA;
}
}
} else {
return self::IMPORT_NO_DATA;
}
} else {
return self::IMPORT_WRAPPER_ERR;
}
} else {
return self::IMPORT_WRAPPER_ERR;
}
}
}
/**
* fetches the PHP/RDF statments array description array
*
* @param string $resourceIri The Iri, which identifies the resource.
* @param string|false $modelIri The Iri, which identifies the model or
* false for store wide descriptions
* @param array $options Array of different options:
* Erfurt_Store::USE_AC = true|false - use access control
* maxDepth = int - how much blank node level
* fetchInverse - also fetch incoming properties
*
* @return PHP/RDF statements array of the resource
*/
private function _fetchResourceDescription($resourceIri, $modelIri, $options = array())
{
// overwrite result format
$options[Erfurt_Store::RESULTFORMAT] = Erfurt_Store::RESULTFORMAT_EXTENDED;
$memoryModel = new Erfurt_Rdf_MemoryModel();
$query = new Erfurt_Sparql_SimpleQuery();
$query->setProloguePart('SELECT ?p ?o')->setWherePart("{<{$resourceIri}> ?p ?o . }");
// prepare an additional query for inverse properties
if (isset($options['fetchInverse']) && $options['fetchInverse'] === true) {
$inverseQuery = new Erfurt_Sparql_SimpleQuery();
$inverseQuery->setProloguePart('SELECT ?s ?p')->setWherePart("{?s ?p <{$resourceIri}> . }");
} else {
$inverseQuery = false;
}
if ($modelIri === false) {
// use complete store if modelIri not given
$result = $this->sparqlQuery($query, $options);
if ($inverseQuery) {
$inverseResult = $this->sparqlQuery($inverseQuery, $options);
}
} else {
// if model is given, try to get it
$ac = Erfurt_App::getInstance()->getAc();
if ($ac->isModelAllowed('view', $modelIri)) {
$model = $this->getModel($modelIri, $options[Erfurt_Store::USE_AC]);
} else {
$model = false;
}
if (!$model) {
// return an empty description if model not available or allowed
$result = false;
} else {
// use model query method if model valid and readable
$result = $model->sparqlQuery($query, $options);
if ($inverseQuery) {
$inverseResult = $model->sparqlQuery($inverseQuery, $options);
}
}
}
if ($result) {
foreach ($result['results']['bindings'] as $row) {
// fake the subject array
$s = array('type' => 'uri', 'value' => $resourceIri);
$memoryModel->addStatementFromExtendedFormatArray($s, $row['p'], $row['o']);
// todo: implement blank node fetching here
//if ($row['o']['type'] === 'bnode') {
//$nodeId = $row['o']['value'];
//$bNode = self::initWithBlankNode($nodeId, $this->_model);
//$nodeKey = sprintf('_:%s', $nodeId);
//$description[$nodeKey] = $bNode->getDescription($maxDepth-1);
//}
}
}
if (isset($inverseResult) && $inverseResult !== false) {
foreach ($inverseResult['results']['bindings'] as $row) {
// fake the object array
$o = array('type' => 'uri', 'value' => $resourceIri);
$memoryModel->addStatementFromExtendedFormatArray($row['s'], $row['p'], $o);
}
}
return $memoryModel->getStatements();
}
/**
* Creates a new named graph
*/
public function createAction()
{
$this->addModuleContext('main.window.modelcreate');
$store = $this->_erfurt->getStore();
$this->view->clearModuleCache('modellist');
OntoWiki::getInstance()->getNavigation()->disableNavigation();
$this->view->placeholder('main.window.title')->set('Create New Knowledge Base');
$this->view->formActionUrl = $this->_config->urlBase . 'model/create';
$this->view->formEncoding = 'multipart/form-data';
$this->view->formClass = 'simple-input input-justify-left';
$this->view->formMethod = 'post';
$this->view->formName = 'createmodel';
// this is the default action
$defaultActions = array('empty' => array('parameter' => 'checked', 'controller' => 'model', 'action' => 'info', 'label' => 'Create a (nearly) empty knowledge base', 'description' => 'Just add the label and type to the new model.'));
$importActions = array_merge($defaultActions, $this->_getImportActions());
$this->view->importActions = $importActions;
if (!$this->_erfurt->isActionAllowed('ModelManagement')) {
$this->_owApp->appendMessage(new OntoWiki_Message('Model management is not allowed.', OntoWiki_Message::ERROR));
$this->view->errorFlag = true;
return;
}
// TODO: add this to the template in order to allow users to tune it
$this->view->modelUri = $this->_config->urlBase . 'NEWMODEL/';
$toolbar = $this->_owApp->toolbar;
$toolbar->appendButton(OntoWiki_Toolbar::SUBMIT, array('name' => 'Create Knowledge Base', 'id' => 'createmodel'))->appendButton(OntoWiki_Toolbar::RESET, array('name' => 'Cancel', 'id' => 'createmodel'));
$this->view->placeholder('main.window.toolbar')->set($toolbar);
$this->view->title = $this->view->_('Create Knowledge Base');
if (!$this->_request->isPost()) {
// FIX: http://www.webmasterworld.com/macintosh_webmaster/3300569.htm
// disable connection keep-alive
$response = $this->getResponse();
$response->setHeader('Connection', 'close', true);
$response->sendHeaders();
return;
} else {
// process the user input
$post = $this->_request->getPost();
// determine or create the model URI
$newModelUri = '';
if (trim($post['modeluri']) != '') {
// URI given via form input
$newModelUri = trim($post['modeluri']);
} else {
if (trim($post['title']) != '') {
// create a nice URI from the title (poor mans way)
$urlBase = $this->_config->urlBase;
$title = trim($post['title']);
$title = str_replace(' ', '', $title);
$title = urlencode($title);
$newModelUri = $urlBase . $title . '/';
} else {
// create a default model with counter
$urlBase = $this->_config->urlBase . 'kb';
$counter = 0;
do {
$newModelUri = $urlBase . $counter++ . '/';
} while ($store->isModelAvailable($newModelUri, false));
}
}
if ($newModelUri == '') {
$this->_owApp->appendMessage(new OntoWiki_Message('Please provide at least a valid URI for the new Knowledge Base.', OntoWiki_Message::ERROR));
$this->view->errorFlag = true;
return;
}
// create model
if ($store->isModelAvailable($newModelUri, false)) {
// model exists
$this->_owApp->appendMessage(new OntoWiki_Message('Given Knowledge Base already exists.', OntoWiki_Message::ERROR));
$this->view->errorFlag = true;
return;
} else {
// model does not exist, will be created
$model = $store->getNewModel($newModelUri, $newModelUri, Erfurt_Store::MODEL_TYPE_OWL);
$this->_owApp->appendMessage(new OntoWiki_Message('Knowledge Base successfully created.', OntoWiki_Message::SUCCESS));
// add label
$additions = new Erfurt_Rdf_MemoryModel();
if (isset($post['title']) && trim($post['title']) != '') {
$additions->addAttribute($newModelUri, EF_RDFS_LABEL, $post['title']);
}
$model->addMultipleStatements($additions->getStatements());
// TODO: add ACL infos based on the post data
$this->_doImportActionRedirect($newModelUri);
}
}
}
