MetadataDescription.inc.php

<?php
 
import('lib.pkp.classes.core.DataObject');
 
define('METADATA_DESCRIPTION_REPLACE_ALL', 0x01);
define('METADATA_DESCRIPTION_REPLACE_PROPERTIES', 0x02);
define('METADATA_DESCRIPTION_REPLACE_NOTHING', 0x03);
 
define('METADATA_DESCRIPTION_UNKNOWN_LOCALE', 'unknown');
 
class MetadataDescription extends DataObject {
   var $_metadataSchemaName;
 
   var $_metadataSchema;
 
   var $_assocType;
 
   var $_assocId;
 
   var $_displayName;
 
   var $_seq;
 
   function __construct($metadataSchemaName, $assocType) {
      assert(is_string($metadataSchemaName) && is_integer($assocType));
      parent::__construct();
      $this->_metadataSchemaName = $metadataSchemaName;
      $this->_assocType = $assocType;
   }
 
   //
   // Get/set methods
   //
   function getMetadataSchemaName() {
      return $this->_metadataSchemaName;
   }
 
   function &getMetadataSchema() {
      // Lazy-load the meta-data schema if this has
      // not been done before.
      if (is_null($this->_metadataSchema)) {
         $this->_metadataSchema =& instantiate($this->getMetadataSchemaName(), 'MetadataSchema');
         assert(is_object($this->_metadataSchema));
      }
      return $this->_metadataSchema;
   }
 
   function getAssocType() {
      return $this->_assocType;
   }
 
   function getAssocId() {
      return $this->_assocId;
   }
 
   function setAssocId($assocId) {
      $this->_assocId = $assocId;
   }
 
   function getAssoc() {
      $assocType = $this->getAssocType();
      $assocId = $this->getAssocId();
      assert(isset($assocType) && isset($assocId));
      return $assocType.':'.$assocId;
   }
 
   function setDisplayName($displayName) {
      $this->_displayName = $displayName;
   }
 
   function getDisplayName() {
      return $this->_displayName;
   }
 
   function setSequence($seq) {
      $this->_seq = $seq;
   }
 
   function getSequence() {
      return $this->_seq;
   }
 
   function addStatement($propertyName, $value, $locale = null, $replace = false) {
      // Check the property
      $property =& $this->getProperty($propertyName);
      if (is_null($property)) return false;
      assert(is_a($property, 'MetadataProperty'));
 
      // Check that the property is allowed for the described resource
      if (!in_array($this->_assocType, $property->getAssocTypes())) return false;
 
      // Handle translation
      $translated = $property->getTranslated();
      if (isset($locale) && !$translated) return false;
      if (!isset($locale) && $translated) {
         // Retrieve the current locale
         $locale = AppLocale::getLocale();
      }
 
      // Check that the value is compliant with the property specification
      if ($property->isValid($value, $locale) === false) return false;
 
      // Handle cardinality
      $existingValue =& $this->getStatement($propertyName, $locale);
      switch ($property->getCardinality()) {
         case METADATA_PROPERTY_CARDINALITY_ONE:
            if (isset($existingValue) && !$replace) return false;
            $newValue = $value;
            break;
 
         case METADATA_PROPERTY_CARDINALITY_MANY:
            if (isset($existingValue) && !$replace) {
               assert(is_array($existingValue));
               $newValue = $existingValue;
               array_push($newValue, $value);
            } else {
               $newValue = array($value);
            }
            break;
 
         default:
            assert(false);
      }
 
      // Add the value
      $this->setData($propertyName, $newValue, $locale);
      return true;
   }
 
   function removeStatement($propertyName, $locale = null) {
      // Remove the statement if it exists
      if (isset($propertyName) && $this->hasData($propertyName, $locale)) {
         $this->setData($propertyName, null, $locale);
         return true;
      }
 
      return false;
   }
 
   function &getStatements() {
      // Do not retrieve the data by-ref
      // otherwise the following unset()
      // will change internal state.
      $allData = $this->getAllData();
 
      // Unset data variables that are not statements
      unset($allData['id']);
      return $allData;
   }
 
   function &getStatement($propertyName, $locale = null) {
      // Check the property
      $property =& $this->getProperty($propertyName);
      assert(isset($property) && is_a($property, 'MetadataProperty'));
 
      // Handle translation
      $translated = $property->getTranslated();
      if (!$translated) assert(is_null($locale));
      if ($translated && !isset($locale)) {
         // Retrieve the current locale
         $locale = AppLocale::getLocale();
      }
 
      // Retrieve the value
      return $this->getData($propertyName, $locale);
   }
 
