ControlledVocabDAO.inc.php

<?php
 
import('lib.pkp.classes.controlledVocab.ControlledVocab');
 
class ControlledVocabDAO extends DAO {
 
   function getEntryDAO() {
      return DAORegistry::getDAO('ControlledVocabEntryDAO');
   }
 
   function getById($controlledVocabId) {
      $result = $this->retrieve(
         'SELECT * FROM controlled_vocabs WHERE controlled_vocab_id = ?', array((int) $controlledVocabId)
      );
 
      $returner = null;
      if ($result->RecordCount() != 0) {
         $returner = $this->_fromRow($result->GetRowAssoc(false));
      }
      $result->Close();
      return $returner;
   }
 
   function _build($symbolic, $assocType = 0, $assocId = 0) {
      // Attempt to fetch an existing controlled vocabulary.
      $controlledVocab = $this->getBySymbolic($symbolic, $assocType, $assocId);
      if ($controlledVocab) return $controlledVocab;
 
      // Attempt to build a new controlled vocabulary.
      $controlledVocab = $this->newDataObject();
      $controlledVocab->setSymbolic($symbolic);
      $controlledVocab->setAssocType($assocType);
      $controlledVocab->setAssocId($assocId);
      $id = $this->insertObject($controlledVocab, false);
      if ($id !== null) return $controlledVocab;
 
      // Presume that an error was a duplicate insert.
      // In this case, try to fetch an existing controlled
      // vocabulary.
      return $this->getBySymbolic($symbolic, $assocType, $assocId);
   }
 
   function newDataObject() {
      return new ControlledVocab();
   }
 
   function _fromRow($row) {
      $controlledVocab = $this->newDataObject();
      $controlledVocab->setId($row['controlled_vocab_id']);
      $controlledVocab->setAssocType($row['assoc_type']);
      $controlledVocab->setAssocId($row['assoc_id']);
      $controlledVocab->setSymbolic($row['symbolic']);
 
      return $controlledVocab;
   }
 
