MetadataDataObjectAdapter.inc.php

<?php
 
import('lib.pkp.classes.filter.PersistableFilter');
import('lib.pkp.classes.metadata.MetadataDescription');
 
define('METADATA_DOA_INJECTION_MODE', 0x01);
define('METADATA_DOA_EXTRACTION_MODE', 0x02);
 
class MetadataDataObjectAdapter extends PersistableFilter {
   var $_mode;
 
   var $_metadataSchema;
 
   var $_dataObjectClass;
 
   var $_metadataFieldNames;
 
   var $_metadataSchemaName;
 
   var $_assocType;
 
   var $_dataObjectName;
 
   function __construct($filterGroup, $mode = null) {
      // Initialize the adapter.
      parent::__construct($filterGroup);
 
      // Extract information from the input/output types.
 
      // Find out whether this filter is injecting or
      // extracting meta-data.
      $metadataTypeDescription = null; /* @var $metadataTypeDescription MetadataTypeDescription */
      $dataObjectTypeDescription = null; /* @var $dataObjectTypeDescription ClassTypeDescription */
      $inputType =& $this->getInputType();
      $outputType =& $this->getOutputType();
      if (is_null($mode)) {
         if (is_a($inputType, 'MetadataTypeDescription')) {
            $mode = METADATA_DOA_INJECTION_MODE;
         } else {
            $mode = METADATA_DOA_EXTRACTION_MODE;
         }
      }
      $this->_mode = $mode;
 
      if ($mode == METADATA_DOA_INJECTION_MODE) {
         // We are in meta-data injection mode (or both input and output are meta-data descriptions).
         $metadataTypeDescription =& $inputType; /* @var $metadataTypeDescription MetadataTypeDescription */
         assert(is_a($outputType, 'ClassTypeDescription'));
         $dataObjectTypeDescription =& $outputType; /* @var $dataObjectTypeDescription ClassTypeDescription */
      } else {
         // We are in meta-data extraction mode.
         assert(is_a($outputType, 'MetadataTypeDescription'));
         $metadataTypeDescription =& $outputType;
         assert(is_a($inputType, 'ClassTypeDescription'));
         $dataObjectTypeDescription =& $inputType;
      }
 
      // Extract information from the input/output types.
      $this->_metadataSchemaName = $metadataTypeDescription->getMetadataSchemaClass();
      $this->_assocType = $metadataTypeDescription->getAssocType();
      $this->_dataObjectName = $dataObjectTypeDescription->getTypeName();
 
      // Set the display name.
      if ($mode == METADATA_DOA_INJECTION_MODE) {
         $this->setDisplayName('Inject metadata into a(n) '.$this->getDataObjectClass());
      } else {
         $this->setDisplayName('Extract metadata from a(n) '.$this->getDataObjectClass());
      }
   }
 
