public function testCanGetArrayOfNamespaces() { $this->specify( "Given a schemaId, we can get an array of unique namespaces", function () { $schemaId = 1; $n = SchemaPropertyElementPeer::getNamespaceList($schemaId); verify( count($n) )->equals( 2 ); } ); }
public function testMe() { $I = $this->tester; $sql = "INSERT INTO `reg_schema_property_element` (`id`, `created_at`, `updated_at`, `deleted_at`, `created_user_id`, `updated_user_id`, `schema_property_id`, `profile_property_id`, `is_schema_property`, `object`, `related_schema_property_id`, `language`, `status_id`) VALUES (110489,'2014-01-19 03:45:21','2014-01-18 22:45:21',NULL,422,422,14603,1,1,'respondentOf',NULL,'en',1);"; $data = $I->getArrayFromSql($sql); //$I->haveInDatabase('reg_schema_property_element', $data); /** @var SchemaPropertyElement $element */ $element = SchemaPropertyElementPeer::retrieveByPK(110489); $element->importId = $this->importId; $element->updateReciprocal("deleted", 422, 81); }
function run_import_repair($task, $args) { //xdebug_break(); if (count($args) < 1) { throw new Exception('You must provide a batch ID.'); } $batchId = $args[0]; //get the import history for the batchid $criteria = new Criteria(); $criteria->add(\FileImportHistoryPeer::BATCH_ID, $batchId); $batch = \FileImportHistoryPeer::doSelect($criteria); if (empty($batch)) { throw new Exception('Not a valid batch ID.'); } $criteria = new \Criteria(); $criteria->add(\ProfilePropertyPeer::NAME, "isSameAs"); /** @var $profileProperty \ProfileProperty */ $profileProperty = \ProfilePropertyPeer::doSelectOne($criteria); $sameasId = $profileProperty->getId(); //for each one in the list /** @var $history FileImportHistory */ foreach ($batch as $history) { //get result array $results = $history->getResults(); $rows = $results['success']['rows']; $userId = $history->getUserId(); //for each row foreach ($rows as $row) { //get the references /** @var $property \SchemaProperty */ $property = \SchemaPropertyPeer::retrieveByPK($row['id']); /** @var $ref \SchemaProperty */ $ref = \SchemaPropertyPeer::retrieveByUri($property->getParentUri()); if ($property and $ref) { $property->setIsSubpropertyOf($ref->getId()); $property->saveSchemaProperty($userId); } //update the parent property if (isset($row['statements'])) { //for each statement foreach ($row['statements'] as $statement) { //get the references if ($sameasId != $statement['propertyId']) { /** @var $ref \SchemaProperty */ $ref = \SchemaPropertyPeer::retrieveByUri($statement['object']); } else { //ref = the parent $ref = $property; } /** @var $propertyElement \SchemaPropertyElement */ $propertyElement = \SchemaPropertyElementPeer::retrieveByPK($statement['id']); if ($propertyElement and $ref) { $propertyElement->setSchemaPropertyRelatedByRelatedSchemaPropertyId($ref); $propertyElement->save(); } } } } } }
/** * @return array */ public function findUsedProfileProperties() { $c = new Criteria(); $c->add(SchemaPropertyPeer::SCHEMA_ID, $this->getId()); $c->clearSelectColumns(); $c->addSelectColumn(SchemaPropertyElementPeer::SCHEMA_PROPERTY_ID); $c->addSelectColumn(SchemaPropertyElementPeer::PROFILE_PROPERTY_ID); $c->addSelectColumn(SchemaPropertyElementPeer::LANGUAGE); $c->addAscendingOrderByColumn(SchemaPropertyElementPeer::SCHEMA_PROPERTY_ID); $c->addJoin(SchemaPropertyElementPeer::SCHEMA_PROPERTY_ID, SchemaPropertyPeer::ID); $foo = array(); $results = SchemaPropertyElementPeer::doSelectRS($c); unset($c); foreach ($results as $result) { if (!isset($foo[$result[0]][$result[1]][$result[2]])) { $foo[$result[0]][$result[1]][$result[2]] = 1; } else { $foo[$result[0]][$result[1]][$result[2]]++; } } $bar = self::buildColumnArray($foo); return $bar; }
/** * updates/creates/deletes the reciprocal property * * @param string $action * @param int $userId * @param int $schemaId * @param Connection $con * * @throws \PropelException */ public function updateReciprocal($action, $userId, $schemaId, $con = null) { $inverseProfilePropertyId = $this->getProfileProperty()->getInverseProfilePropertyId(); if (empty($inverseProfilePropertyId) and $this->getProfileProperty()->getIsReciprocal()) { $inverseProfilePropertyId = $this->getProfileProperty()->getId(); } if (!$inverseProfilePropertyId) { //there's no reciprocal or inverse to process return; } $relatedPropertyId = $this->getRelatedSchemaPropertyId(); if (!$relatedPropertyId) { $relatedProperty = SchemaPropertyPeer::retrieveByUri($this->getObject()); if (!$relatedProperty) { //there's no related property in the registry return; } else { $relatedPropertyId = $relatedProperty->getId(); $this->setRelatedSchemaPropertyId($relatedPropertyId); $this->save(); } } $schemaPropertyID = $this->getSchemaPropertyId(); $property = $this->getSchemaPropertyRelatedBySchemaPropertyId(); //does the user have editorial rights to the reciprocal... $permission = false; //get the maintainers of the reciprocal property $maintainers = $property->getSchema()->getMaintainerIds(); foreach ($maintainers as $maintainerId) { if ($userId == $maintainerId) { $permission = true; break; } } if (false === $permission) { return; } $c = new Criteria(); $c->add(SchemaPropertyElementPeer::SCHEMA_PROPERTY_ID, $relatedPropertyId); $c->add(SchemaPropertyElementPeer::PROFILE_PROPERTY_ID, $inverseProfilePropertyId); $c->add(SchemaPropertyElementPeer::OBJECT, $property->getUri()); $recipElement = SchemaPropertyElementPeer::doSelectOne($c, $con); $recipSchemaProperty = SchemaPropertyPeer::retrieveByPK($relatedPropertyId, $con); $recipProfileProperty = ProfilePropertyPeer::retrieveByPK($inverseProfilePropertyId, $con); $statusId = $this->getStatusId(); $language = ''; if ($recipProfileProperty) { $recipField = $recipProfileProperty->getName(); if ($recipProfileProperty->getHasLanguage()) { $language = $this->getLanguage(); } } //if action == deleted then if ('deleted' == $action && $recipElement) { //delete the reciprocal $recipElement->delete($con); return; } //undelete the element if it's deleted and we get this far if (isset($recipElement)) { $recipElement->setDeletedAt(null); } //if action == added, and reciprocal doesn't exist if ('added' == $action && !$recipElement) { //add the reciprocal $recipElement = SchemaPropertyElementPeer::createElement($recipSchemaProperty, $userId, $inverseProfilePropertyId, $statusId, $language, false, true); } //if action == updated if ('updated' == $action) { //check to see if there's a reciprocal if (!$recipElement) { //create a new one $recipElement = SchemaPropertyElementPeer::createElement($recipSchemaProperty, $userId, $inverseProfilePropertyId, $statusId, $language, false, true); } } if ($recipElement) { if (isset($this->importId)) { $recipElement->importId = $this->importId; } $recipElement->setUpdatedUserId($userId); $recipElement->setRelatedSchemaPropertyId($schemaPropertyID); $recipElement->setObject($this->getSchemaPropertyRelatedBySchemaPropertyId()->getUri()); $recipElement->save($con); } return; }
/** * Selects a collection of SchemaPropertyElementHistory objects pre-filled with all related objects except FileImportHistory. * * @return array Array of SchemaPropertyElementHistory objects. * @throws PropelException Any exceptions caught during processing will be * rethrown wrapped into a PropelException. */ public static function doSelectJoinAllExceptFileImportHistory(Criteria $c, $con = null) { $c = clone $c; // Set the correct dbName if it has not been overridden // $c->getDbName() will return the same object if not set to another value // so == check is okay and faster if ($c->getDbName() == Propel::getDefaultDB()) { $c->setDbName(self::DATABASE_NAME); } SchemaPropertyElementHistoryPeer::addSelectColumns($c); $startcol2 = SchemaPropertyElementHistoryPeer::NUM_COLUMNS - SchemaPropertyElementHistoryPeer::NUM_LAZY_LOAD_COLUMNS + 1; UserPeer::addSelectColumns($c); $startcol3 = $startcol2 + UserPeer::NUM_COLUMNS; SchemaPropertyElementPeer::addSelectColumns($c); $startcol4 = $startcol3 + SchemaPropertyElementPeer::NUM_COLUMNS; SchemaPropertyPeer::addSelectColumns($c); $startcol5 = $startcol4 + SchemaPropertyPeer::NUM_COLUMNS; SchemaPeer::addSelectColumns($c); $startcol6 = $startcol5 + SchemaPeer::NUM_COLUMNS; ProfilePropertyPeer::addSelectColumns($c); $startcol7 = $startcol6 + ProfilePropertyPeer::NUM_COLUMNS; SchemaPropertyPeer::addSelectColumns($c); $startcol8 = $startcol7 + SchemaPropertyPeer::NUM_COLUMNS; StatusPeer::addSelectColumns($c); $startcol9 = $startcol8 + StatusPeer::NUM_COLUMNS; $c->addJoin(SchemaPropertyElementHistoryPeer::CREATED_USER_ID, UserPeer::ID); $c->addJoin(SchemaPropertyElementHistoryPeer::SCHEMA_PROPERTY_ELEMENT_ID, SchemaPropertyElementPeer::ID); $c->addJoin(SchemaPropertyElementHistoryPeer::SCHEMA_PROPERTY_ID, SchemaPropertyPeer::ID); $c->addJoin(SchemaPropertyElementHistoryPeer::SCHEMA_ID, SchemaPeer::ID); $c->addJoin(SchemaPropertyElementHistoryPeer::PROFILE_PROPERTY_ID, ProfilePropertyPeer::ID); $c->addJoin(SchemaPropertyElementHistoryPeer::RELATED_SCHEMA_PROPERTY_ID, SchemaPropertyPeer::ID); $c->addJoin(SchemaPropertyElementHistoryPeer::STATUS_ID, StatusPeer::ID); $rs = BasePeer::doSelect($c, $con); $results = array(); while ($rs->next()) { $omClass = SchemaPropertyElementHistoryPeer::getOMClass(); $cls = Propel::import($omClass); $obj1 = new $cls(); $obj1->hydrate($rs); $omClass = UserPeer::getOMClass(); $cls = Propel::import($omClass); $obj2 = new $cls(); $obj2->hydrate($rs, $startcol2); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj2 = $temp_obj1->getUser(); //CHECKME if ($temp_obj2->getPrimaryKey() === $obj2->getPrimaryKey()) { $newObject = false; $temp_obj2->addSchemaPropertyElementHistory($obj1); break; } } if ($newObject) { $obj2->initSchemaPropertyElementHistorys(); $obj2->addSchemaPropertyElementHistory($obj1); } $omClass = SchemaPropertyElementPeer::getOMClass(); $cls = Propel::import($omClass); $obj3 = new $cls(); $obj3->hydrate($rs, $startcol3); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj3 = $temp_obj1->getSchemaPropertyElement(); //CHECKME if ($temp_obj3->getPrimaryKey() === $obj3->getPrimaryKey()) { $newObject = false; $temp_obj3->addSchemaPropertyElementHistory($obj1); break; } } if ($newObject) { $obj3->initSchemaPropertyElementHistorys(); $obj3->addSchemaPropertyElementHistory($obj1); } $omClass = SchemaPropertyPeer::getOMClass(); $cls = Propel::import($omClass); $obj4 = new $cls(); $obj4->hydrate($rs, $startcol4); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj4 = $temp_obj1->getSchemaPropertyRelatedBySchemaPropertyId(); //CHECKME if ($temp_obj4->getPrimaryKey() === $obj4->getPrimaryKey()) { $newObject = false; $temp_obj4->addSchemaPropertyElementHistoryRelatedBySchemaPropertyId($obj1); break; } } if ($newObject) { $obj4->initSchemaPropertyElementHistorysRelatedBySchemaPropertyId(); $obj4->addSchemaPropertyElementHistoryRelatedBySchemaPropertyId($obj1); } $omClass = SchemaPeer::getOMClass(); $cls = Propel::import($omClass); $obj5 = new $cls(); $obj5->hydrate($rs, $startcol5); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj5 = $temp_obj1->getSchema(); //CHECKME if ($temp_obj5->getPrimaryKey() === $obj5->getPrimaryKey()) { $newObject = false; $temp_obj5->addSchemaPropertyElementHistory($obj1); break; } } if ($newObject) { $obj5->initSchemaPropertyElementHistorys(); $obj5->addSchemaPropertyElementHistory($obj1); } $omClass = ProfilePropertyPeer::getOMClass(); $cls = Propel::import($omClass); $obj6 = new $cls(); $obj6->hydrate($rs, $startcol6); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj6 = $temp_obj1->getProfileProperty(); //CHECKME if ($temp_obj6->getPrimaryKey() === $obj6->getPrimaryKey()) { $newObject = false; $temp_obj6->addSchemaPropertyElementHistory($obj1); break; } } if ($newObject) { $obj6->initSchemaPropertyElementHistorys(); $obj6->addSchemaPropertyElementHistory($obj1); } $omClass = SchemaPropertyPeer::getOMClass(); $cls = Propel::import($omClass); $obj7 = new $cls(); $obj7->hydrate($rs, $startcol7); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj7 = $temp_obj1->getSchemaPropertyRelatedByRelatedSchemaPropertyId(); //CHECKME if ($temp_obj7->getPrimaryKey() === $obj7->getPrimaryKey()) { $newObject = false; $temp_obj7->addSchemaPropertyElementHistoryRelatedByRelatedSchemaPropertyId($obj1); break; } } if ($newObject) { $obj7->initSchemaPropertyElementHistorysRelatedByRelatedSchemaPropertyId(); $obj7->addSchemaPropertyElementHistoryRelatedByRelatedSchemaPropertyId($obj1); } $omClass = StatusPeer::getOMClass(); $cls = Propel::import($omClass); $obj8 = new $cls(); $obj8->hydrate($rs, $startcol8); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj8 = $temp_obj1->getStatus(); //CHECKME if ($temp_obj8->getPrimaryKey() === $obj8->getPrimaryKey()) { $newObject = false; $temp_obj8->addSchemaPropertyElementHistory($obj1); break; } } if ($newObject) { $obj8->initSchemaPropertyElementHistorys(); $obj8->addSchemaPropertyElementHistory($obj1); } $results[] = $obj1; } return $results; }
/** * Get the associated SchemaPropertyElement object * * @param Connection Optional Connection object. * @return SchemaPropertyElement The associated SchemaPropertyElement object. * @throws PropelException */ public function getSchemaPropertyElement($con = null) { if ($this->aSchemaPropertyElement === null && $this->schema_property_element_id !== null) { // include the related Peer class include_once 'lib/model/om/BaseSchemaPropertyElementPeer.php'; $this->aSchemaPropertyElement = SchemaPropertyElementPeer::retrieveByPK($this->schema_property_element_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 = SchemaPropertyElementPeer::retrieveByPK($this->schema_property_element_id, $con); $obj->addSchemaPropertyElements($this); */ } return $this->aSchemaPropertyElement; }
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) }
if (!isset($schema)) { if ($schema_property) { $objectId = $schema_property->getId(); $schema = $schema_property->getSchema(); } } break; case 'schemapropel': $showBc = true; $showSchemaBc = true; $showSchemaPropBc = true; $showSchemaPropelBc = true; if (!isset($schema_property_element)) { $id = 'show' == $action ? $sf_params->get('id') : $paramId; if ($id) { $schema_property_element = SchemaPropertyElementPeer::retrieveByPK($id); } } if (!isset($schema_property)) { if ($schema_property_element) { $schema_property = $schema_property_element->getSchemaPropertyRelatedBySchemaPropertyId(); } } if (!isset($schema)) { if ($schema_property) { $schema = $schema_property->getSchema(); } } if ($schema_property_element) { $objectId = $schema_property_element->getId(); }
/** * @param $key * @param $value * @param $propertyId * @param $updateTime * @param $rowStatusId * @param $cellLanguage * @param $cellType * @param $schemaId * * @return array $results * @throws \PropelException */ private function SetPropertyElement( $key, $value, $propertyId, $updateTime, $rowStatusId, $cellLanguage, $cellType ) { $profilePropertyId = $this->prolog['columns'][$key]['id']; if (is_array($profilePropertyId)) { $profilePropertyId = $profilePropertyId[0]; } //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 contain the identifier for the triple //actually there is. We look for exact matches and skip the update of an exact match, //but then we look at just the old properties that are left -- the ones where the property matches but the object doesn't //and we update those. If we have any properties left after that, we add them as new. //We need to add an instruction to the spreadsheet to treat an empty property cell as a skip or a delete //and if an empty cell means delete, then we delete those //get the language for this thing //if there's a prolog set for the language for this column, use it //use the default for the import (already set above) //fall back to the default language of the vocabulary //get the fqn if using curies if ($cellType and $this->useCuries) { $value = $this->getFqn($value); } $StatementCounter['status'] = 'skipped'; /** @var \SchemaPropertyElement[] $element */ $element = \SchemaPropertyElementPeer::lookupElement($propertyId, $profilePropertyId, $value, $cellLanguage); if ($element) { if (1 === count($element)) { $element = $element[0]; //make sure we handle the special case of subproperty and subclass if (empty( $value ) && $element->getIsSchemaProperty() && in_array($element->getProfilePropertyId(), [ 6, 9 ]) ) { return $StatementCounter; } } else { //it's ambiguous and we stop processing, logging an error to be dealt with later $error['Message'] = "Ambiguous update"; $error['PropertyId'] = $propertyId; $error['ProfilePropertyId'] = $profilePropertyId; $error['UpdateValue'] = $value; $this->results['errors'][] = $error; } } //create a new propertyelement for each unmatched column //we didn't find an existing element, make a new one if ( ! $element && ! empty( $value )) { $element = new \SchemaPropertyElement; $element->setCreatedUserId($this->userId); $element->setCreatedAt($updateTime); $element->setProfilePropertyId($profilePropertyId); $element->setSchemaPropertyId($propertyId); $StatementCounter['status'] = 'created'; } if ( ! $element) { return $StatementCounter; } if (( $value != $element->getObject() ) || ( $cellLanguage != $element->getLanguage() )) { /** * @todo We need a check here for objectproperties and handle differently * if it's a URI, and it uses namespaces, and we have the namespace, do the substitution **/ if ( ! $cellType and $cellLanguage) { if ($cellLanguage != $element->getLanguage()) { $element->setLanguage($cellLanguage); } } } if ($value != $element->getObject()) { if ( ! empty( $value )) { $element->setObject($value); } else { $element->setDeletedAt($updateTime); } } if ($element->isNew() or $element->isModified()) { $element->setUpdatedUserId($this->userId); $element->setUpdatedAt($updateTime); $element->setStatusId($rowStatusId); $element->importId = $this->importId; $element->save(); if ($StatementCounter['status'] != 'created') { $StatementCounter['status'] = 'modified'; } if (is_array($element->getProfilePropertyId())) { $profilePropertyId = $element->getProfilePropertyId()[0]; } else { $profilePropertyId = $element->getProfilePropertyId(); } /** @var \ProfileProperty $profileProperty */ $profileProperty = $this->profileProperties[$profilePropertyId]; $StatementCounter['column'] = $key; $StatementCounter['id'] = $element->getId(); $StatementCounter['propertyId'] = $element->getProfilePropertyId(); $StatementCounter['object'] = $element->getObject(); $StatementCounter['type'] = $cellType; $StatementCounter['language'] = $cellLanguage; } unset( $element ); return $StatementCounter; }
/** * gets repeatable or unused profile properties for a resource property element * * @return array * @param criteria $criteria */ public static function getProfilePropertiesForCreate($criteria = null) { if ($criteria === null) { $criteria = new Criteria(); } elseif ($criteria instanceof Criteria) { $criteria = clone $criteria; } //get the current property ID //create should always have a property id $propertyId = sfContext::getInstance()->getRequest()->getParameter('schema_property_id'); //get the current property if ($propertyId) { $schemaProperty = SchemaPropertyPeer::retrieveByPK($propertyId); if ('class' == $schemaProperty->getType() || 'subclass' == $schemaProperty->getType()) { $criteria->add(ProfilePropertyPeer::IS_IN_CLASS_PICKLIST, 1); } else { $criteria->add(ProfilePropertyPeer::IS_IN_PROPERTY_PICKLIST, 1); } } //properties for the metadata registry schema are currently related to profile '1' $criteria->add(ProfilePropertyPeer::PROFILE_ID, 1); $criteria->add(ProfilePropertyPeer::IS_IN_PICKLIST, 1); $criteria->addAscendingOrderByColumn(ProfilePropertyPeer::URI); //get the list of all properties for this profile/namespace //at some point this should look at the property or schema namespace $profileProperties = self::doSelect($criteria); $propertyList = array(); $pickList = array(); foreach ($profileProperties as $key => $property) { $propertyList[$property->getId()] = $property; $pickList[$property->getId()] = $property->getLabel(); } //get the property elements already in use for this property $c = new Criteria(); $c->add(SchemaPropertyElementPeer::SCHEMA_PROPERTY_ID, $propertyId); $c->add(SchemaPropertyElementPeer::IS_SCHEMA_PROPERTY, true); $elements = SchemaPropertyElementPeer::doSelect($c); foreach ($elements as $key => $element) { $propertyId = $element->getProfilePropertyId(); //if the property is in the list and not repeatable /** @var ProfileProperty **/ if (isset($propertyList[$propertyId]) && $propertyList[$propertyId]->getIsSingleton()) { //remove it from the list of all properties unset($pickList[$propertyId]); unset($propertyList[$propertyId]); } } return $propertyList; //whatever remains in the list }
/** * If this collection has already been initialized with * an identical criteria, it returns the collection. * Otherwise if this SchemaProperty is new, it will return * an empty collection; or if this SchemaProperty has previously * been saved, it will retrieve related SchemaPropertyElementsRelatedByRelatedSchemaPropertyId from storage. * * This method is protected by default in order to keep the public * api reasonable. You can provide public methods for those you * actually need in SchemaProperty. */ public function getSchemaPropertyElementsRelatedByRelatedSchemaPropertyIdJoinStatus($criteria = null, $con = null) { // include the Peer class include_once 'lib/model/om/BaseSchemaPropertyElementPeer.php'; if ($criteria === null) { $criteria = new Criteria(); } elseif ($criteria instanceof Criteria) { $criteria = clone $criteria; } if ($this->collSchemaPropertyElementsRelatedByRelatedSchemaPropertyId === null) { if ($this->isNew()) { $this->collSchemaPropertyElementsRelatedByRelatedSchemaPropertyId = array(); } else { $criteria->add(SchemaPropertyElementPeer::RELATED_SCHEMA_PROPERTY_ID, $this->getId()); $this->collSchemaPropertyElementsRelatedByRelatedSchemaPropertyId = SchemaPropertyElementPeer::doSelectJoinStatus($criteria, $con); } } else { // the following code is to determine if a new query is // called for. If the criteria is the same as the last // one, just return the collection. $criteria->add(SchemaPropertyElementPeer::RELATED_SCHEMA_PROPERTY_ID, $this->getId()); if (!isset($this->lastSchemaPropertyElementRelatedByRelatedSchemaPropertyIdCriteria) || !$this->lastSchemaPropertyElementRelatedByRelatedSchemaPropertyIdCriteria->equals($criteria)) { $this->collSchemaPropertyElementsRelatedByRelatedSchemaPropertyId = SchemaPropertyElementPeer::doSelectJoinStatus($criteria, $con); } } $this->lastSchemaPropertyElementRelatedByRelatedSchemaPropertyIdCriteria = $criteria; return $this->collSchemaPropertyElementsRelatedByRelatedSchemaPropertyId; }
/** * * @return Schema */ private static function getSchema() { $currentPropertyId = sfContext::getInstance()->getRequest()->getParameter('schema_property_id', ''); if ($currentPropertyId) { $schema = SchemaPropertyPeer::retrieveByPK($currentPropertyId)->getSchema(); } else { $schema = sfContext::getInstance()->getUser()->getAttribute('schema'); } if (!$schema) { $id = sfContext::getInstance()->getRequest()->getParameter('id', ''); if ($id) { if ("schemapropel" == sfContext::getInstance()->getModuleName()) { $schema = SchemaPropertyElementPeer::retrieveByPK($id)->getSchemaPropertyRelatedBySchemaPropertyId()->getSchema(); } else { $schema = self::retrieveByPK($id)->getSchema(); } } } return $schema; }
/** * Populates the object using an array. * * This is particularly useful when populating an object from one of the * request arrays (e.g. $_POST). This method goes through the column * names, checking to see whether a matching key exists in populated * array. If so the setByName() method is called for that column. * * You can specify the key type of the array by additionally passing one * of the class type constants TYPE_PHPNAME, TYPE_COLNAME, TYPE_FIELDNAME, * TYPE_NUM. The default key type is the column's phpname (e.g. 'authorId') * * @param array $arr An array to populate the object from. * @param string $keyType The type of keys the array uses. * @return void */ public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME) { $keys = SchemaPropertyElementPeer::getFieldNames($keyType); if (array_key_exists($keys[0], $arr)) { $this->setId($arr[$keys[0]]); } if (array_key_exists($keys[1], $arr)) { $this->setCreatedAt($arr[$keys[1]]); } if (array_key_exists($keys[2], $arr)) { $this->setUpdatedAt($arr[$keys[2]]); } if (array_key_exists($keys[3], $arr)) { $this->setDeletedAt($arr[$keys[3]]); } if (array_key_exists($keys[4], $arr)) { $this->setCreatedUserId($arr[$keys[4]]); } if (array_key_exists($keys[5], $arr)) { $this->setUpdatedUserId($arr[$keys[5]]); } if (array_key_exists($keys[6], $arr)) { $this->setSchemaPropertyId($arr[$keys[6]]); } if (array_key_exists($keys[7], $arr)) { $this->setProfilePropertyId($arr[$keys[7]]); } if (array_key_exists($keys[8], $arr)) { $this->setIsSchemaProperty($arr[$keys[8]]); } if (array_key_exists($keys[9], $arr)) { $this->setObject($arr[$keys[9]]); } if (array_key_exists($keys[10], $arr)) { $this->setRelatedSchemaPropertyId($arr[$keys[10]]); } if (array_key_exists($keys[11], $arr)) { $this->setLanguage($arr[$keys[11]]); } if (array_key_exists($keys[12], $arr)) { $this->setStatusId($arr[$keys[12]]); } if (array_key_exists($keys[13], $arr)) { $this->setIsGenerated($arr[$keys[13]]); } }
/** * Retrieve multiple objects by pkey. * * @param array $pks List of primary keys * @param Connection $con the connection to use * @throws PropelException Any exceptions caught during processing will be * rethrown wrapped into a PropelException. */ public static function retrieveByPKs($pks, $con = null) { if ($con === null) { $con = Propel::getConnection(self::DATABASE_NAME); } $objs = null; if (empty($pks)) { $objs = array(); } else { $criteria = new Criteria(); $criteria->add(SchemaPropertyElementPeer::ID, $pks, Criteria::IN); $objs = SchemaPropertyElementPeer::doSelect($criteria, $con); } return $objs; }
/** * Selects a collection of Discuss objects pre-filled with all related objects except DiscussRelatedByParentId. * * @return array Array of Discuss objects. * @throws PropelException Any exceptions caught during processing will be * rethrown wrapped into a PropelException. */ public static function doSelectJoinAllExceptDiscussRelatedByParentId(Criteria $c, $con = null) { $c = clone $c; // Set the correct dbName if it has not been overridden // $c->getDbName() will return the same object if not set to another value // so == check is okay and faster if ($c->getDbName() == Propel::getDefaultDB()) { $c->setDbName(self::DATABASE_NAME); } DiscussPeer::addSelectColumns($c); $startcol2 = DiscussPeer::NUM_COLUMNS - DiscussPeer::NUM_LAZY_LOAD_COLUMNS + 1; UserPeer::addSelectColumns($c); $startcol3 = $startcol2 + UserPeer::NUM_COLUMNS; UserPeer::addSelectColumns($c); $startcol4 = $startcol3 + UserPeer::NUM_COLUMNS; SchemaPeer::addSelectColumns($c); $startcol5 = $startcol4 + SchemaPeer::NUM_COLUMNS; SchemaPropertyPeer::addSelectColumns($c); $startcol6 = $startcol5 + SchemaPropertyPeer::NUM_COLUMNS; SchemaPropertyElementPeer::addSelectColumns($c); $startcol7 = $startcol6 + SchemaPropertyElementPeer::NUM_COLUMNS; VocabularyPeer::addSelectColumns($c); $startcol8 = $startcol7 + VocabularyPeer::NUM_COLUMNS; ConceptPeer::addSelectColumns($c); $startcol9 = $startcol8 + ConceptPeer::NUM_COLUMNS; ConceptPropertyPeer::addSelectColumns($c); $startcol10 = $startcol9 + ConceptPropertyPeer::NUM_COLUMNS; $c->addJoin(DiscussPeer::CREATED_USER_ID, UserPeer::ID); $c->addJoin(DiscussPeer::DELETED_USER_ID, UserPeer::ID); $c->addJoin(DiscussPeer::SCHEMA_ID, SchemaPeer::ID); $c->addJoin(DiscussPeer::SCHEMA_PROPERTY_ID, SchemaPropertyPeer::ID); $c->addJoin(DiscussPeer::SCHEMA_PROPERTY_ELEMENT_ID, SchemaPropertyElementPeer::ID); $c->addJoin(DiscussPeer::VOCABULARY_ID, VocabularyPeer::ID); $c->addJoin(DiscussPeer::CONCEPT_ID, ConceptPeer::ID); $c->addJoin(DiscussPeer::CONCEPT_PROPERTY_ID, ConceptPropertyPeer::ID); $rs = BasePeer::doSelect($c, $con); $results = array(); while ($rs->next()) { $omClass = DiscussPeer::getOMClass(); $cls = Propel::import($omClass); $obj1 = new $cls(); $obj1->hydrate($rs); $omClass = UserPeer::getOMClass(); $cls = Propel::import($omClass); $obj2 = new $cls(); $obj2->hydrate($rs, $startcol2); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj2 = $temp_obj1->getUserRelatedByCreatedUserId(); //CHECKME if ($temp_obj2->getPrimaryKey() === $obj2->getPrimaryKey()) { $newObject = false; $temp_obj2->addDiscussRelatedByCreatedUserId($obj1); break; } } if ($newObject) { $obj2->initDiscusssRelatedByCreatedUserId(); $obj2->addDiscussRelatedByCreatedUserId($obj1); } $omClass = UserPeer::getOMClass(); $cls = Propel::import($omClass); $obj3 = new $cls(); $obj3->hydrate($rs, $startcol3); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj3 = $temp_obj1->getUserRelatedByDeletedUserId(); //CHECKME if ($temp_obj3->getPrimaryKey() === $obj3->getPrimaryKey()) { $newObject = false; $temp_obj3->addDiscussRelatedByDeletedUserId($obj1); break; } } if ($newObject) { $obj3->initDiscusssRelatedByDeletedUserId(); $obj3->addDiscussRelatedByDeletedUserId($obj1); } $omClass = SchemaPeer::getOMClass(); $cls = Propel::import($omClass); $obj4 = new $cls(); $obj4->hydrate($rs, $startcol4); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj4 = $temp_obj1->getSchema(); //CHECKME if ($temp_obj4->getPrimaryKey() === $obj4->getPrimaryKey()) { $newObject = false; $temp_obj4->addDiscuss($obj1); break; } } if ($newObject) { $obj4->initDiscusss(); $obj4->addDiscuss($obj1); } $omClass = SchemaPropertyPeer::getOMClass(); $cls = Propel::import($omClass); $obj5 = new $cls(); $obj5->hydrate($rs, $startcol5); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj5 = $temp_obj1->getSchemaProperty(); //CHECKME if ($temp_obj5->getPrimaryKey() === $obj5->getPrimaryKey()) { $newObject = false; $temp_obj5->addDiscuss($obj1); break; } } if ($newObject) { $obj5->initDiscusss(); $obj5->addDiscuss($obj1); } $omClass = SchemaPropertyElementPeer::getOMClass(); $cls = Propel::import($omClass); $obj6 = new $cls(); $obj6->hydrate($rs, $startcol6); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj6 = $temp_obj1->getSchemaPropertyElement(); //CHECKME if ($temp_obj6->getPrimaryKey() === $obj6->getPrimaryKey()) { $newObject = false; $temp_obj6->addDiscuss($obj1); break; } } if ($newObject) { $obj6->initDiscusss(); $obj6->addDiscuss($obj1); } $omClass = VocabularyPeer::getOMClass(); $cls = Propel::import($omClass); $obj7 = new $cls(); $obj7->hydrate($rs, $startcol7); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj7 = $temp_obj1->getVocabulary(); //CHECKME if ($temp_obj7->getPrimaryKey() === $obj7->getPrimaryKey()) { $newObject = false; $temp_obj7->addDiscuss($obj1); break; } } if ($newObject) { $obj7->initDiscusss(); $obj7->addDiscuss($obj1); } $omClass = ConceptPeer::getOMClass(); $cls = Propel::import($omClass); $obj8 = new $cls(); $obj8->hydrate($rs, $startcol8); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj8 = $temp_obj1->getConcept(); //CHECKME if ($temp_obj8->getPrimaryKey() === $obj8->getPrimaryKey()) { $newObject = false; $temp_obj8->addDiscuss($obj1); break; } } if ($newObject) { $obj8->initDiscusss(); $obj8->addDiscuss($obj1); } $omClass = ConceptPropertyPeer::getOMClass(); $cls = Propel::import($omClass); $obj9 = new $cls(); $obj9->hydrate($rs, $startcol9); $newObject = true; for ($j = 0, $resCount = count($results); $j < $resCount; $j++) { $temp_obj1 = $results[$j]; $temp_obj9 = $temp_obj1->getConceptProperty(); //CHECKME if ($temp_obj9->getPrimaryKey() === $obj9->getPrimaryKey()) { $newObject = false; $temp_obj9->addDiscuss($obj1); break; } } if ($newObject) { $obj9->initDiscusss(); $obj9->addDiscuss($obj1); } $results[] = $obj1; } return $results; }