classes/monograph/MonographDAO.inc.php

<?php

import('classes.monograph.Monograph');

class MonographDAO extends DAO {
   var $authorDao;
   var $cache;

   function MonographDAO() {
      parent::DAO();
      $this->authorDao =& DAORegistry::getDAO('AuthorDAO');
   }

   function _cacheMiss(&$cache, $id) {
      $monograph =& $this->getMonograph($id, null, false);
      $cache->setCache($id, $monograph);
      return $monograph;
   }

   function &_getCache() {
      if (!isset($this->cache)) {
         $cacheManager =& CacheManager::getManager();
         $this->cache =& $cacheManager->getObjectCache('monographs', 0, array(&$this, '_cacheMiss'));
      }
      return $this->cache;
   }

   function getLocaleFieldNames() {
      return array(
         'title', 'subtitle', 'cleanTitle', 'prefix',
         'abstract',
         'discipline', 'subjectClass', 'subject',
         'coverageGeo', 'coverageChron', 'coverageSample',
         'type', 'sponsor', 'rights', 'source', 'copyrightNotice',
      );
   }

   function updateLocaleFields(&$monograph) {
      $this->updateDataObjectSettings('monograph_settings', $monograph, array(
         'monograph_id' => $monograph->getId()
      ));
   }

   function &getById($monographId, $pressId = null, $useCache = false) {
      if ($useCache) {
         $cache =& $this->_getCache();
         $returner =& $cache->get($monographId);
         if ($returner && $pressId != null && $pressId != $returner->getPressId()) $returner = null;
         return $returner;
      }

      $primaryLocale = AppLocale::getPrimaryLocale();
      $locale = AppLocale::getLocale();
      $params = array(
         'title', $primaryLocale, // Series title
         'title', $locale, // Series title
         'abbrev', $primaryLocale, // Series abbreviation
         'abbrev', $locale, // Series abbreviation
         (int) $monographId
      );
      if ($pressId) $params[] = (int) $pressId;

      $result =& $this->retrieve(
         'SELECT  m.*, pm.date_published,
            COALESCE(stl.setting_value, stpl.setting_value) AS series_title,
            COALESCE(sal.setting_value, sapl.setting_value) AS series_abbrev
         FROM  monographs m
            LEFT JOIN series s ON s.series_id = m.series_id
            LEFT JOIN series_settings stpl ON (s.series_id = stpl.series_id AND stpl.setting_name = ? AND stpl.locale = ?)
            LEFT JOIN series_settings stl ON (s.series_id = stl.series_id AND stl.setting_name = ? AND stl.locale = ?)
            LEFT JOIN series_settings sapl ON (s.series_id = sapl.series_id AND sapl.setting_name = ? AND sapl.locale = ?)
            LEFT JOIN series_settings sal ON (s.series_id = sal.series_id AND sal.setting_name = ? AND sal.locale = ?)
            LEFT JOIN published_monographs pm ON (m.monograph_id = pm.monograph_id)
         WHERE m.monograph_id = ?
            ' . ($pressId?' AND m.press_id = ?':''),
         $params
      );

      $returner = null;
      if ($result->RecordCount() != 0) {
         $returner =& $this->_fromRow($result->GetRowAssoc(false));
      }

      $result->Close();
      unset($result);

      return $returner;
   }

   function &_fromRow(&$row) {
      $monograph = $this->newDataObject();
      $this->_monographFromRow($monograph, $row);
      return $monograph;
   }

   function newDataObject() {
      return new Monograph();
   }

