public function retrievePrefixes()
{
$prefixes = $this->schema->getPrefixes();
if ('schema' === $this->type) {
$namespaces = \SchemaPropertyElementPeer::getNamespaceList($this->schema->getId());
} else {
$namespaces = \VocabularyPeer::getNamespaceList($this->schema->getId());
}
//check the retrieved namespaces for a match to existing prefixes
foreach ($namespaces as $uri) {
//if we find the uri in existing schema prefixes, move on
if ($prefixes and array_search($uri, $prefixes) !== false) {
continue;
}
//look for it in Prefixes table
$namespacePrefix = \PrefixPeer::findByUri($uri);
if ($namespacePrefix) {
//add it to the prefix array
$prefixes[ $namespacePrefix->getPrefix() ] = $uri;
} //check it against the schema token
elseif (trim($uri, "/#") == trim($this->schema->getUri(), "#/")) {
$prefixes[ $this->schema->getToken() ] = $uri;
} else {
$prefixes[ ] = $uri;
}
}
if (empty($prefixes)) {
$prefixes = $this->getDefaultPrefix();
}
return $prefixes;
}
/**
* AccessTable constructor
*
* @param Schema $schema The schema valid at $ts
* @param string|int $pid
* @param int $ts Time at which the data should be read or written, 0 for now
*/
public function __construct(Schema $schema, $pid, $ts = 0)
{
/** @var \helper_plugin_struct_db $helper */
$helper = plugin_load('helper', 'struct_db');
$this->sqlite = $helper->getDB();
if (!$this->sqlite) {
throw new StructException('Sqlite plugin required');
}
if (!$schema->getId()) {
throw new StructException('Schema does not exist. Only data of existing schemas can be accessed');
}
$this->schema = $schema;
$this->pid = $pid;
$this->setTimestamp($ts);
foreach ($this->schema->getColumns() as $col) {
$this->labels[$col->getColref()] = $col->getType()->getLabel();
}
}
/**
* this is for importing a list of value vocabulary files.
*
* it's designed specifically to import the list of marc21 VES files,
* but may be modified and expanded to support more things
*
* @param $task
* @param $args
*
* @throws Exception
*/
function run_import_list($task, $args)
{
xdebug_break();
//check the argument counts
//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.');
}
//set the arguments
$type = strtolower($args[0]);
$filePath = $args[1];
$batchId = $args[3];
//does the file exist?
if (! file_exists($filePath)) {
throw new Exception('You must supply a valid file to import');
}
//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");
}
/************************************************************
* Set Defaults Here *
*************************************************************/
$fileType = $matches[1];
//todo: need to figure out a way to pass defaults dynamically
$importTask = new pakeTask('import-vocabulary');
// parse file to get the fields/columns and data
$file = fopen($filePath, "r");
if (! $file) {
throw new Exception("Can't read supplied file");
}
switch ($fileType) {
case "csv":
try {
$reader = new aCsvReader($filePath);
} catch(Exception $e) {
throw new Exception("Not a happy CSV file! Error: " . $e);
}
$uploadPath = $GLOBALS['uploadPath'];
;
if ('vocab' == $type) {
// Get array of heading names found
$headings = $reader->getHeadings();
$fields = VocabularyPeer::getFieldNames();
try {
while ($row = $reader->getRow()) {
// lookup the URI (or the OMR ID if available) for a match
if (empty($row["VES"])) {
//skip this one
break;
}
$uri = $baseDomain . $row["VES"] . "#";
$vocab = VocabularyPeer::getVocabularyByUri($uri);
$updateTime = time();
if (! $vocab) {
// create a new concept or element
$vocab = new Vocabulary();
$vocab->setUri($uri);
$vocab->setCreatedAt($updateTime);
$vocab->setCreatedUserId($userId);
$vocab->setAgentId($agentID);
$vocab->setBaseDomain($baseDomain);
$vocab->setCommunity("Libraries, MARC21");
$vocab->setLanguage("en");
$vocab->setStatusId(1);
} else {
$vocab->setLastUpdated($updateTime);
$vocab->setUpdatedUserId($userId);
}
$vocab->setName(fixEncoding(rtrim($row['Name'])));
$vocab->setNote(fixEncoding(rtrim($row['Note'])));
$vocab->setToken($row['VES']);
$vocab->save();
//type
$args[0] = "vocab";
//vocabid
$args[2] = $vocab->getId();
//filepath
$args[1] = $GLOBALS['uploadPath'] . $row['VES'] . ".csv";
$args[3] = $batchId;
$args[4] = "-d";
run_import_vocabulary($importTask, $args);
$foo = $vocab->countConcepts();
}
} catch(Exception $e) {
throw new Exception($e);
}
} else //it's a schema
{
try {
while ($row = $reader->getRow()) {
//NOTE: this is explicitly tuned to a particular import file
//TODO: generalize this import mapping
// lookup the URI (or the OMR ID if available) for a match
if (empty($row["URI"])) {
//skip this one
break;
}
$uri = $row["URI"];
$schema = SchemaPeer::getschemaByUri($uri);
$updateTime = time();
if (! $schema) {
// create a new vocabulary
$schema = new Schema();
$schema->setUri($uri);
$schema->setCreatedAt($updateTime);
$schema->setCreatedUserId($userId);
$schema->setAgentId($agentID);
$schema->setBaseDomain($baseDomain);
$schema->setProfileId(1);
} else {
$schema->setUpdatedAt($updateTime);
$schema->setUpdatedUserId($userId);
}
$schema->setCommunity($row['Tags']);
$schema->setLanguage($row['Language']);
$schema->setNsType("slash");
$schema->setName($row['Label']);
$schema->setNote($row['Note']);
$schema->setStatusId(1);
$schema->setToken($row['Name']);
$schema->setUrl($row['URL']);
$schema->save();
//todo: create a new import batch here and pass it to the import args
//see importVocabulary->saveresults()
//$batchId =
//type
$args[0] = "schema";
//filepath
$args[1] = $GLOBALS['uploadPath'] . $row['File Name'];
//vocabid
$args[2] = $schema->getId();
$args[3] = $batchId;
$args[4] = "-d";
run_import_vocabulary($importTask, $args);
$foo = $schema->countSchemaPropertys();
}
} catch(Exception $e) {
throw new Exception($e);
}
}
break;
default:
}
}
/**
* Declares an association between this object and a Schema object.
*
* @param Schema $v
* @return void
* @throws PropelException
*/
public function setSchema($v)
{
if ($v === null) {
$this->setSchemaId(NULL);
} else {
$this->setSchemaId($v->getId());
}
$this->aSchema = $v;
}
