MetadataProperty.inc.php

<?php
 
// literal values (plain)
define('METADATA_PROPERTY_TYPE_STRING', 0x01);
 
// literal values (typed)
define('METADATA_PROPERTY_TYPE_DATE', 0x02); // This is W3CDTF encoding without time (YYYY[-MM[-DD]])!
define('METADATA_PROPERTY_TYPE_INTEGER', 0x03);
 
// non-literal value string from a controlled vocabulary
define('METADATA_PROPERTY_TYPE_VOCABULARY', 0x04);
 
// non-literal value URI
define('METADATA_PROPERTY_TYPE_URI', 0x05);
 
// non-literal value pointing to a separate description set instance (=another MetadataRecord object)
define('METADATA_PROPERTY_TYPE_COMPOSITE', 0x06);
 
// allowed cardinality of statements for a given property type in a meta-data schema
define('METADATA_PROPERTY_CARDINALITY_ONE', 0x01);
define('METADATA_PROPERTY_CARDINALITY_MANY', 0x02);
 
class MetadataProperty {
   var $_name;
 
   var $_displayName;
 
   var $_assocTypes;
 
   var $_allowedTypes;
 
   var $_translated;
 
   var $_cardinality;
 
   var $_validationMessage;
 
   var $_mandatory;
 
   function __construct($name, $assocTypes = array(), $allowedTypes = METADATA_PROPERTY_TYPE_STRING,
         $translated = false, $cardinality = METADATA_PROPERTY_CARDINALITY_ONE, $displayName = null, $validationMessage = null, $mandatory = false) {
 
      // Validate name and assoc type array
      if (!is_string($name)) throw new InvalidArgumentException('$name should be a string.');
      if (!is_array($assocTypes)) throw new InvalidArgumentException('$assocTypes should be an array.');
 
      // A single type will be transformed to an
      // array of types so that we can handle them
      // uniformly.
      if (is_scalar($allowedTypes) || count($allowedTypes) == 1) {
         $allowedTypes = array($allowedTypes);
      }
 
      // Validate types
      $canonicalizedTypes = array();
      foreach($allowedTypes as $allowedType) {
         if (is_array($allowedType)) {
            // We expect an array with a single entry
            // of the form "type => additional parameter".
            assert(count($allowedType) == 1);
            // Reset the array, just in case...
            reset($allowedType);
            // Extract the type and the additional parameter
            $allowedTypeId = key($allowedType);
            $allowedTypeParam = current($allowedType);
         } else {
            // No additional parameter has been set.
            $allowedTypeId = $allowedType;
            $allowedTypeParam = null;
         }
 
         // Validate type
         if (!in_array($allowedTypeId, MetadataProperty::getSupportedTypes())) throw new InvalidArgumentException('Allowed types must be supported types!');
 
         // Transform the type array in a
         // structure that is easy to handle
         // in for loops.
         $canonicalizedTypes[$allowedTypeId][] = $allowedTypeParam;
 
         // Validate additional type parameter.
         switch($allowedTypeId) {
            case METADATA_PROPERTY_TYPE_COMPOSITE:
               // Validate the assoc id of the composite.
               if (!is_integer($allowedTypeParam)) throw new InvalidArgumentException('Allowed type parameter should be an integer.');
               // Properties that allow composite types cannot be translated.
               if ($translated) throw new InvalidArgumentException('Properties that allow composite types cannot be translated.');
               break;
 
            case METADATA_PROPERTY_TYPE_VOCABULARY:
               // Validate the symbolic name of the vocabulary.
               if (!is_string($allowedTypeParam)) throw new InvalidArgumentException('Allowed type parameter should be a string.');
               break;
 
            default:
               // No other types support an additional parameter
               if (!is_null($allowedTypeParam)) throw new InvalidArgumentException('An additional parameter was supplied for an unsupported metadata property type.');
         }
      }
 
      // Validate translation and cardinality
      if (!is_bool($translated)) throw new InvalidArgumentException('$translated must be a boolean');
      if (!in_array($cardinality, MetadataProperty::getSupportedCardinalities())) throw new InvalidArgumentException('$cardinality must be a supported cardinality.');
 
      // Default display name
      if (is_null($displayName)) $displayName = 'metadata.property.displayName.'.$name;
      if (!is_string($displayName)) throw new InvalidArgumentException('$displayName must be a string.');
 
      // Default validation message
      if (is_null($validationMessage)) $validationMessage = 'metadata.property.validationMessage.'.$name;
      if (!is_string($validationMessage)) throw new InvalidArgumentException('$validationMessage must be a string.');
 
 
      // Initialize the class
      $this->_name = (string)$name;
      $this->_assocTypes =& $assocTypes;
      $this->_allowedTypes =& $canonicalizedTypes;
      $this->_translated = (boolean)$translated;
      $this->_cardinality = (integer)$cardinality;
      $this->_displayName = (string)$displayName;
      $this->_validationMessage = (string)$validationMessage;
      $this->_mandatory = (boolean)$mandatory;
   }
 