   function _monographFromRow(&$monograph, &$row) {
      $monograph->setId($row['monograph_id']);
      $monograph->setLocale($row['locale']);
      $monograph->setUserId($row['user_id']);
      $monograph->setPressId($row['press_id']);
      $monograph->setStatus($row['status']);
      $monograph->setSeriesId($row['series_id']);
      $monograph->setSeriesPosition($row['series_position']);
      $monograph->setSeriesAbbrev(isset($row['series_abbrev'])?$row['series_abbrev']:null);
      $monograph->setLanguage($row['language']);
      $monograph->setCommentsToEditor($row['comments_to_ed']);
      $monograph->setDateSubmitted($row['date_submitted']);
      $monograph->setDateStatusModified($this->datetimeFromDB($row['date_status_modified']));
      $monograph->setLastModified($this->datetimeFromDB($row['last_modified']));
      $monograph->setStageId($row['stage_id']);
      $monograph->setStatus($row['status']);
      $monograph->setSubmissionProgress($row['submission_progress']);
      $monograph->setWorkType($row['edited_volume']);
      $monograph->setDatePublished($this->datetimeFromDB(isset($row['date_published'])?$row['date_published']:null));

      $this->getDataObjectSettings('monograph_settings', 'monograph_id', $row['monograph_id'], $monograph);

      HookRegistry::call('MonographDAO::_monographFromRow', array(&$monograph, &$row));
   }

   function insertMonograph(&$monograph) {
      $monograph->stampModified();
      $this->update(
         sprintf('INSERT INTO monographs
            (locale, user_id, press_id, series_id, series_position, language, comments_to_ed, date_submitted, date_status_modified, last_modified, status, submission_progress, stage_id, pages, hide_author, comments_status, edited_volume)
            VALUES
            (?, ?, ?, ?, ?, ?, ?, %s, %s, %s, ?, ?, ?, ?, ?, ?, ?)',
            $this->datetimeToDB($monograph->getDateSubmitted()), $this->datetimeToDB($monograph->getDateStatusModified()), $this->datetimeToDB($monograph->getLastModified())),
         array(
            $monograph->getLocale(),
            (int) $monograph->getUserId(),
            (int) $monograph->getPressId(),
            (int) $monograph->getSeriesId(),
            $monograph->getSeriesPosition(),
            $monograph->getLanguage(),
            $monograph->getCommentsToEditor(),
            $monograph->getStatus() === null ? STATUS_QUEUED : (int) $monograph->getStatus(),
            $monograph->getSubmissionProgress() === null ? 1 : (int) $monograph->getSubmissionProgress(),
            $monograph->getStageId() === null ? 1 : (int) $monograph->getStageId(),
            $monograph->getPages(),
            (int) $monograph->getHideAuthor(),
            (int) $monograph->getCommentsStatus(),
            (int) $monograph->getWorkType(),
         )
      );

      $monograph->setId($this->getInsertMonographId());
      $this->updateLocaleFields($monograph);

      return $monograph->getId();
   }

   function updateMonograph($monograph) {
      $this->update(
         sprintf('UPDATE monographs
            SET   user_id = ?,
               series_id = ?,
               series_position = ?,
               language = ?,
               comments_to_ed = ?,
               date_submitted = %s,
               date_status_modified = %s,
               last_modified = %s,
               status = ?,
               press_id = ?,
               submission_progress = ?,
               stage_id = ?,
               edited_volume = ?,
               hide_author = ?

            WHERE monograph_id = ?',
            $this->datetimeToDB($monograph->getDateSubmitted()), $this->datetimeToDB($monograph->getDateStatusModified()), $this->datetimeToDB($monograph->getLastModified())),
         array(
            (int) $monograph->getUserId(),
            (int) $monograph->getSeriesId(),
            $monograph->getSeriesPosition(),
            $monograph->getLanguage(),
            $monograph->getCommentsToEditor(),
            (int) $monograph->getStatus(),
            (int) $monograph->getPressId(),
            (int) $monograph->getSubmissionProgress(),
            (int) $monograph->getStageId(),
            (int) $monograph->getWorkType(),
            (int) $monograph->getHideAuthor(),
            (int) $monograph->getId()
         )
      );
      $this->updateLocaleFields($monograph);
      $this->flushCache();
   }

   function deleteObject(&$monograph) {
      return $this->deleteById($monograph->getId());
   }