   function &getStatementTranslations($propertyName) {
      assert($this->isTranslatedProperty($propertyName));
      return $this->getData($propertyName);
   }
 
   function setStatements(&$statements, $replace = METADATA_DESCRIPTION_REPLACE_PROPERTIES) {
      assert(in_array($replace, $this->_allowedReplaceLevels()));
 
      // Make a backup copy of all existing statements.
      $statementsBackup = $this->getAllData();
 
      if ($replace == METADATA_DESCRIPTION_REPLACE_ALL) {
         // Delete existing statements
         $emptyArray = array();
         $this->setAllData($emptyArray);
      }
 
      // Add statements one by one to detect invalid values.
      foreach($statements as $propertyName => $content) {
         assert(!empty($content));
 
         // Transform scalars or translated fields to arrays so that
         // we can handle properties with different cardinalities in
         // the same way.
         if (is_scalar($content) || is_string(key($content))) {
            $values = array(&$content);
         } else {
            $values =& $content;
         }
 
         if ($replace == METADATA_DESCRIPTION_REPLACE_PROPERTIES) {
            $replaceProperty = true;
         } else {
            $replaceProperty = false;
         }
 
         $valueIndex = 0;
         foreach($values as $value) {
            $firstValue = ($valueIndex == 0) ? true : false;
            // Is this a translated property?
            if (is_array($value)) {
               foreach($value as $locale => $translation) {
                  // Handle cardinality many and one in the same way
                  if (is_scalar($translation)) {
                     $translationValues = array(&$translation);
                  } else {
                     $translationValues =& $translation;
                  }
                  $translationIndex = 0;
                  foreach($translationValues as $translationValue) {
                     $firstTranslation = ($translationIndex == 0) ? true : false;
                     // Add a statement (replace existing statement if any)
                     if (!($this->addStatement($propertyName, $translationValue, $locale, $firstTranslation && $replaceProperty))) {
                        $this->setAllData($statementsBackup);
                        return false;
                     }
                     unset($translationValue);
                     $translationIndex++;
                  }
                  unset($translationValues);
               }
               unset($translation);
            } else {
               // Add a statement (replace existing statement if any)
               if (!($this->addStatement($propertyName, $value, null, $firstValue && $replaceProperty))) {
                  $this->setAllData($statementsBackup);
                  return false;
               }
            }
            unset($value);
            $valueIndex++;
         }
         unset($values);
      }
      return true;
   }
 
   function &getProperties() {
      $metadataSchema =& $this->getMetadataSchema();
      return $metadataSchema->getProperties();
   }
 
   function &getProperty($propertyName) {
      $metadataSchema =& $this->getMetadataSchema();
      return $metadataSchema->getProperty($propertyName);
   }
 
   function getNamespacedPropertyId($propertyName) {
      $metadataSchema =& $this->getMetadataSchema();
      return $metadataSchema->getNamespacedPropertyId($propertyName);
   }
 
   function getPropertyNames() {
      $metadataSchema =& $this->getMetadataSchema();
      return $metadataSchema->getPropertyNames();
   }
 
   function getPropertyNamesByType($propertyType) {
      $metadataSchema =& $this->getMetadataSchema();
      return $metadataSchema->getPropertyNamesByType($propertyType);
   }
 
   function getSetPropertyNames() {
      return array_keys($this->getStatements());
   }
 
   function hasProperty($propertyName) {
      $metadataSchema =& $this->getMetadataSchema();
      return $metadataSchema->hasProperty($propertyName);
   }
 
   function hasStatement($propertyName) {
      $statements =& $this->getStatements();
      return (isset($statements[$propertyName]));
   }
 
   function isTranslatedProperty($propertyName) {
      $property = $this->getProperty($propertyName);
      assert(is_a($property, 'MetadataProperty'));
      return $property->getTranslated();
   }
 
 
   //
   // Private helper methods
   //
   static function _allowedReplaceLevels() {
      static $allowedReplaceLevels = array(
         METADATA_DESCRIPTION_REPLACE_ALL,
         METADATA_DESCRIPTION_REPLACE_PROPERTIES,
         METADATA_DESCRIPTION_REPLACE_NOTHING
      );
      return $allowedReplaceLevels;
   }
}