/**
* description
*
* @return string
*/
public function getScheme()
{
$scheme = VocabularyPeer::retrieveByPK($this->getSchemeId());
if ($scheme) {
return $scheme->getName();
}
}
/**
* description
*
* @return return_type
* @param integer $v Vocbaulary Id to lookup
*/
public static function getNextConceptId($v)
{
//lookup the vocabulary
$vocabulary = VocabularyPeer::retrieveByPK($v);
if ($vocabulary) {
//get the last id
$lastId = $vocabulary->getLastUriId();
//increment it by one and set the last_id
$nextId = $lastId ? ++$lastId : 100000;
//we should theoretically set this when we save the concept, but it doesn't matter
$vocabulary->setLastUriId($nextId);
$vocabulary->save();
return $nextId;
}
}
/**
* Set the defaults
*
* @param ConceptProperty $concept_property
*/
public function setDefaults($discuss)
{
$action = $this->getRequest()->getParameter('action');
if ('create' == strtolower($action)) {
$filter = $this->getUser()->getAttributeHolder()->getAll('sf_admin/discuss/filters');
//we need to get all the numbers
if ($filter && is_array($filter)) {
$filterKey = array_keys($filter);
try {
switch ($filterKey[0]) {
case "property":
$property = ConceptPropertyPeer::retrieveByPK($filter[$filterKey[0]]);
$concept = $property->getConceptRelatedByConceptId();
$vocabId = $concept->getVocabularyId();
$vocabulary = myActionTools::findCurrentVocabulary();
/** @var Discuss **/
$discuss->setConceptProperty($property);
$discuss->setConcept($concept);
$discuss->setVocabularyId($vocabId);
break;
case "concept_id":
$concept = ConceptPeer::retrieveByPK($filter[$filterKey[0]]);
$vocabId = $concept->getVocabularyId();
/** @var Discuss **/
$discuss->setConcept($concept);
$discuss->setVocabularyId($vocabId);
case "vocabulary_id":
$vocabId = VocabularyPeer::retrieveByPK($filter[$filterKey[0]]);
/** @var Discuss **/
$discuss->setVocabularyId($vocabId);
break;
default:
}
} catch (Exception $e) {
}
}
} else {
}
parent::setDefaults($discuss);
}
/**
* @param $task
* @param $args
*
* Arg[0] is one of "schema" (element set), "vocab" or "vocabulary"
* arg[1] is the vocabulary name.
* The file type is determined by the extension and must be one of "json", "rdf", "csv", "xml"
* arg[2] is the vocabulary id
* arg[3] is the batch id
* arg[4] [optional] is -d
*
* @throws Exception
*/
function run_import_vocabulary($task, $args)
{
//xdebug_break();
//check the argument counts
if (count($args) < 1) {
throw new Exception('You must provide a vocabulary type.');
}
if (count($args) < 2) {
throw new Exception('You must provide a file name.');
}
if (count($args) < 3) {
throw new Exception('You must provide a vocabulary id.');
}
//set the arguments
$type = strtolower($args[0]);
$filePath = $args[1];
$vocabId = $args[2];
$batchId = isset($args[3]) ? $args[3] : "";
$deleteMissing = (isset($args[4]) && ("-d" == $args[4]));
//do some basic validity checks
if (! in_array(
$type,
array(
"schema",
"vocab",
"vocabulary"
)
)
) {
throw new Exception('You must import into a schema or a vocab');
}
if ("vocabulary" == $type) {
$type = "vocab";
}
if (! is_numeric($vocabId)) {
throw new Exception('You must provide a valid ID');
}
//does the file exist?
if (! file_exists($filePath)) {
//default to the site upload path
$filePath = $GLOBALS['uploadPath'] . $filePath;
if (! file_exists($filePath)) {
throw new Exception('You must supply a valid file to import: ' . $filePath);
}
}
//is the file a valid type?
if (preg_match('/^.+\.([[:alpha:]]{2,4})$/', $filePath, $matches)) {
if (! in_array(
strtolower($matches[1]),
array(
"json",
"rdf",
"csv",
"xml"
)
)
) {
throw new Exception('You must provide a valid file type based on the extension');
}
} else {
throw new Exception("File type cannot be determined from the file extension");
}
$fileType = $matches[1];
//is the object a valid object?
if ('vocab' == $type) {
$vocabObj = VocabularyPeer::retrieveByPK($vocabId);
if (is_null($vocabObj)) {
throw new Exception('Invalid vocabulary ID');
}
//set some defaults
$baseDomain = $vocabObj->getBaseDomain();
$language = $vocabObj->getLanguage();
$statusId = $vocabObj->getStatusId();
$userId = $vocabObj->getCreatedUserId();
$agentId = $vocabObj->getAgentId();
//get a skos property id map
$skosMap = SkosPropertyPeer::getPropertyNames();
//there has to be a hash or a slash
$tSlash = preg_match('@(/$)@i', $vocabObj->getUri()) ? '' : '/';
$tSlash = preg_match('/#$/', $vocabObj->getUri()) ? '' : $tSlash;
} else {
$import = new ImportVocab($type, $filePath, $vocabId);
}
/* From here on the process is the same regardless of UI */
// check to see if file has been uploaded before
// check import history for file name
$importHistory = FileImportHistoryPeer::retrieveByLastFilePath($filePath);
// if reimport
// get last import history for filename
// unserialize column map
// match column names to AP based on map
// look for matches in unmatched field/column names to AP (ideal)
// csv table of data --
// row1: parsed field names/column headers
// row2: select dropdown with available fields from object AP (pre-select known matches)
// each select identified by column number
// row3: display datatype of selected field (updated dynamically when field selected)
// row4-13: first 10 rows of parsed data from file
// require a column that can match to 'URI' (maybe we'll allow an algorithm later)
// require columns that are required by AP
// on reimport there should be a flag to 'delete missing properties' from the current data
// note: at some point there will be a reimport process that allows URI changing
// this will require that there be an OMR identifier embedded in the incoming data
switch ($fileType) {
case "csv":
if ('vocab' == $type) {
// Get array of heading names found
$headings = $reader->getHeadings();
$fields = ConceptPeer::getFieldNames();
//set the map
// $map[] = array("property" => "Uri", "column" => "URILocal");
// $map[] = array("property" => "prefLabel", "column" => "skos:prefLabel");
// $map[] = array("property" => "definition", "column" => "skos:definition");
// $map[] = array("property" => "notation", "column" => "skos:notation");
// $map[] = array("property" => "scopeNote", "column" => "skos:scopeNote");
$map = array(
"uri" => "URILocal",
"prefLabel" => "skos:prefLabel",
"definition" => "skos:definition",
"notation" => "skos:notation",
"scopeNote" => "skos:scopeNote"
);
$rows = 0;
//executeImport:
// serialize the column map
try {
while ($row = $reader->getRow()) {
$rows ++;
// lookup the URI (or the OMR ID if available) for a match
$uri = $baseDomain . $row[$map["uri"]];
$concept = ConceptPeer::getConceptByUri($uri);
$updateTime = time();
$language = (isset($map['language'])) ? $row[$map['language']] : $vocabObj->getLanguage();
if (! $concept) {
// create a new concept or element
$concept = new Concept();
$concept->setVocabulary($vocabObj);
$concept->setUri($uri);
/**
* @todo Need to handle updates for topconcept here, just like language
**/
$concept->setIsTopConcept(false);
$concept->updateFromRequest(
$userId,
fixEncoding(rtrim($row[$map['prefLabel']])),
$language,
$statusId
);
} //don't update the concept if the preflabel matches
else if ($row[$map['prefLabel']] != $concept->getPrefLabel()) {
$concept->updateFromRequest($userId, fixEncoding(rtrim($row[$map['prefLabel']])));
}
//there needs to be a language to lookup the properties unless it's an objectProperty
$rowLanguage = (isset($map['language'])) ? $row[$map['language']] : $concept->getLanguage();
foreach ($map as $key => $value) {
//we skip because we already did them
if (! in_array(
$key,
array(
'uri',
'prefLabel',
'language'
)
)
) {
$skosId = $skosMap[$key];
//check to see if the property already exists
$property =
ConceptPropertyPeer::lookupProperty($concept->getId(), $skosId, $rowLanguage);
//create a new property for each unmatched column
if (! empty($row[$value])) {
if (! $property) {
$property = new ConceptProperty();
$property->setCreatedUserId($userId);
$property->setConceptId($concept->getId());
$property->setCreatedAt($updateTime);
$property->setSkosPropertyId($skosId);
}
if (($row[$value] != $property->getObject()) ||
($rowLanguage != $property->getLanguage())
) {
/**
* @todo We need a check here for skos objectproperties and handle differently
**/
if ($rowLanguage != $property->getLanguage()) {
$property->setLanguage($rowLanguage);
}
if ($row[$value] != $property->getObject()) {
$property->setObject(fixEncoding(rtrim($row[$value])));
}
$property->setUpdatedUserId($userId);
$property->setUpdatedAt($updateTime);
$property->save();
}
} //the row value is empty
else if ($deleteMissing && $property) {
$property->delete();
}
}
}
// else
// lookup and update concept or element
// lookup and update each property
// update the history for each property, action is 'import', should be a single timestamp for all (this should be automatic)
// if 'delete missing properties' is true
// delete each existing, non-required property that wasn't updated by the import
}
} catch(Exception $e) {
// catch
// if there's an error of any kind, write to error log and continue
echo "Error on row: " . $rows . ", " . $uri . "\n" . $e . "\n";
continue;
}
$objects = $vocabObj->countConcepts();
} else //it's an element set
{
$import->setCsvReader($import->file);
$import->processProlog();
$import->getDataColumnIds();
$import->processData();
//todo: $results should be a class
$results[$vocabId] = $import->results;
$bacthId = $import->saveResults($batchId);
}
break;
case "json":
break;
case "rdf":
break;
case "xml":
break;
default:
}
/* output to stdout*/
// number of objects imported (link to history, filtered on timestamp of import)
echo " Rows imported: " . count($results[$vocabId]['success']['rows']) . "\n From File:" . $filePath . "\nUse this ID for more in this batch: " . $bacthId;
// number of errors (link to error log)
}
public function setSchema( $schemaId )
{
if ($this->type === 'schema' ) {
$this->schema = \SchemaPeer::retrieveByPK($schemaId);
} else {
$this->schema = \VocabularyPeer::retrieveByPK($schemaId);
}
}
/**
* Executes show action
*
*/
public function executeShowScheme()
{
//build the complete URI
$rootUri = $this->getRequest()->getUriPrefix() . '/';
$schemeUri = $rootUri . 'uri/' . $this->getRequestParameter('scheme', '');
$type = $this->getRequestParameter('type');
$ts = strtotime($this->getRequestParameter('ts'));
$this->timestamp = $ts;
$version = $this->getRequestParameter('version');
//$_SERVER['HTTP_ACCEPT'] = '';
//$_SERVER['HTTP_USER_AGENT'] = '';
switch ($type) {
case 'xmlschema':
//this URI HAS an 'id', HAS an 'rdf' suffix, and does NOT have a 'uri' action
$id = $this->getRequestParameter('id');
$vocabulary = VocabularyPeer::retrieveByPK($id);
$this->getContext()->getResponse()->setStatusCode(200);
break;
case 'html':
//this URI does NOT have an 'id', HAS an 'html' suffix, and HAS a 'uri' action
//redirect to the base registry using the correct id for the scheme:
// http://metadataregistry.org/concept/list/vocabulary_id/16.html
$vocabulary = VocabularyPeer::retrieveByUri($schemeUri);
$this->forward404Unless($vocabulary);
//redirect
$this->getContext()->getResponse()->setStatusCode(303);
$this->redirect($this->getRequest()->getUriPrefix() . '/concept/list/vocabulary_id/' . $vocabulary->getId() . '.html');
break;
case 'uri':
//this URI does NOT have an 'id', HAS an 'rdf' suffix, and HAS a 'uri' action
//$this->getContext()->getResponse()->setStatusCode(303);
$vocabulary = VocabularyPeer::retrieveByUri($schemeUri);
break;
case 'api_uri':
//this URI does NOT have an 'id', does NOT have an 'html' suffix, and comes from the API
$uri = $this->getRequestParameter('uri', '');
$vocabulary = VocabularyPeer::retrieveByUri($uri);
break;
default:
//covers case of 'unknown' too
//this URI does NOT have an 'id', does NOT have a suffix, and HAS a 'uri' action
//do content negotiation
if (true === strpos($_SERVER['HTTP_ACCEPT'], 'text/html') || true === strpos($_SERVER['HTTP_ACCEPT'], 'application/xhtml+xml') || 0 === strpos($_SERVER['HTTP_USER_AGENT'], 'Mozilla')) {
//we redirect to html
$vocabulary = VocabularyPeer::retrieveByUri($schemeUri);
$this->forward404Unless($vocabulary);
//redirect
$this->redirect($this->getRequest()->getUriPrefix() . '/concept/list/vocabulary_id/' . $vocabulary->getId() . '.html');
} else {
$vocabulary = VocabularyPeer::retrieveByUri($schemeUri);
}
break;
}
$this->forward404Unless($vocabulary);
$this->vocabulary = $vocabulary;
//forward to the timeslice if there's a version
if ($version && !$ts) {
$c = new Criteria();
$c->add(VocabularyHasVersionPeer::NAME, $version);
$version = VocabularyHasVersionPeer::doSelectOne($c);
$this->forward404Unless($version, 'Unknown version!');
$ts = $version->getTimeslice('YmdHis');
$this->getRequest()->getParameterHolder()->set('ts', $ts);
$this->forward('xml', 'showScheme');
}
if (!$ts) {
$this->concepts = $vocabulary->getConcepts();
} else {
$this->concepts = ConceptPeer::doSelectConceptByHistoryTimestamp($vocabulary->getid(), $ts);
}
}
/**
* Get the associated Vocabulary object
*
* @param Connection Optional Connection object.
* @return Vocabulary The associated Vocabulary object.
* @throws PropelException
*/
public function getVocabulary($con = null)
{
if ($this->aVocabulary === null && $this->scheme_id !== null) {
// include the related Peer class
include_once 'lib/model/om/BaseVocabularyPeer.php';
$this->aVocabulary = VocabularyPeer::retrieveByPK($this->scheme_id, $con);
/* The following can be used instead of the line above to
guarantee the related object contains a reference
to this object, but this level of coupling
may be undesirable in many circumstances.
As it can lead to a db query with many results that may
never be used.
$obj = VocabularyPeer::retrieveByPK($this->scheme_id, $con);
$obj->addVocabularys($this);
*/
}
return $this->aVocabulary;
}
$tab = false;
break;
case 'vocabulary':
$showBc = true;
$showVocabularyBc = true;
if ('import' == $filter) {
$import = FileImportHistoryPeer::retrieveByPK($paramId);
if ($import) {
$id = $import->getSchemaId();
$schema = SchemaPeer::retrieveByPK($id);
}
}
if (!isset($vocabulary)) {
$id = 'show' == $action ? $sf_params->get('id') : $paramId;
if ($id) {
$vocabulary = VocabularyPeer::retrieveByPK($id);
}
}
$objectId = $vocabulary->getID();
break;
case 'schema':
$showBc = true;
$showSchemaBc = true;
if ('import' == $filter) {
$import = FileImportHistoryPeer::retrieveByPK($paramId);
if ($import) {
$id = $import->getSchemaId();
$schema = SchemaPeer::retrieveByPK($id);
}
}
if (!isset($schema)) {
function run_import_marc_vocabulary($task, $args)
{
//check the argument counts
if (count($args) < 1) {
throw new Exception('You must provide a vocabulary type.');
}
if (count($args) < 2) {
throw new Exception('You must provide a file name.');
}
if (count($args) < 3) {
throw new Exception('You must provide a vocabulary id.');
}
//set the arguments
$type = strtolower($args[0]);
$filePath = $args[1];
$id = $args[2];
$deleteMissing = (isset($args[3]) && ("-d" == $args[3]));
//do some basic validity checks
if (! in_array($type, array("schema", "vocab", "vocabulary"))) {
throw new Exception('You must import into a schema or a vocab');
}
if ("vocabulary" == $type) {
$type = "vocab";
}
if (! is_numeric($id)) {
throw new Exception('You must provide a valid ID');
}
//does the file exist?
if (! file_exists($filePath)) {
throw new Exception('You must supply a valid file to import: ' . $filePath);
}
//is the file a valid type?
if (preg_match('/^.+\.([[:alpha:]]{2,4})$/', $filePath, $matches)) {
if (! in_array(strtolower($matches[1]), array("json", "rdf", "csv", "xml"))) {
throw new Exception('You must provide a valid file type based on the extension');
}
} else {
throw new Exception("File type cannot be determined from the file extension");
}
$fileType = $matches[1];
//is the object a valid object?
if ('vocab' == $type) {
$vocabObj = VocabularyPeer::retrieveByPK($id);
if (is_null($vocabObj)) {
throw new Exception('Invalid vocabulary ID');
}
//set some defaults
$baseDomain = $vocabObj->getBaseDomain();
$language = $vocabObj->getLanguage();
$statusId = $vocabObj->getStatusId();
//get a skos property id map
$skosMap = SkosPropertyPeer::getPropertyNames();
//there has to be a hash or a slash
$tSlash = preg_match('@(/$)@i', $vocabObj->getUri()) ? '' : '/';
$tSlash = preg_match('/#$/', $vocabObj->getUri()) ? '' : $tSlash;
} else {
$schemaObj = SchemaPeer::retrieveByPK($id);
if (is_null($schemaObj)) {
throw new Exception('Invalid schema ID');
}
//set some defaults
$baseDomain = $schemaObj->getUri();
$language = $schemaObj->getLanguage();
$statusId = $schemaObj->getStatusId();
//get a element set property id map
$profileId = 1;
$profile = ProfilePeer::retrieveByPK($profileId);
$elementMap = $profile->getAllProperties();
//there has to be a hash or a slash
$tSlash = preg_match('@(/$)@i', $baseDomain) ? '' : '/';
$tSlash = preg_match('/#$/', $baseDomain) ? '' : $tSlash;
}
// insert jon's user id
$userId = 36;
/* From here on the process is the same regardless of UI */
//execute
// parse file to get the fields/columns and data
$file = fopen($filePath, "r");
if (! $file) {
throw new Exception("Can't read supplied file");
}
// check to see if file has been uploaded before
// check import history for file name
$importHistory = FileImportHistoryPeer::retrieveByLastFilePath($filePath);
// if reimport
// get last import history for filename
// unserialize column map
// match column names to AP based on map
// look for matches in unmatched field/column names to AP (ideal)
// csv table of data --
// row1: parsed field names/column headers
// row2: select dropdown with available fields from object AP (pre-select known matches)
// each select identified by column number
// row3: display datatype of selected field (updated dynamically when field selected)
// row4-13: first 10 rows of parsed data from file
// require a column that can match to 'URI' (maybe we'll allow an algorithm later)
// require columns that are required by AP
// on reimport there should be a flag to 'delete missing properties' from the current data
// note: at some point there will be a reimport process that allows URI changing
// this will require that there be an OMR identifier embedded in the incoming data
switch ($fileType) {
case "csv":
try {
$reader = new aCsvReader($filePath);
} catch(Exception $e) {
throw new Exception("Not a happy CSV file!");
}
if ('vocab' == $type) {
// Get array of heading names found
$headings = $reader->getHeadings();
$fields = ConceptPeer::getFieldNames();
//set the map
// $map[] = array("property" => "Uri", "column" => "URILocal");
// $map[] = array("property" => "prefLabel", "column" => "skos:prefLabel");
// $map[] = array("property" => "definition", "column" => "skos:definition");
// $map[] = array("property" => "notation", "column" => "skos:notation");
// $map[] = array("property" => "scopeNote", "column" => "skos:scopeNote");
$map = array(
"uri" => "URILocal",
"prefLabel" => "skos:prefLabel",
"definition" => "skos:definition",
"notation" => "skos:notation",
"scopeNote" => "skos:scopeNote"
);
$rows = 0;
//executeImport:
// serialize the column map
try {
while ($row = $reader->getRow()) {
$rows ++;
// lookup the URI (or the OMR ID if available) for a match
$uri = $baseDomain . $row[$map["uri"]];
$concept = ConceptPeer::getConceptByUri($uri);
$updateTime = time();
$language = (isset($map['language'])) ? $row[$map['language']] : $vocabObj->getLanguage();
if (! $concept) {
// create a new concept or element
$concept = new Concept();
$concept->setVocabulary($vocabObj);
$concept->setUri($uri);
/**
* @todo Need to handle updates for topconcept here, just like language
**/
$concept->setIsTopConcept(false);
$concept->updateFromRequest(
$userId,
fixMarcEncoding(rtrim($row[$map['prefLabel']])),
$language,
$statusId
);
} //don't update the concept if the preflabel matches
else if ($row[$map['prefLabel']] != $concept->getPrefLabel()) {
$concept->updateFromRequest($userId, fixMarcEncoding(rtrim($row[$map['prefLabel']])));
}
//there needs to be a language to lookup the properties unless it's an objectProperty
$rowLanguage = (isset($map['language'])) ? $row[$map['language']] : $concept->getLanguage();
foreach ($map as $key => $value) {
//we skip because we already did them
if (! in_array($key, array('uri', 'prefLabel', 'language'))) {
$skosId = $skosMap[$key];
//check to see if the property already exists
$property =
ConceptPropertyPeer::lookupProperty($concept->getId(), $skosId, $rowLanguage);
//create a new property for each unmatched column
if (! empty($row[$value])) {
if (! $property) {
$property = new ConceptProperty();
$property->setCreatedUserId($userId);
$property->setConceptId($concept->getId());
$property->setCreatedAt($updateTime);
$property->setSkosPropertyId($skosId);
}
if (($row[$value] != $property->getObject()) ||
($rowLanguage != $property->getLanguage())
) {
/**
* @todo We need a check here for skos objectproperties and handle differently
**/
if ($rowLanguage != $property->getLanguage()) {
$property->setLanguage($rowLanguage);
}
if ($row[$value] != $property->getObject()) {
$property->setObject(fixMarcEncoding(rtrim($row[$value])));
}
$property->setUpdatedUserId($userId);
$property->setUpdatedAt($updateTime);
$property->save();
}
} //the row value is empty
else if ($deleteMissing && $property) {
$property->delete();
}
}
}
// else
// lookup and update concept or element
// lookup and update each property
// update the history for each property, action is 'import', should be a single timestamp for all (this should be automatic)
// if 'delete missing properties' is true
// delete each existing, non-required property that wasn't updated by the import
}
} catch(Exception $e) {
// catch
// if there's an error of any kind, write to error log and continue
echo "Error on row: " . $rows . ", " . $uri . "\n" . $e . "\n";
continue;
}
$objects = $vocabObj->countConcepts();
} else //it's an element set
{
$map = array(
"uri" => "uriLocalPart",
"name" => "reg:name",
"definition" => "skos:definition",
"label" => "rdfs:label",
"note" => array("tag" => "tagCap", "ind1" => "ind1Cap", "ind2" => "ind2Cap", "sub" => "subCap")
);
$rows = 0;
//executeImport:
// serialize the column map
try {
while ($row = $reader->getRow()) {
// lookup the URI (or the OMR ID if available) for a match
//There always has to be a URI on either update or create
if (! isset($row[$map["uri"]])) {
throw new Exception('Missing URI for row: ' . $reader->getRowCount());
continue;
}
$rows ++;
$uri = $baseDomain . $tSlash . $row[$map["uri"]];
$property = SchemaPropertyPeer::retrieveByUri($uri);
$updateTime = time();
$rowLanguage = (isset($map['language'])) ? $row[$map['language']] : $language;
$rowStatusId = (isset($map['status'])) ? $row[$map['status']] : $statusId;
if (! $property) {
// create a new property
/** @var SchemaProperty * */
$property = new SchemaProperty();
$property->setSchema($schemaObj);
$property->setUri($uri);
$property->setCreatedUserId($userId);
$property->setCreatedAt($updateTime);
}
$property->setLanguage($rowLanguage);
$property->setStatusId($rowStatusId);
$property->setUpdatedUserId($userId);
$property->setUpdatedAt($updateTime);
if (isset($row[$map["label"]])) {
$property->setLabel($row[$map["label"]]);
}
if (isset($row[$map["name"]])) {
$property->setName($row[$map["name"]]);
}
if (isset($row[$map["definition"]])) {
$property->setDefinition($row[$map["definition"]]);
}
if (is_array($map["note"])) {
$note = '';
foreach ($map["note"] as $key => $value) {
$caption = ! empty($row[$value]) ? " (" . $row[$value] . ")" : ' (no caption)';
$note .= ! empty($row[$key]) ? $key . ": " . $row[$key] . $caption . "<br />" : "";
}
$property->setNote($note);
} else {
if (isset($row[$map["note"]])) {
$property->setNote($row[$map["note"]]);
}
}
$property->saveSchemaProperty($userId);
/**
* @todo Need to handle domain and range
**/
foreach ($map as $key => $value) {
//we skip because we already did them
if (! in_array(
$key,
array('uri', 'status', 'language', 'label', 'name', 'definition', 'comment', 'note')
)
) {
$elementId = $elementMap[$key];
//check to see if the property already exists
//note that this also checks the object value as well, so there's no way to update or delete an existing triple
//the sheet would have to conatin the identifier for the triple
$element = SchemaPropertyElementPeer::lookupElement(
$schemaObj->getId(),
$elementId,
$map[$value]
);
//create a new property for each unmatched column
if (! empty($row[$value])) {
if (! $element) {
$element = new SchemaPropertyElement();
$element->setCreatedUserId($userId);
$element->setCreatedAt($updateTime);
$element->setProfilePropertyId($elementId);
}
if (($row[$value] != $element->getObject()) ||
($rowLanguage != $element->getLanguage())
) {
/**
* @todo We need a check here for objectproperties and handle differently
**/
if ($rowLanguage != $element->getLanguage()) {
$element->setLanguage($rowLanguage);
}
if ($row[$value] != $element->getObject()) {
$element->setObject($row[$value]);
}
$element->setUpdatedUserId($userId);
$element->setUpdatedAt($updateTime);
$element->save();
}
} //the row value is empty
else if ($deleteMissing && $element) {
$element->delete();
}
}
}
// else
// lookup and update concept or element
// lookup and update each property
// update the history for each property, action is 'import', should be a single timestamp for all (this should be automatic)
// if 'delete missing properties' is true
// delete each existing, non-required property that wasn't updated by the import
}
} catch(Exception $e) {
// catch
// if there's an error of any kind, write to error log and continue
echo "Error on row: " . $rows . ", " . $uri . "\n" . $e . "\n";
continue;
}
$objects = $schemaObj->countSchemaPropertys();
}
// save the import history file (match timestamp to history entries)
break;
case "json":
break;
case "rdf":
break;
case "xml":
break;
default:
}
/* output to stdout*/
// number of objects imported (link to history, filtered on timestamp of import)
echo "File:" . $filePath . ";\n Objects imported: " . $objects . "; Rows read: " . $rows . "\n";
// number of errors (link to error log)
}
public function executePublish()
{
//send the id to the publishing class
if (!$this->vocabulary) {
$this->vocabulary = VocabularyPeer::retrieveByPK($this->getRequestParameter('id'));
}
$vocabulary = $this->vocabulary;
//todo: these should be configured by the publish form
$uselanguageMap = true;
$useLanguage = "";
$cLang = null;
ini_set('memory_limit', '640M');
ini_set('max_execution_time', 600);
$repo = $vocabulary->getRepo();
$mime = "jsonld";
$vocabDir = parse_url($vocabulary->getNamespace(), PHP_URL_PATH);
if (!$vocabulary->getRepo() || !$vocabDir) {
$this->setFlash('error', 'This Vocabulary has NOT been published. We couldn\'t parse the file names from the uri.</br>Make sure that you\'ve set the the Git repository and have a valid namespace');
$this->redirect($this->getRequest()->getUriPrefix() . '/vocabulary/show/id/' . $vocabulary->getId() . '.html');
}
$file = rtrim($vocabDir, "/") . "." . $mime;
$repoRoot = SF_ROOT_DIR . DIRECTORY_SEPARATOR . 'web' . DIRECTORY_SEPARATOR . 'repos' . DIRECTORY_SEPARATOR . "agents" . DIRECTORY_SEPARATOR . $vocabulary->getAgentId() . DIRECTORY_SEPARATOR . $repo;
$filesystem = new Filesystem(new Adapter($repoRoot), new Cache());
$filePath = $repoRoot . DIRECTORY_SEPARATOR . $mime . DIRECTORY_SEPARATOR . $file;
//TODO: create an alias file
$aliasPath = "alias" . DIRECTORY_SEPARATOR . $vocabDir;
//make sure the path is created
$filesystem->put($mime . DIRECTORY_SEPARATOR . $file, '');
//open a file for writing the complete vocabulary file
$vocabFile = fopen($filePath, 'w');
$jsonLdService = new jsonldService($vocabulary);
fwrite($vocabFile, $jsonLdService->getJsonLd());
fclose($vocabFile);
//TODO: generate RDF/XML and save
//TODO: generate other flavours of RDF using EasyRDF and save
//if publish was successful
$this->setFlash('notice', 'This Vocabulary has been published');
$this->redirect($this->getRequest()->getUriPrefix() . '/vocabulary/show/id/' . $vocabulary->getId() . '.html');
}
public function _before(FunctionalTester $I)
{
$this->vocab = \VocabularyPeer::retrieveByPK($this->valueVocabularyId);
}
public function setVocabularyParams()
{
//use the prolog to look up correct resources in the database
if ('schema' == $this->type) {
$vocabulary = \SchemaPeer::retrieveByPK($this->vocabId);
} else {
/** @var $vocabulary \Vocabulary */
$vocabulary = \VocabularyPeer::retrieveByPK($this->vocabId);
}
if ( ! $vocabulary) {
//TODO: turn this into a real error message and exit gracefully
exit( "No vocab!!!!!" );
}
$this->vocabulary = $vocabulary;
//if we didn't set it from the constructor we set default status from the vocab
if ( ! $this->status) {
$this->prolog['defaults']['statusId'] = $this->getStatusId($vocabulary->getStatusId());
} else {
$this->prolog['defaults']['statusId'] = $this->status;
}
//if the prolog never set the default language from the spreadsheet, set it here
if ( ! isset( $this->prolog['defaults']['lang'] )) {
$this->prolog['defaults']['lang'] = $vocabulary->getLanguage();
}
//if it hasn't been set already, set the userId from the vocabulary (which does a little bit more work)
if ( ! $this->userId) {
$this->setUserId();
}
}
public function perform($args)
{
list($schemaId, $filePath, $importId, $environment, $type) = $args;
// Set up environment for this job
define('SF_ROOT_DIR', realpath(dirname(__file__) . '/../../../..'));
define('SF_APP', 'frontend');
define('SF_ENVIRONMENT', $environment);
define('SF_DEBUG', false);
//initialize composer
require_once(SF_ROOT_DIR . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php');
// initialize symfony
require_once(SF_ROOT_DIR . DIRECTORY_SEPARATOR . 'apps' . DIRECTORY_SEPARATOR . SF_APP . DIRECTORY_SEPARATOR
. 'config' . DIRECTORY_SEPARATOR . 'config.php');
// initialize database manager
$databaseManager = new \sfDatabaseManager();
$databaseManager->initialize();
$import = new ImportVocab($type, $filePath, $schemaId);
try {
$fileImportHistory = \FileImportHistoryPeer::retrieveByPK($importId);
} catch (\PropelException $e) {
//exit the job with an error
throw $e;
}
try {
if ('schema' == $type) {
$schema = \SchemaPeer::retrieveByPK($schemaId);
} else {
$schema = \VocabularyPeer::retrieveByPK($schemaId);
}
} catch (\PropelException $e) {
//exit the job with an error
throw $e;
}
// Perform some job
$import->importId = $importId;
//todo update the prefixes table with prefixes
//todo update the schema table with prefixes
$schemaPrefixes = $schema->getPrefixes();
$countSchemaPrefixes = count($schemaPrefixes);
/** @var string[] $importPrefixes */
$importPrefixes = $import->prolog['prefix'];
foreach ($importPrefixes as $prefix => $url) {
if (trim($prefix)) {
if ( ! array_key_exists($prefix, $schemaPrefixes)) {
$schemaPrefixes[$prefix] = $url;
}
}
}
if (count($schemaPrefixes) != $countSchemaPrefixes)
{
$schema->setPrefixes($schemaPrefixes);
$schema->save();
}
try {
$prolog = $import->processProlog();
$import->processData();
$fileImportHistory->setResults($import->results);
$fileImportHistory->setMap($import->mapping);
$fileImportHistory->setTotalProcessedCount( $import->DataWorkflowResults->getTotalProcessedCount());
$fileImportHistory->setErrorCount($import->DataWorkflowResults->getErrorCount());
$fileImportHistory->setSuccessCount($import->DataWorkflowResults->getSuccessCount());
$fileImportHistory->setResults('Your file has been imported. It took us: ' . $import->DataWorkflowResults->getElapsed()->format("%h hours; %i minutes; %s seconds"));
$fileImportHistory->save();
} catch (\Exception $e) {
$fileImportHistory->setResults("There was an error processing the import. Message: " . $e->getMessage());
$fileImportHistory->save();
throw $e;
}
$agentId = ($fileImportHistory->getSchema()) ? $fileImportHistory->getSchema()->getAgentId() : $fileImportHistory->getVocabulary()->getAgentId();
$newFilePath = \sfConfig::get( 'sf_repos_dir' ) . DIRECTORY_SEPARATOR .
'agents' . DIRECTORY_SEPARATOR .
$agentId . DIRECTORY_SEPARATOR .
$fileImportHistory->getSourceFileName();
$request = new \myWebRequest();
$result = $request->moveToRepo($filePath, $newFilePath);
$schema = \SchemaPeer::retrieveByPK($schemaId);
if ($schema) {
$schema->setUpdatedAt(time());
$schema->setUpdatedUserId($import->userId);
$schema->save();
}
unset ($import);
unset ($request);
unset($databaseManager);
}
/**
* Gets the related vocabulary object
*
* @return Vocabulary
*/
public function getRelatedScheme()
{
return VocabularyPeer::retrieveByPK($this->scheme_id);
}
/**
* description
*
* @return Vocabulary Current vocabulary object
* @param integer $vocabId
*/
public static function setLatestVocabulary($vocabId)
{
$vocabObj = VocabularyPeer::retrieveByPK($vocabId);
if ($vocabObj) {
sfContext::getInstance()->getUser()->setCurrentVocabulary($vocabObj);
}
return $vocabObj;
}