   function deleteById($monographId) {
      $this->authorDao->deleteAuthorsByMonograph($monographId);

      $seriesEditorSubmissionDao =& DAORegistry::getDAO('SeriesEditorSubmissionDAO');
      $seriesEditorSubmissionDao->deleteDecisionsByMonograph($monographId);
      $seriesEditorSubmissionDao->deleteReviewRoundsByMonograph($monographId);

      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $reviewAssignmentDao->deleteBySubmissionId($monographId);

      // Delete chapters and assigned chapter authors.
      $chapterDao =& DAORegistry::getDAO('ChapterDAO');
      $chapters =& $chapterDao->getChapters($monographId);
      while ($chapter =& $chapters->next()) {
         // also removes Chapter Author associations
         $chapterDao->deleteObject($chapter);
      }

      // Delete controlled vocab lists assigned to this Monograph
      $monographKeywordDao =& DAORegistry::getDAO('MonographKeywordDAO');
      $monographKeywordVocab =& $monographKeywordDao->getBySymbolic(CONTROLLED_VOCAB_MONOGRAPH_KEYWORD, ASSOC_TYPE_MONOGRAPH, $monographId);
      if (isset($monographKeywordVocab)) {
         $monographKeywordDao->deleteObject($monographKeywordVocab);
      }

      $monographDisciplineDao =& DAORegistry::getDAO('MonographDisciplineDAO');
      $monographDisciplineVocab =& $monographDisciplineDao->getBySymbolic(CONTROLLED_VOCAB_MONOGRAPH_DISCIPLINE, ASSOC_TYPE_MONOGRAPH, $monographId);
      if (isset($monographDisciplineVocab)) {
         $monographDisciplineDao->deleteObject($monographDisciplineVocab);
      }

      $monographAgencyDao =& DAORegistry::getDAO('MonographAgencyDAO');
      $monographAgencyVocab =& $monographAgencyDao->getBySymbolic(CONTROLLED_VOCAB_MONOGRAPH_AGENCY, ASSOC_TYPE_MONOGRAPH, $monographId);
      if (isset($monographAgencyVocab)) {
         $monographAgencyDao->deleteObject($monographAgencyVocab);
      }

      $monographLanguageDao =& DAORegistry::getDAO('MonographLanguageDAO');
      $monographLanguageVocab =& $monographLanguageDao->getBySymbolic(CONTROLLED_VOCAB_MONOGRAPH_LANGUAGE, ASSOC_TYPE_MONOGRAPH, $monographId);
      if (isset($monographLanguageVocab)) {
         $monographLanguageDao->deleteObject($monographLanguageVocab);
      }

      $monographSubjectDao =& DAORegistry::getDAO('MonographSubjectDAO');
      $monographSubjectVocab =& $monographSubjectDao->getBySymbolic(CONTROLLED_VOCAB_MONOGRAPH_SUBJECT, ASSOC_TYPE_MONOGRAPH, $monographId);
      if (isset($monographSubjectVocab)) {
         $monographSubjectDao->deleteObject($monographSubjectVocab);
      }

      // Signoff DAOs
      $signoffDao =& DAORegistry::getDAO('SignoffDAO');
      $monographFileSignoffDao =& DAORegistry::getDAO('MonographFileSignoffDAO');

      // Delete Signoffs associated with a monogrpah file of this monograph.
      $monographFileSignoffs = $monographFileSignoffDao->getAllByMonograph($monographId);
      while ($signoff =& $monographFileSignoffs->next()) {
         $signoffDao->deleteObject($signoff);
         unset($signoff);
      }

      // Delete the Signoffs associated with the monograph itself.
      $monographSignoffs =& $signoffDao->getAllByAssocType(ASSOC_TYPE_MONOGRAPH, $monographId);
      while ($signoff =& $monographSignoffs->next()) {
         $signoffDao->deleteObject($signoff);
         unset($signoff);
      }

      // Delete the stage assignments.
      $stageAssignmentDao =& DAORegistry::getDAO('StageAssignmentDAO');
      $stageAssignments =& $stageAssignmentDao->getBySubmissionAndStageId($monographId);
      while ($stageAssignment =& $stageAssignments->next()) {
         $stageAssignmentDao->deleteObject($stageAssignment);
         unset($stageAssignment);
      }

      // N.B. Files must be deleted after signoffs to identify monograph file signoffs.
      // Delete monograph files.
      $submissionFileDao =& DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */
      $submissionFileDao->deleteAllRevisionsBySubmissionId($monographId);

      // Delete monograph file directory.
      $monograph =& $this->getById($monographId);
      assert(is_a($monograph, 'Monograph'));

      import('classes.file.MonographFileManager');
      $monographFileManager = new MonographFileManager($monograph->getPressId(), $monograph->getId());
      $monographFileManager->rmtree($monographFileManager->getBasePath());

      // Delete any comments.
      $monographCommentDao =& DAORegistry::getDAO('MonographCommentDAO');
      $monographCommentDao->deleteByMonographId($monographId);

      // Delete references to features or new releases.
      $featureDao =& DAORegistry::getDAO('FeatureDAO');
      $featureDao->deleteByMonographId($monographId);

      $newReleaseDao =& DAORegistry::getDAO('NewReleaseDAO');
      $newReleaseDao->deleteByMonographId($monographId);

      // Delete any outstanding notifications for this monograph
      $notificationDao =& DAORegistry::getDAO('NotificationDAO');
      $notificationDao->deleteByAssoc(ASSOC_TYPE_MONOGRAPH, $monographId);

      $this->update('DELETE FROM monograph_settings WHERE monograph_id = ?', (int) $monographId);
      $this->update('DELETE FROM monographs WHERE monograph_id = ?', (int) $monographId);
   }