   //
   // Getters and setters
   //
   function getMode() {
      return $this->_mode;
   }
 
   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)) {
         $metadataSchemaName = $this->getMetadataSchemaName();
         assert(!is_null($metadataSchemaName));
         $this->_metadataSchema =& instantiate($metadataSchemaName, 'MetadataSchema');
         assert(is_object($this->_metadataSchema));
      }
      return $this->_metadataSchema;
   }
 
   function getMetadataNamespace() {
      $metadataSchema =& $this->getMetadataSchema();
      return $metadataSchema->getNamespace();
   }
 
   function getDataObjectName() {
      return $this->_dataObjectName;
   }
 
   function getDataObjectClass() {
      if (is_null($this->_dataObjectClass)) {
         $dataObjectName = $this->getDataObjectName();
         assert(!is_null($dataObjectName));
         $dataObjectNameParts = explode('.', $dataObjectName);
         $this->_dataObjectClass = array_pop($dataObjectNameParts);
      }
      return $this->_dataObjectClass;
   }
 
   function getAssocType() {
      return $this->_assocType;
   }
 
   function setTargetDataObject(&$targetDataObject) {
      $this->_targetDataObject =& $targetDataObject;
   }
 
   function &getTargetDataObject() {
      return $this->_targetDataObject;
   }
 
 
   //
   // Abstract template methods
   //
   function &injectMetadataIntoDataObject(&$metadataDescription, &$targetDataObject) {
      // Must be implemented by sub-classes
      assert(false);
   }
 
   function extractMetadataFromDataObject(&$sourceDataObject) {
      // Must be implemented by sub-classes
      assert(false);
   }
 
   function getDataObjectMetadataFieldNames($translated = true) {
      // By default return all field names
      return $this->getMetadataFieldNames($translated);
   }
 
 
   //
   // Implement template methods from Filter
   //
   function &process(&$input) {
      // Do we inject or extract metadata?
      switch ($this->getMode()) {
         case METADATA_DOA_INJECTION_MODE:
            $targetDataObject =& $this->getTargetDataObject();
 
            // Instantiate a new data object if none was given.
            if (is_null($targetDataObject)) {
               $targetDataObject =& $this->instantiateDataObject();
               assert(is_a($targetDataObject, $this->getDataObjectName()));
            }
 
            // Inject meta-data into the data object.
            $output =& $this->injectMetadataIntoDataObject($input, $targetDataObject);
            break;
 
         case METADATA_DOA_EXTRACTION_MODE:
            $output = $this->extractMetadataFromDataObject($input);
            break;
 
         default:
            // Input should be validated by now.
            assert(false);
      }
 
      return $output;
   }
 
 
   //
   // Protected helper methods
   //
   function &instantiateDataObject() {
      $dataObjectName = $this->getDataObjectName();
      assert(!is_null($dataObjectName));
      $dataObject =& instantiate($dataObjectName, $this->getDataObjectClass());
      return $dataObject;
   }
 
   function &instantiateMetadataDescription() {
      $metadataDescription = new MetadataDescription($this->getMetadataSchemaName(), $this->getAssocType());
      return $metadataDescription;
   }
 
   function getMetadataFieldNames($translated = true) {
      // Do we need to build the field name cache first?
      if (is_null($this->_metadataFieldNames)) {
         // Initialize the cache array
         $this->_metadataFieldNames = array();
 
         // Retrieve all properties and add
         // their names to the cache
         $metadataSchema =& $this->getMetadataSchema();
         $metadataSchemaNamespace = $metadataSchema->getNamespace();
         $properties =& $metadataSchema->getProperties();
         foreach($properties as $property) {
            $propertyAssocTypes = $property->getAssocTypes();
            if (in_array($this->_assocType, $propertyAssocTypes)) {
               // Separate translated and non-translated property names
               // and add the name space so that field names are unique
               // across various meta-data schemas.
               $this->_metadataFieldNames[$property->getTranslated()][] = $metadataSchemaNamespace.':'.$property->getName();
            }
         }
      }
 
      // Return the field names
      return $this->_metadataFieldNames[$translated];
   }
 
   function addLocalizedStatements(&$metadataDescription, $propertyName, $localizedValues) {
      if (is_array($localizedValues)) {
         foreach ($localizedValues as $locale => $values) {
            // Handle cardinality "many" and "one" in the same way.
            if (is_scalar($values)) $values = array($values);
            foreach($values as $value) {
               $metadataDescription->addStatement($propertyName, $value, $locale);
               unset($value);
            }
         }
      }
   }
 
   function injectUnmappedDataObjectMetadataFields(&$metadataDescription, &$dataObject) {
      // Handle translated and non-translated statements separately.
      foreach(array(true, false) as $translated) {
         // Retrieve the unmapped fields.
         foreach($this->getDataObjectMetadataFieldNames($translated) as $unmappedProperty) {
            // Identify the corresponding property name.
            list($namespace, $propertyName) = explode(':', $unmappedProperty);
 
            // Find out whether we have a statement for this unmapped property.
            if ($metadataDescription->hasStatement($propertyName)) {
               // Add the unmapped statement directly to the
               // data object.
               if ($translated) {
                  $dataObject->setData($unmappedProperty, $metadataDescription->getStatementTranslations($propertyName));
               } else {
                  $dataObject->setData($unmappedProperty, $metadataDescription->getStatement($propertyName));
               }
            }
         }
      }
   }
 
   function extractUnmappedDataObjectMetadataFields(&$dataObject, &$metadataDescription) {
      $metadataSchema =& $this->getMetadataSchema();
      $handledNamespace = $metadataSchema->getNamespace();
 
      // Handle translated and non-translated statements separately.
      foreach(array(true, false) as $translated) {
         // Retrieve the unmapped fields.
         foreach($this->getDataObjectMetadataFieldNames($translated) as $unmappedProperty) {
            // Find out whether we have a statement for this unmapped property.
            if ($dataObject->hasData($unmappedProperty)) {
               // Identify the corresponding property name and namespace.
               list($namespace, $propertyName) = explode(':', $unmappedProperty);
 
               // Only extract data if the namespace of the property
               // is the same as the one handled by this adapter and the
               // property is within the current description.
               if ($namespace == $handledNamespace && $metadataSchema->hasProperty($propertyName)) {
                  // Add the unmapped statement to the metadata description.
                  if ($translated) {
                     $this->addLocalizedStatements($metadataDescription, $propertyName, $dataObject->getData($unmappedProperty));
                  } else {
                     $metadataDescription->addStatement($propertyName, $dataObject->getData($unmappedProperty));
                  }
               }
            }
         }
      }
   }
}