   function insertObject($controlledVocab, $dieOnError = true) {
      $success = $this->update(
         sprintf('INSERT INTO controlled_vocabs
            (symbolic, assoc_type, assoc_id)
            VALUES
            (?, ?, ?)'),
         array(
            $controlledVocab->getSymbolic(),
            (int) $controlledVocab->getAssocType(),
            (int) $controlledVocab->getAssocId()
         ),
         true, // callHooks
         $dieOnError
      );
      if ($success) {
         $controlledVocab->setId($this->getInsertId());
         return $controlledVocab->getId();
      }
      else return null; // An error occurred on insert
   }
 
   function updateObject(&$controlledVocab) {
      $returner = $this->update(
         sprintf('UPDATE   controlled_vocabs
            SET   symbolic = ?,
               assoc_type = ?,
               assoc_id = ?
            WHERE controlled_vocab_id = ?'),
         array(
            $controlledVocab->getSymbolic(),
            (int) $controlledVocab->getAssocType(),
            (int) $controlledVocab->getAssocId(),
            (int) $controlledVocab->getId()
         )
      );
      return $returner;
   }
 
   function deleteObject($controlledVocab) {
      return $this->deleteObjectById($controlledVocab->getId());
   }
 
   function deleteObjectById($controlledVocabId) {
      $params = array((int) $controlledVocabId);
      $controlledVocabEntryDao = DAORegistry::getDAO('ControlledVocabEntryDAO'); /* @var $controlledVocabEntryDao ControlledVocabEntryDAO */
      $controlledVocabEntries = $this->enumerate($controlledVocabId);
      foreach ($controlledVocabEntries as $controlledVocabEntryId => $controlledVocabEntryName) {
         $controlledVocabEntryDao->deleteObjectById($controlledVocabEntryId);
      }
      return $this->update('DELETE FROM controlled_vocabs WHERE controlled_vocab_id = ?', $params);
   }
 
   function getBySymbolic($symbolic, $assocType = 0, $assocId = 0) {
      $result = $this->retrieve(
         'SELECT * FROM controlled_vocabs WHERE symbolic = ? AND assoc_type = ? AND assoc_id = ?',
         array($symbolic, (int) $assocType, (int) $assocId)
      );
 
      $returner = null;
      if ($result->RecordCount() != 0) {
         $returner = $this->_fromRow($result->GetRowAssoc(false));
      }
      $result->Close();
      return $returner;
   }
 
   function enumerateBySymbolic($symbolic, $assocType, $assocId, $settingName = 'name') {
      $controlledVocab = $this->getBySymbolic($symbolic, $assocType, $assocId);
      if (!$controlledVocab) {
         $returner = array();
         return $returner;
      }
      return $controlledVocab->enumerate($settingName);
   }
 
   function enumerate($controlledVocabId, $settingName = 'name') {
      $result = $this->retrieve(
         'SELECT  e.controlled_vocab_entry_id,
            COALESCE(l.setting_value, p.setting_value, n.setting_value) AS setting_value,
            COALESCE(l.setting_type, p.setting_type, n.setting_type) AS setting_type
         FROM  controlled_vocab_entries e
            LEFT JOIN controlled_vocab_entry_settings l ON (l.controlled_vocab_entry_id = e.controlled_vocab_entry_id AND l.setting_name = ? AND l.locale = ?)
            LEFT JOIN controlled_vocab_entry_settings p ON (p.controlled_vocab_entry_id = e.controlled_vocab_entry_id AND p.setting_name = ? AND p.locale = ?)
            LEFT JOIN controlled_vocab_entry_settings n ON (n.controlled_vocab_entry_id = e.controlled_vocab_entry_id AND n.setting_name = ? AND n.locale = ?)
         WHERE e.controlled_vocab_id = ?
         ORDER BY e.seq',
         array(
            $settingName, AppLocale::getLocale(),     // Current locale
            $settingName, AppLocale::getPrimaryLocale(), // Primary locale
            $settingName, '',          // No locale
            (int) $controlledVocabId
         )
      );
 
      $returner = array();
      while (!$result->EOF) {
         $row = $result->GetRowAssoc(false);
         $returner[$row['controlled_vocab_entry_id']] = $this->convertFromDB(
            $row['setting_value'],
            $row['setting_type']
         );
         $result->MoveNext();
      }
      $result->Close();
      return $returner;
   }
 
   function getInsertId() {
      return parent::_getInsertId('controlled_vocabs', 'controlled_vocab_id');
   }
 
   function installXML($filename) {
      $controlledVocabs = array();
      $controlledVocabEntryDao = $this->getEntryDAO();
      $controlledVocabEntrySettingsDao = $controlledVocabEntryDao->getSettingsDAO();
      $parser = new XMLParser();
      $tree = $parser->parse($filename);
      foreach ($tree->getChildren() as $controlledVocabNode) {
         assert($controlledVocabNode->getName() == 'controlled_vocab');
 
         // Try to fetch an existing controlled vocabulary
         $controlledVocab = $this->getBySymbolic(
            $symbolic = $controlledVocabNode->getAttribute('symbolic'),
            $assocType = (int) $controlledVocabNode->getAttribute('assoc-type'),
            $assocId = (int) $controlledVocabNode->getAttribute('assoc-id')
         );
         if ($controlledVocab) {
            $controlledVocabs[] = $controlledVocab;
            continue;
         }
 
         // It doesn't exist; create a new one.
         $controlledVocabs[] = $controlledVocab = $this->_build($symbolic, $assocType, $assocId);
         foreach ($controlledVocabNode->getChildren() as $entryNode) {
            $seq = $entryNode->getAttribute('seq');
            if ($seq !== null) $seq = (float) $seq;
 
            $controlledVocabEntry = $controlledVocabEntryDao->newDataObject();
            $controlledVocabEntry->setControlledVocabId($controlledVocab->getId());
            $controlledVocabEntry->setSequence($seq);
            $controlledVocabEntryDao->insertObject($controlledVocabEntry);
 
            foreach ($entryNode->getChildren() as $settingNode) {
               $controlledVocabEntrySettingsDao->updateSetting(
                  $controlledVocabEntry->getId(),
                  $settingNode->getAttribute('name'),
                  $settingNode->getValue(),
                  $settingNode->getAttribute('type'),
                  false // Not localized
               );
            }
         }
      }
      return $controlledVocabs;
   }
}