   function &getByPressId($pressId) {
      $primaryLocale = AppLocale::getPrimaryLocale();
      $locale = AppLocale::getLocale();

      $result =& $this->retrieve(
         'SELECT  m.*, pm.date_published,
            COALESCE(stl.setting_value, stpl.setting_value) AS series_title,
            COALESCE(sal.setting_value, sapl.setting_value) AS series_abbrev
         FROM  monographs m
            LEFT JOIN series s ON s.series_id = m.series_id
            LEFT JOIN series_settings stpl ON (s.series_id = stpl.series_id AND stpl.setting_name = ? AND stpl.locale = ?)
            LEFT JOIN series_settings stl ON (s.series_id = stl.series_id AND stl.setting_name = ? AND stl.locale = ?)
            LEFT JOIN series_settings sapl ON (s.series_id = sapl.series_id AND sapl.setting_name = ? AND sapl.locale = ?)
            LEFT JOIN series_settings sal ON (s.series_id = sal.series_id AND sal.setting_name = ? AND sal.locale = ?)
            LEFT JOIN published_monographs pm ON (m.monograph_id = pm.monograph_id)
         WHERE m.press_id = ?',
         array(
            'title', $primaryLocale, // Series title
            'title', $locale, // Series title
            'abbrev', $primaryLocale, // Series abbreviation
            'abbrev', $locale, // Series abbreviation
            (int) $pressId
         )
      );

      $returner = new DAOResultFactory($result, $this, '_fromRow');
      return $returner;
   }

   function &getUnpublishedMonographsByPressId($pressId) {
      $primaryLocale = AppLocale::getPrimaryLocale();
      $locale = AppLocale::getLocale();

      $result =& $this->retrieve(
         'SELECT  m.*, pm.date_published,
            COALESCE(stl.setting_value, stpl.setting_value) AS series_title,
            COALESCE(sal.setting_value, sapl.setting_value) AS series_abbrev
         FROM  monographs m
            LEFT JOIN series s ON s.series_id = m.series_id
            LEFT JOIN series_settings stpl ON (s.series_id = stpl.series_id AND stpl.setting_name = ? AND stpl.locale = ?)
            LEFT JOIN series_settings stl ON (s.series_id = stl.series_id AND stl.setting_name = ? AND stl.locale = ?)
            LEFT JOIN series_settings sapl ON (s.series_id = sapl.series_id AND sapl.setting_name = ? AND sapl.locale = ?)
            LEFT JOIN series_settings sal ON (s.series_id = sal.series_id AND sal.setting_name = ? AND sal.locale = ?)
            LEFT JOIN published_monographs pm ON (m.monograph_id = pm.monograph_id)
         WHERE m.press_id = ? AND
            (pm.monograph_id IS NULL OR pm.date_published IS NULL) AND
            m.submission_progress = 0',
         array(
            'title', $primaryLocale, // Series title
            'title', $locale, // Series title
            'abbrev', $primaryLocale, // Series abbreviation
            'abbrev', $locale, // Series abbreviation
            (int) $pressId
         )
      );

      $returner = new DAOResultFactory($result, $this, '_fromRow');
      return $returner;
   }

