public function delete($connection = null)
{
// Cascade delete descendants
if (0 < count($children = $this->getChildren())) {
foreach ($children as $child) {
$child->delete($connection);
}
}
// Delete relations
$criteria = new Criteria();
$cton1 = $criteria->getNewCriterion(QubitRelation::OBJECT_ID, $this->id);
$cton2 = $criteria->getNewCriterion(QubitRelation::SUBJECT_ID, $this->id);
$cton1->addOr($cton2);
$criteria->add($cton1);
if (0 < count($relations = QubitRelation::get($criteria))) {
foreach ($relations as $relation) {
$relation->delete($connection);
}
}
// Delete relation to objects
$criteria = new Criteria();
$criteria->add(QubitObjectTermRelation::TERM_ID, $this->id);
if (0 < count($otRelations = QubitObjectTermRelation::get($criteria))) {
foreach ($otRelations as $otRelation) {
$otRelation->delete($connection);
}
}
parent::delete($connection);
}
public function execute($request)
{
$this->resource = $request->getAttribute('sf_route')->resource;
$criteria = new Criteria();
$criteria->add(QubitEvent::ACTOR_ID, $this->resource->id);
$criteria->addJoin(QubitEvent::INFORMATION_OBJECT_ID, QubitInformationObject::ID);
$criteria->addAscendingOrderByColumn(QubitEvent::TYPE_ID);
// Sort info objects alphabetically (w/ fallback)
$criteria->addAscendingOrderByColumn('title');
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitInformationObject');
// Filter draft descriptions
$criteria = QubitAcl::addFilterDraftsCriteria($criteria);
$this->relatedInfoObjects = array();
foreach (QubitEvent::get($criteria) as $item) {
$this->relatedInfoObjects[$item->type->getRole()][] = $item->informationObject;
}
// Get "subject of" information objects (name access point)
$criteria = new Criteria();
$criteria->add(QubitRelation::OBJECT_ID, $this->resource->id);
$criteria->add(QubitRelation::TYPE_ID, QubitTerm::NAME_ACCESS_POINT_ID);
$this->subjectInfoObjects = array();
foreach (QubitRelation::get($criteria) as $item) {
$this->subjectInfoObjects[] = $item->subject;
}
}
public function __get($name)
{
switch ($name) {
case '_maintenanceNote':
if (!isset($this->maintenanceNote)) {
$criteria = new Criteria();
$criteria->add(QubitNote::OBJECT_ID, $this->resource->id);
$criteria->add(QubitNote::TYPE_ID, QubitTerm::MAINTENANCE_NOTE_ID);
if (1 == count($query = QubitNote::get($criteria))) {
$this->maintenanceNote = $query[0];
} else {
$this->maintenanceNote = new QubitNote();
$this->maintenanceNote->typeId = QubitTerm::MAINTENANCE_NOTE_ID;
$this->resource->notes[] = $this->maintenanceNote;
}
}
return $this->maintenanceNote;
case 'maintenanceNotes':
return $this->_maintenanceNote->content;
case 'relatedAuthorityRecord':
if (!isset($this->relatedAuthorityRecord)) {
$criteria = new Criteria();
$criteria->add(QubitRelation::SUBJECT_ID, $this->resource->id);
$criteria->addJoin(QubitRelation::OBJECT_ID, QubitActor::ID);
$this->relatedAuthorityRecord = QubitRelation::get($criteria);
}
return $this->relatedAuthorityRecord;
case 'relatedFunction':
if (!isset($this->relatedFunction)) {
$criteria = new Criteria();
$criteria->add($criteria->getNewCriterion(QubitRelation::OBJECT_ID, $this->resource->id)->addOr($criteria->getNewCriterion(QubitRelation::SUBJECT_ID, $this->resource->id)));
$criteria->addAlias('ro', QubitFunction::TABLE_NAME);
$criteria->addJoin(QubitRelation::OBJECT_ID, 'ro.id');
$criteria->addAlias('rs', QubitFunction::TABLE_NAME);
$criteria->addJoin(QubitRelation::SUBJECT_ID, 'rs.id');
$criteria->addAscendingOrderByColumn(QubitRelation::TYPE_ID);
$this->relatedFunction = QubitRelation::get($criteria);
}
return $this->relatedFunction;
case 'relatedResource':
if (!isset($this->relatedResource)) {
$criteria = new Criteria();
$criteria->add(QubitRelation::SUBJECT_ID, $this->resource->id);
$criteria->addJoin(QubitRelation::OBJECT_ID, QubitInformationObject::ID);
$this->relatedResource = QubitRelation::get($criteria);
}
return $this->relatedResource;
case 'sourceCulture':
return $this->resource->sourceCulture;
}
}
public function execute($request)
{
parent::execute($request);
$this->isad = new sfIsadPlugin($this->resource);
if (1 > strlen($title = $this->resource)) {
$title = $this->context->i18n->__('Untitled');
}
$this->response->setTitle("{$title} - {$this->response->getTitle()}");
// Function relations
$criteria = new Criteria();
$criteria->add(QubitRelation::OBJECT_ID, $this->resource->id);
$criteria->addJoin(QubitRelation::SUBJECT_ID, QubitFunction::ID);
$this->functionRelations = QubitRelation::get($criteria);
if (QubitAcl::check($this->resource, 'update')) {
$validatorSchema = new sfValidatorSchema();
$values = array();
$validatorSchema->creators = new QubitValidatorCountable(array('required' => true), array('required' => $this->context->i18n->__('This archival description, or one of its higher levels, %1%requires%2% at least one %3%creator%4%.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#I.12">', '%2%' => '</a>', '%3%' => '<a href="http://ica-atom.org/doc/RS-1#3.2.1">', '%4%' => '</a>'))));
foreach ($this->resource->ancestors->andSelf()->orderBy('rgt') as $item) {
$values['creators'] = $item->getCreators();
if (0 < count($values['creators'])) {
break;
}
}
$validatorSchema->dateRange = new QubitValidatorIsadDates(array(), array('invalid' => $this->context->i18n->__('%1%Date(s)%2% - are not consistent with %3%higher levels%2%.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#3.1.3">', '%2%' => '</a>', '%3%' => '<a href="%ancestor%">'))));
$values['dateRange'] = $this->resource;
$validatorSchema->dates = new QubitValidatorCountable(array('required' => true), array('required' => $this->context->i18n->__('%1%Date(s)%2% - This is a %3%mandatory%4% element.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#3.1.3">', '%2%' => '</a>', '%3%' => '<a href="http://ica-atom.org/doc/RS-1#I.12">', '%4%' => '</a>'))));
$values['dates'] = $this->resource->getDates();
$validatorSchema->extentAndMedium = new sfValidatorString(array('required' => true), array('required' => $this->context->i18n->__('%1%Extent and medium%2% - This is a %3%mandatory%4% element.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#3.1.5">', '%2%' => '</a>', '%3%' => '<a href="http://ica-atom.org/doc/RS-1#I.12">', '%4%' => '</a>'))));
$values['extentAndMedium'] = $this->resource->getExtentAndMedium(array('cultureFallback' => true));
$validatorSchema->identifier = new sfValidatorString(array('required' => true), array('required' => $this->context->i18n->__('%1%Identifier%2% - This is a %3%mandatory%4% element.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#3.1.1">', '%2%' => '</a>', '%3%' => '<a href="http://ica-atom.org/doc/RS-1#I.12">', '%4%' => '</a>'))));
$values['identifier'] = $this->resource->identifier;
$this->addField($validatorSchema, 'levelOfDescription');
$validatorSchema->levelOfDescription->setMessage('forbidden', $this->context->i18n->__('%1%Level of description%2% - Value "%value%" is not consistent with higher levels.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#3.1.4">', '%2%' => '</a>')));
$validatorSchema->levelOfDescription->setMessage('required', $this->context->i18n->__('%1%Level of description%2% - This is a %3%mandatory%4% element.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#3.1.4">', '%2%' => '</a>', '%3%' => '<a href="http://ica-atom.org/doc/RS-1#I.12">', '%4%' => '</a>')));
if (isset($this->resource->levelOfDescription)) {
$values['levelOfDescription'] = $this->resource->levelOfDescription->getName(array('sourceCulture' => true));
}
$validatorSchema->title = new sfValidatorString(array('required' => true), array('required' => $this->context->i18n->__('%1%Title%2% - This is a %3%mandatory%4% element.', array('%1%' => '<a href="http://ica-atom.org/doc/RS-1#3.1.2">', '%2%' => '</a>', '%3%' => '<a href="http://ica-atom.org/doc/RS-1#I.12">', '%4%' => '</a>'))));
$values['title'] = $this->resource->getTitle(array('cultureFallback' => true));
try {
$validatorSchema->clean($values);
} catch (sfValidatorErrorSchema $e) {
$this->errorSchema = $e;
}
}
}
public function __get($name)
{
switch ($name) {
case 'biogHist':
return self::toDiscursiveSet($this->resource->history);
case 'entityType':
switch ($this->resource->entityTypeId) {
case QubitTerm::CORPORATE_BODY_ID:
return 'corporateBody';
case QubitTerm::FAMILY_ID:
return 'family';
case QubitTerm::PERSON_ID:
return 'person';
}
return;
case 'existDates':
// TODO <date/>, <dateRange/>, <dateSet/>, <descriptiveNote/>, simple
// natural language parsing?
return '<date>' . esc_specialchars($this->resource->datesOfExistence) . '</date>';
case 'generalContext':
return self::toDiscursiveSet($this->resource->generalContext);
case 'maintenanceHistory':
ProjectConfiguration::getActive()->loadHelpers('Date');
$createdAt = format_date($this->resource->createdAt, 's');
$updatedAt = format_date($this->resource->updatedAt, 's');
$createdDisplay = format_date($this->resource->createdAt, 'F');
$updatedDisplay = format_date($this->resource->updatedAt, 'F');
return <<<return
<maintenanceEvent>
<eventType>created</eventType>
<eventDateTime standardDateTime="{$createdAt}">{$createdDisplay}</eventDateTime>
<agentType>human</agentType>
<agent/>
</maintenanceEvent>
<maintenanceEvent>
<eventType>revised</eventType>
<eventDateTime standardDateTime="{$updatedAt}">{$updatedDisplay}</eventDateTime>
<agentType>human</agentType>
<agent/>
</maintenanceEvent>
return;
case 'maintenanceStatus':
switch (strtolower($this->resource->descriptionStatus)) {
case 'revised':
return 'revised';
default:
return 'new';
}
case 'publicationStatus':
return 'approved';
case 'resourceRelation':
$criteria = new Criteria();
$criteria->add(QubitEvent::ACTOR_ID, $this->resource->id);
$criteria->addJoin(QubitEvent::INFORMATION_OBJECT_ID, QubitInformationObject::ID);
return QubitEvent::get($criteria);
case 'functionRelation':
$criteria = new Criteria();
$criteria->addAlias('subj', QubitObject::TABLE_NAME);
$criteria->addJoin(QubitRelation::SUBJECT_ID, 'subj.id');
$criteria->add(QubitRelation::OBJECT_ID, $this->resource->id);
$criteria->add('subj.class_name', 'QubitFunction');
return QubitRelation::get($criteria);
case 'structureOrGenealogy':
return self::toDiscursiveSet($this->resource->internalStructures);
}
}
/**
* Get actor-to-actor relations linked to this actor
*
* @return QubitQuery collection of QubitRelation objects
*/
public function getActorRelations()
{
$criteria = new Criteria();
$criteria->addJoin(QubitRelation::TYPE_ID, QubitTerm::ID);
$criteria->add($criteria->getNewCriterion(QubitRelation::OBJECT_ID, $this->id)->addOr($criteria->getNewCriterion(QubitRelation::SUBJECT_ID, $this->id))->addAnd($criteria->getNewCriterion(QubitTerm::TAXONOMY_ID, QubitTaxonomy::ACTOR_RELATION_TYPE_ID)));
$criteria->addAscendingOrderByColumn(QubitRelation::TYPE_ID);
$criteria->addDescendingOrderByColumn(QubitRelation::START_DATE);
return QubitRelation::get($criteria);
}
public function getNameAccessPointsString($options = array())
{
$nameAccessPointString = '';
$criteria = new Criteria();
$criteria->add(QubitRelation::SUBJECT_ID, $this->id);
$criteria->add(QubitRelation::TYPE_ID, QubitTerm::NAME_ACCESS_POINT_ID);
$culture = isset($options['culture']) ? $options['culture'] : sfContext::getInstance()->user->getCulture();
foreach ($this->nameAccessPoints = QubitRelation::get($criteria) as $name) {
$nameAccessPointString .= $name->object->getAuthorizedFormOfName(array('culture' => $culture)) . ' ';
}
return $nameAccessPointString;
}
public function __get($name)
{
switch ($name) {
case '_event':
// Because simple Dublin Core cannot qualify the <date/> or <coverage/>
// elements, we only return a limited set of events: just those that
// are related to creation/origination
$event = array();
foreach ($this->resource->events as $item) {
switch ($item->typeId) {
case QubitTerm::CREATION_ID:
case QubitTerm::CONTRIBUTION_ID:
case QubitTerm::PUBLICATION_ID:
case QubitTerm::COLLECTION_ID:
case QubitTerm::ACCUMULATION_ID:
$event[] = $item;
break;
}
}
return $event;
case 'coverage':
$coverage = array();
foreach ($this->resource->events as $item) {
if (null !== ($place = $item->getPlace())) {
$coverage[] = $place;
}
}
foreach ($this->resource->getPlaceAccessPoints() as $item) {
$coverage[] = $item->term;
}
return $coverage;
case 'date':
$list = array();
foreach ($this->_event as $item) {
if (isset($item->startDate)) {
$date = $item->startDate;
if (isset($item->endDate)) {
$date .= "/{$item->endDate}";
}
$list[] = $date;
}
}
return $list;
case 'format':
$format = array();
if (null !== ($digitalObject = $this->resource->getDigitalObject())) {
if (isset($digitalObject->mimeType)) {
$format[] = $digitalObject->mimeType;
}
}
if (isset($this->resource->extentAndMedium)) {
$format[] = $this->resource->getExtentAndMedium(array('cultureFallback' => true));
}
return $format;
case 'identifier':
return $this->resource->referenceCode;
case 'sourceCulture':
return $this->resource->sourceCulture;
case 'subject':
$subject = array();
foreach ($this->resource->getSubjectAccessPoints() as $item) {
$subject[] = $item->term;
}
// Add name access points
$criteria = new Criteria();
$criteria = $this->resource->addrelationsRelatedBysubjectIdCriteria($criteria);
$criteria->add(QubitRelation::TYPE_ID, QubitTerm::NAME_ACCESS_POINT_ID);
foreach (QubitRelation::get($criteria) as $item) {
$subject[] = $item->object;
}
return $subject;
case 'type':
$type = array();
foreach ($this->resource->getTermRelations(QubitTaxonomy::DC_TYPE_ID) as $item) {
$type[] = $item->term;
}
// Map media type to DCMI type vocabulary
if (null !== ($digitalObject = $this->resource->getDigitalObject())) {
switch ($digitalObject->mediaType) {
case 'Image':
$type[] = 'image';
break;
case 'Video':
$type[] = 'moving image';
break;
case 'Audio':
$type[] = 'sound';
break;
case 'Text':
$type[] = 'text';
break;
}
}
return $type;
}
}
protected function addField($name)
{
switch ($name) {
case 'levelOfDescription':
$this->form->setDefault('levelOfDescription', $this->context->routing->generate(null, array($this->resource->levelOfDescription, 'module' => 'term')));
$this->form->setValidator('levelOfDescription', new sfValidatorString());
$choices = array();
$choices[null] = null;
foreach (QubitTaxonomy::getTaxonomyTerms(QubitTaxonomy::LEVEL_OF_DESCRIPTION_ID) as $item) {
$choices[$this->context->routing->generate(null, array($item, 'module' => 'term'))] = $item;
}
$this->form->setWidget('levelOfDescription', new sfWidgetFormSelect(array('choices' => $choices)));
break;
case 'publicationStatus':
$publicationStatus = $this->resource->getStatus(array('typeId' => QubitTerm::STATUS_TYPE_PUBLICATION_ID));
if (isset($publicationStatus)) {
$this->form->setDefault('publicationStatus', $publicationStatus->statusId);
} else {
$this->form->setDefault('publicationStatus', sfConfig::get('app_defaultPubStatus'));
}
$this->form->setValidator('publicationStatus', new sfValidatorString());
if (isset($this->resource) && QubitAcl::check($this->resource, 'publish') || !isset($this->resurce) && QubitAcl::check($this->parent, 'publish')) {
$choices = array();
foreach (QubitTaxonomy::getTermsById(QubitTaxonomy::PUBLICATION_STATUS_ID) as $item) {
$choices[$item->id] = $item;
}
$this->form->setWidget('publicationStatus', new sfWidgetFormSelect(array('choices' => $choices)));
} else {
$choices = array();
if (isset($publicationStatus)) {
$choices = array($publicationStatus->id => $publicationStatus->status->__toString());
} else {
$status = QubitTerm::getById(sfConfig::get('app_defaultPubStatus'));
$choices = array($status->id => $status->__toString());
}
// Disable widget if user doesn't have "publish" permission
$this->form->setWidget('publicationStatus', new sfWidgetFormSelect(array('choices' => $choices), array('disabled' => true)));
}
break;
case 'repository':
$this->form->setDefault('repository', $this->context->routing->generate(null, array($this->resource->repository, 'module' => 'repository')));
$this->form->setValidator('repository', new sfValidatorString());
$choices = array();
if (isset($this->resource->repository)) {
$choices[$this->context->routing->generate(null, array($this->resource->repository, 'module' => 'repository'))] = $this->resource->repository;
}
$this->form->setWidget('repository', new sfWidgetFormSelect(array('choices' => $choices)));
if (isset($this->getRoute()->resource)) {
$this->repoAcParams = array('module' => 'repository', 'action' => 'autocomplete', 'aclAction' => 'update');
} else {
$this->repoAcParams = array('module' => 'repository', 'action' => 'autocomplete', 'aclAction' => 'create');
}
break;
case 'accessConditions':
case 'accruals':
case 'acquisition':
case 'archivalHistory':
case 'arrangement':
case 'extentAndMedium':
case 'findingAids':
case 'locationOfCopies':
case 'locationOfOriginals':
case 'physicalCharacteristics':
case 'relatedUnitsOfDescription':
case 'reproductionConditions':
case 'revisionHistory':
case 'rules':
case 'scopeAndContent':
case 'sources':
$this->form->setDefault($name, $this->resource[$name]);
$this->form->setValidator($name, new sfValidatorString());
$this->form->setWidget($name, new sfWidgetFormTextarea());
break;
case 'descriptionIdentifier':
case 'identifier':
case 'institutionResponsibleIdentifier':
case 'title':
$this->form->setDefault($name, $this->resource[$name]);
$this->form->setValidator($name, new sfValidatorString());
$this->form->setWidget($name, new sfWidgetFormInput());
break;
case 'subjectAccessPoints':
case 'placeAccessPoints':
$criteria = new Criteria();
$criteria->add(QubitObjectTermRelation::OBJECT_ID, $this->resource->id);
$criteria->addJoin(QubitObjectTermRelation::TERM_ID, QubitTerm::ID);
switch ($name) {
case 'subjectAccessPoints':
$criteria->add(QubitTerm::TAXONOMY_ID, QubitTaxonomy::SUBJECT_ID);
break;
case 'placeAccessPoints':
$criteria->add(QubitTerm::TAXONOMY_ID, QubitTaxonomy::PLACE_ID);
break;
}
$value = $choices = array();
foreach ($this[$name] = QubitObjectTermRelation::get($criteria) as $item) {
$choices[$value[] = $this->context->routing->generate(null, array($item->term, 'module' => 'term'))] = $item->term;
}
$this->form->setDefault($name, $value);
$this->form->setValidator($name, new sfValidatorPass());
$this->form->setWidget($name, new sfWidgetFormSelect(array('choices' => $choices, 'multiple' => true)));
break;
case 'nameAccessPoints':
$criteria = new Criteria();
$criteria->add(QubitRelation::SUBJECT_ID, $this->resource->id);
$criteria->add(QubitRelation::TYPE_ID, QubitTerm::NAME_ACCESS_POINT_ID);
$value = $choices = array();
foreach ($this->nameAccessPoints = QubitRelation::get($criteria) as $item) {
$choices[$value[] = $this->context->routing->generate(null, array($item->object, 'module' => 'actor'))] = $item->object;
}
$this->form->setDefault($name, $value);
$this->form->setValidator($name, new sfValidatorPass());
$this->form->setWidget($name, new sfWidgetFormSelect(array('choices' => $choices, 'multiple' => true)));
break;
default:
return parent::addField($name);
}
}
/**
* Get all relations from/to given object $id
*
* @param integer $id primary key of object
* @param array $options optional parameters
* @return QubitQuery collection of QubitRelation objects
*/
public static function getBySubjectOrObjectId($id, $options = array())
{
$criteria = new Criteria();
$criterion1 = $criteria->getNewCriterion(QubitRelation::OBJECT_ID, $id);
$criterion2 = $criteria->getNewCriterion(QubitRelation::SUBJECT_ID, $id);
$criterion1->addOr($criterion2);
// If restricting by relation type
if (isset($options['typeId'])) {
$criterion3 = $criteria->getNewCriterion(QubitRelation::TYPE_ID, $options['typeId']);
$criterion1->addAnd($criterion3);
}
$criteria->add($criterion1);
$criteria->addAscendingOrderByColumn(QubitRelation::TYPE_ID);
return QubitRelation::get($criteria);
}
public static function getrelationsById($id, array $options = array())
{
$criteria = new Criteria();
self::addrelationsCriteriaById($criteria, $id);
return QubitRelation::get($criteria, $options);
}