   function getName() {
      return $this->_name;
   }
 
   function getId() {
      // Replace special characters in XPath-like names
      // as 'person-group[@person-group-type="author"]'.
      $from = array(
         '[', ']', '@', '"', '='
      );
      $to = array(
         '-', '', '', '', '-'
      );
      $propertyId = trim(str_replace($from, $to, $this->getName()), '-');
      $propertyId = PKPString::camelize($propertyId);
      return $propertyId;
   }
 
   function getDisplayName() {
      return $this->_displayName;
   }
 
   function &getAssocTypes() {
      return $this->_assocTypes;
   }
 
   function getAllowedTypes() {
      return $this->_allowedTypes;
   }
 
   function getTranslated() {
      return $this->_translated;
   }
 
   function getCardinality() {
      return $this->_cardinality;
   }
 
   function getValidationMessage() {
      return $this->_validationMessage;
   }
 
   function getMandatory() {
      return $this->_mandatory;
   }
 
 
   //
   // Public methods
   //
   function isValid($value, $locale = null) {
      // We never accept null values or arrays.
      if (is_null($value) || is_array($value)) return false;
 
      // Translate the locale.
      if (is_null($locale)) $locale = '';
 
      // MetadataProperty::getSupportedTypes() returns an ordered
      // list of possible meta-data types with the most specific
      // type coming first so that we always correctly identify
      // specializations (e.g. a date is a specialized string).
      $allowedTypes = $this->getAllowedTypes();
      foreach (MetadataProperty::getSupportedTypes() as $testedType) {
         if (isset($allowedTypes[$testedType])) {
            foreach ($allowedTypes[$testedType] as $allowedTypeParam) {
               // Type specific validation
               switch ($testedType) {
                  case METADATA_PROPERTY_TYPE_COMPOSITE:
                     // Composites can either be represented by a meta-data description
                     // or by a string of the form AssocType:AssocId if the composite
                     // has already been persisted in the database.
                     switch(true) {
                        // Test for MetadataDescription format
                        case is_a($value, 'MetadataDescription'):
                           $assocType = $value->getAssocType();
                           break;
 
                        // Test for AssocType:AssocId format
                        case is_string($value):
                           $valueParts = explode(':', $value);
                           if (count($valueParts) != 2) break 2; // break the outer switch
                           list($assocType, $assocId) = $valueParts;
                           if (!(is_numeric($assocType) && is_numeric($assocId))) break 2; // break the outer switch
                           $assocType = (integer)$assocType;
                           break;
 
                        default:
                           // None of the allowed types
                           break;
                     }
 
                     // Check that the association type matches
                     // with the allowed association type (which
                     // is configured as an additional type parameter).
                     if (isset($assocType) && $assocType === $allowedTypeParam) return array(METADATA_PROPERTY_TYPE_COMPOSITE => $assocType);
                     break;
 
                  case METADATA_PROPERTY_TYPE_VOCABULARY:
                     // Interpret the type parameter of this type like this:
                     // symbolic[:assoc-type:assoc-id]. If no assoc type/id are
                     // given then we assume :0:0 to represent site-wide vocabs.
                     $vocabNameParts = explode(':', $allowedTypeParam);
                     $vocabNamePartsCount = count($vocabNameParts);
                     switch ($vocabNamePartsCount) {
                        case 1:
                           // assume a site-wide vocabulary
                           $symbolic = $allowedTypeParam;
                           $assocType = $assocId = 0;
                           break;
 
                        case 3:
                           // assume a context-specific vocabulary
                           list($symbolic, $assocType, $assocId) = $vocabNameParts;
                           break;
 
                        default:
                           // Invalid configuration
                           assert(false);
                     }
 
                     if (is_string($value)) {
                        // Try to translate the string value into a controlled vocab entry
                        $controlledVocabEntryDao = DAORegistry::getDAO('ControlledVocabEntryDAO'); /* @var $controlledVocabEntryDao ControlledVocabEntryDAO */
                        if (!is_null($controlledVocabEntryDao->getBySetting($value, $symbolic, $assocType, $assocId, 'name', $locale))) {
                           // The string was successfully translated so mark it as "valid".
                           return array(METADATA_PROPERTY_TYPE_VOCABULARY => $allowedTypeParam);
                        }
                     }
 
                     if (is_integer($value)) {
                        // Validate with controlled vocabulary validator
                        import('lib.pkp.classes.validation.ValidatorControlledVocab');
                        $validator = new ValidatorControlledVocab($symbolic, $assocType, $assocId);
                        if ($validator->isValid($value)) {
                           return array(METADATA_PROPERTY_TYPE_VOCABULARY => $allowedTypeParam);
                        }
                     }
 
                     break;
 
                  case METADATA_PROPERTY_TYPE_URI:
                     import('lib.pkp.classes.validation.ValidatorFactory');
                     $validator = ValidatorFactory::make(
                        array('uri' => $value),
                        array('uri' => 'url')
                     );
                     if (!$validator->fails()) {
                        return array(METADATA_PROPERTY_TYPE_URI => null);
                     }
                     break;
 
                  case METADATA_PROPERTY_TYPE_DATE:
                     // We allow the following patterns:
                     // YYYY-MM-DD, YYYY-MM and YYYY
                     $datePattern = '/^[0-9]{4}(-[0-9]{2}(-[0-9]{2})?)?$/';
                     if (!preg_match($datePattern, $value)) break;
 
                     // Check whether the given string is really a valid date
                     $dateParts = explode('-', $value);
                     // Set the day and/or month to 1 if not set
                     $dateParts = array_pad($dateParts, 3, 1);
                     // Extract the date parts
                     list($year, $month, $day) = $dateParts;
                     // Validate the date (only leap days will pass unnoticed ;-) )
                     // Who invented this argument order?
                     if (checkdate($month, $day, $year)) return array(METADATA_PROPERTY_TYPE_DATE => null);
                     break;
 
                  case METADATA_PROPERTY_TYPE_INTEGER:
                     if (is_integer($value)) return array(METADATA_PROPERTY_TYPE_INTEGER => null);
                     break;
 
                  case METADATA_PROPERTY_TYPE_STRING:
                     if (is_string($value)) return array(METADATA_PROPERTY_TYPE_STRING => null);
                     break;
 
                  default:
                     // Unknown type. As we validate type in the setter, this
                     // should be unreachable code.
                     assert(false);
               }
            }
         }
      }
 
      // Return false if the value didn't validate against any
      // of the allowed types.
      return false;
   }
 
   //
   // Public static methods
   //
   static function getSupportedTypes() {
      static $_supportedTypes = array(
         METADATA_PROPERTY_TYPE_COMPOSITE,
         METADATA_PROPERTY_TYPE_VOCABULARY,
         METADATA_PROPERTY_TYPE_URI,
         METADATA_PROPERTY_TYPE_DATE,
         METADATA_PROPERTY_TYPE_INTEGER,
         METADATA_PROPERTY_TYPE_STRING
      );
      return $_supportedTypes;
   }
 
   static function getSupportedCardinalities() {
      static $_supportedCardinalities = array(
         METADATA_PROPERTY_CARDINALITY_ONE,
         METADATA_PROPERTY_CARDINALITY_MANY
      );
      return $_supportedCardinalities;
   }
}