   function deleteByPressId($pressId) {
      $monographs = $this->getByPressId($pressId);
      import('classes.search.MonographSearchIndex');
      while ($monograph =& $monographs->next()) {
         if ($monograph->getDatePublished()) {
            MonographSearchIndex::deleteTextIndex($monograph->getId());
         }
         $this->deleteById($monograph->getId());
         unset($monograph);
      }
   }

   function &getByUserId($userId, $pressId = null) {
      $primaryLocale = AppLocale::getPrimaryLocale();
      $locale = AppLocale::getLocale();
      $params = array(
         'title', $primaryLocale, // Series title
         'title', $locale, // Series title
         'abbrev', $primaryLocale, // Series abbreviation
         'abbrev', $locale, // Series abbreviation
         (int) $userId
      );
      if ($pressId) $params[] = $pressId;

      $result =& $this->retrieve(
         'SELECT  m.*, pm.date_published,
            COALESCE(atl.setting_value, atpl.setting_value) AS series_title,
            COALESCE(aal.setting_value, aapl.setting_value) AS series_abbrev
         FROM  monographs m
            LEFT JOIN series aa ON (aa.series_id = m.series_id)
            LEFT JOIN series_settings atpl ON (aa.series_id = atpl.series_id AND atpl.setting_name = ? AND atpl.locale = ?)
            LEFT JOIN series_settings atl ON (aa.series_id = atl.series_id AND atl.setting_name = ? AND atl.locale = ?)
            LEFT JOIN series_settings aapl ON (aa.series_id = aapl.series_id AND aapl.setting_name = ? AND aapl.locale = ?)
            LEFT JOIN series_settings aal ON (aa.series_id = aal.series_id AND aal.setting_name = ? AND aal.locale = ?)
            LEFT JOIN published_monographs pm ON (m.monograph_id = pm.monograph_id)
         WHERE m.user_id = ?' .
            (isset($pressId)?' AND m.press_id = ?':''),
         $params
      );

      $returner = new DAOResultFactory($result, $this, '_fromRow');
      return $returner;
   }

   function removeMonographsFromSeries($seriesId) {
      $this->update(
         'UPDATE monographs SET series_id = null WHERE series_id = ?',
         (int) $seriesId
      );

      $this->flushCache();
   }

   function getInsertMonographId() {
      return $this->getInsertId('monographs', 'monograph_id');
   }

   function flushCache() {
      // Because both publishedMonographs and monographs are cached by
      // monograph ID, flush both caches on update.
      $cache =& $this->_getCache();
      $cache->flush();
      unset($cache);

      //TODO: flush cache of publishedMonographDAO once created
   }

   function &getMonographsBySeriesEditorId($pressId = null, $seriesEditorId = null) {
      $primaryLocale = AppLocale::getPrimaryLocale();
      $locale = AppLocale::getLocale();

      $params = array(
         'title', $primaryLocale, // Series title
         'title', $locale, // Series title
         'abbrev', $primaryLocale, // Series abbreviation
         'abbrev', $locale, // Series abbreviation
         (int) ROLE_ID_PRESS_MANAGER
      );
      if ($seriesEditorId) $params[] = (int) $seriesEditorId;
      if ($pressId) $params[] = (int) $pressId;

      $result =& $this->retrieve(
         'SELECT  m.*
         FROM  monographs m
            LEFT JOIN published_monographs pm ON m.monograph_id = pm.monograph_id
            LEFT JOIN series s ON s.series_id = m.series_id
            LEFT JOIN series_settings stpl ON (s.series_id = stpl.series_id AND stpl.setting_name = ? AND stpl.locale = ?)
            LEFT JOIN series_settings stl ON (s.series_id = stl.series_id AND stl.setting_name = ? AND stl.locale = ?)
            LEFT JOIN series_settings sapl ON (s.series_id = sapl.series_id AND sapl.setting_name = ? AND sapl.locale = ?)
            LEFT JOIN series_settings sal ON (s.series_id = sal.series_id AND sal.setting_name = ? AND sal.locale = ?)
            LEFT JOIN stage_assignments sa ON (m.monograph_id = sa.submission_id)
            LEFT JOIN user_groups g ON (sa.user_group_id = g.user_group_id AND g.role_id = ?)
            ' . ($seriesEditorId?' JOIN series_editors se ON (se.press_id = m.press_id AND se.user_id = ? AND se.series_id = m.series_id)':'') . '
         WHERE m.date_submitted IS NOT NULL
            ' . ($pressId?' AND m.press_id = ?':'') . '
         GROUP BY m.monograph_id',
         $params
      );

      $returner = new DAOResultFactory($result, $this, '_fromRow');
      return $returner;
   }

   function addCategory($monographId, $categoryId) {
      $this->update(
         'INSERT INTO monograph_categories
            (monograph_id, category_id)
         VALUES
            (?, ?)',
         array(
            (int) $monographId,
            (int) $categoryId
         )
      );
   }

   function removeCategory($monographId, $categoryId) {
      $this->update(
         'DELETE FROM monograph_categories WHERE monograph_id = ? AND category_id = ?',
         array(
            (int) $monographId,
            (int) $categoryId
         )
      );

      // If any new release or feature object is associated
      // with this category delete them.
      $newReleaseDao =& DAORegistry::getDAO('NewReleaseDAO'); /* @var $newReleaseDao NewReleaseDAO */
      $newReleaseDao->deleteNewRelease($monographId, ASSOC_TYPE_CATEGORY, $categoryId);

      $featureDao =& DAORegistry::getDAO('FeatureDAO'); /* @var $featureDao FeatureDAO */
      $featureDao->deleteFeature($monographId, ASSOC_TYPE_CATEGORY, $categoryId);
   }

   function removeCategories($monographId) {
      $this->update(
         'DELETE FROM monograph_categories WHERE monograph_id = ?',
         (int) $monographId
      );
   }

   function getCategories($monographId, $pressId = null) {
      $params = array((int) $monographId);
      if ($pressId) $params[] = (int) $pressId;

      $categoryDao =& DAORegistry::getDAO('CategoryDAO');
      $result =& $this->retrieve(
         'SELECT  c.*
         FROM  categories c,
            monograph_categories mc,
            monographs m
         WHERE c.category_id = mc.category_id AND
            m.monograph_id = ? AND
         ' . ($pressId?' c.press_id = m.press_id AND m.press_id = ? AND':'') . '
            m.monograph_id = mc.monograph_id',
         $params
      );

      // Delegate category creation to the category DAO.
      $returner = new DAOResultFactory($result, $categoryDao, '_fromRow');
      return $returner;
   }

   function getUnassignedCategories($monographId, $pressId = null) {
      $params = array((int) $monographId);
      if ($pressId) $params[] = (int) $pressId;

      $categoryDao =& DAORegistry::getDAO('CategoryDAO');
      // The strange ORDER BY clause is to return subcategories
      // immediately after their parent category's entry.
      $result =& $this->retrieve(
         'SELECT  c.*
         FROM  monographs m
            JOIN categories c ON (c.press_id = m.press_id)
            LEFT JOIN monograph_categories mc ON (m.monograph_id = mc.monograph_id AND mc.category_id = c.category_id)
         WHERE m.monograph_id = ? AND
            ' . ($pressId?' m.press_id = ? AND':'') . '
            mc.monograph_id IS NULL
         ORDER BY CASE WHEN c.parent_id = 0 THEN c.category_id * 2 ELSE (c.parent_id * 2) + 1 END ASC',
         $params
      );

      // Delegate category creation to the category DAO.
      $returner = new DAOResultFactory($result, $categoryDao, '_fromRow');
      return $returner;
   }

   function categoryAssociationExists($monographId, $categoryId) {
      $result =& $this->retrieve(
         'SELECT COUNT(*) FROM monograph_categories WHERE monograph_id = ? AND category_id = ?',
         array((int) $monographId, (int) $categoryId)
      );
      $returner = isset($result->fields[0]) && $result->fields[0] == 1 ? true : false;

      $result->Close();
      unset($result);

      return $returner;
   }
}

?>