IssueDAO.inc.php

<?php
 
import('classes.issue.Issue');
import('lib.pkp.classes.submission.PKPSubmission'); // STATUS_... constants
import('lib.pkp.classes.plugins.PKPPubIdPluginDAO');
 
class IssueDAO extends DAO implements PKPPubIdPluginDAO {
   var $caches;
 
   function _cacheMiss($cache, $id) {
      if ($cache->getCacheId() === 'current') {
         $issue = $this->getCurrent($id, false);
      } else {
         $issue = $this->getByBestId($id, null, false);
      }
      $cache->setCache($id, $issue);
      return $issue;
   }
 
   function _getCache($cacheId) {
      if (!isset($this->caches)) $this->caches = array();
      if (!isset($this->caches[$cacheId])) {
         $cacheManager = CacheManager::getManager();
         $this->caches[$cacheId] = $cacheManager->getObjectCache('issues', $cacheId, array($this, '_cacheMiss'));
      }
      return $this->caches[$cacheId];
   }
 
   function getById($issueId, $journalId = null, $useCache = false) {
      if ($useCache) {
         $cache = $this->_getCache('issues');
         $returner = $cache->get($issueId);
         if ($returner && $journalId != null && $journalId != $returner->getJournalId()) $returner = null;
         return $returner;
      }
 
      $params = array((int) $issueId);
      if ($journalId) $params[] = (int) $journalId;
      $result = $this->retrieve(
         'SELECT i.* FROM issues i WHERE issue_id = ?'
         . ($journalId?' AND journal_id = ?':''),
         $params
      );
 
      $issue = null;
      if ($result->RecordCount() != 0) {
         $issue = $this->_returnIssueFromRow($result->GetRowAssoc(false));
      }
      $result->Close();
      return $issue;
   }
 
   function getByPubId($pubIdType, $pubId, $journalId = null, $useCache = false) {
      if ($useCache && $pubIdType == 'publisher-id') {
         $cache = $this->_getCache('issues');
         $returner = $cache->get($pubId);
         if ($returner && $journalId != null && $journalId != $returner->getJournalId()) $returner = null;
         return $returner;
      }
 
      $issues = $this->getBySetting('pub-id::'.$pubIdType, $pubId, $journalId);
      if (empty($issues)) {
         return null;
      } else {
         assert(count($issues) == 1);
         return $issues[0];
      }
   }
 
   function getBySetting($settingName, $settingValue, $journalId = null) {
      $params = array($settingName);
      $sql = 'SELECT i.*
         FROM  issues i ';
      if (is_null($settingValue)) {
         $sql .= 'LEFT JOIN issue_settings ist ON i.issue_id = ist.issue_id AND ist.setting_name = ?
            WHERE (ist.setting_value IS NULL OR ist.setting_value = \'\')';
      } else {
         $params[] = (string) $settingValue;
         $sql .= 'INNER JOIN issue_settings ist ON i.issue_id = ist.issue_id
            WHERE ist.setting_name = ? AND ist.setting_value = ?';
      }
      if ($journalId) {
         $params[] = (int) $journalId;
         $sql .= ' AND i.journal_id = ?';
      }
      $sql .= ' ORDER BY i.issue_id';
      $result = $this->retrieve($sql, $params);
 
      $issues = array();
      while (!$result->EOF) {
         $issues[] = $this->_returnIssueFromRow($result->GetRowAssoc(false));
         $result->MoveNext();
      }
      $result->Close();
      return $issues;
   }
 
   function getPublishedIssuesByNumber($journalId, $volume = null, $number = null, $year = null) {
      $sql = 'SELECT i.* FROM issues i WHERE i.published = 1 AND i.journal_id = ?';
      $params = array((int) $journalId);
 
      if ($volume !== null) {
         $sql .= ' AND i.volume = ?';
         $params[] = (int) $volume;
      }
      if ($number !== null) {
         $sql .= ' AND i.number = ?';
         $params[] = $number;
      }
      if ($year !== null) {
         $sql .= ' AND i.year = ?';
         $params[] = $year;
      }
 
      $result = $this->retrieve($sql, $params);
      return new DAOResultFactory($result, $this, '_returnIssueFromRow');
   }
 
   function getIssuesByIdentification($journalId, $volume = null, $number = null, $year = null, $titles = array()) {
      $params = array();
 
      $i = 1;
      $sqlTitleJoin = '';
      foreach ($titles as $title) {
         $sqlTitleJoin .= ' JOIN issue_settings iss' .$i .' ON (i.issue_id = iss' .$i .'.issue_id AND iss' .$i .'.setting_name = \'title\' AND iss' .$i .'.setting_value = ?)';
         $params[] = $title;
         $i++;
      }
      $params[] = (int) $journalId;
      if ($volume !== null) {
         $params[] = (int) $volume;
      }
      if ($number !== null) {
         $params[] = $number;
      }
      if ($year !== null) {
         $params[] = (int) $year;
      }
 
      $result = $this->retrieve(
         'SELECT i.*
         FROM issues i'
         .$sqlTitleJoin
         .' WHERE i.journal_id = ?'
         .(($volume !== null)?' AND i.volume = ?':'')
         .(($number !== null)?' AND i.number = ?':'')
         .(($year !== null)?' AND i.year = ?':''),
         $params
      );
      return new DAOResultFactory($result, $this, '_returnIssueFromRow');
   }
 
   function getByBestId($issueId, $contextId = null, $useCache = false) {
      $params = [
         $issueId
      ];
      if ($contextId) $params[] = (int) $contextId;
 
      $result = $this->retrieve(
         'SELECT i.* FROM issues i WHERE url_path = ?'
         . ($contextId?' AND journal_id = ?':''),
         $params
      );
 
      if ($result->RecordCount() != 0) {
         $issue = $this->_returnIssueFromRow($result->GetRowAssoc(false));
      } elseif (is_int($issueId) || ctype_digit($issueId)) {
         $issue = $this->getById($issueId);
      }
      $result->Close();
 
      return $issue ?? null;
   }
 
   function getCurrent($journalId, $useCache = false) {
      if ($useCache) {
         $cache = $this->_getCache('current');
         return $cache->get($journalId);
      }
 
      $result = $this->retrieve(
         'SELECT i.* FROM issues i WHERE journal_id = ? AND current = 1', (int) $journalId
      );
 
      $issue = null;
      if ($result->RecordCount() != 0) {
         $issue = $this->_returnIssueFromRow($result->GetRowAssoc(false));
      }
      $result->Close();
      return $issue;
   }
 
   function updateCurrent($journalId, $issue = null) {
      $this->update(
         'UPDATE issues SET current = 0 WHERE journal_id = ? AND current = 1', (int) $journalId
      );
      if ($issue) $this->updateObject($issue);
 
      $this->flushCache();
   }
 
 
   function newDataObject() {
      return new Issue();
   }
 
   function _fromRow($row) {
      $issue = $this->newDataObject();
      $issue->setId($row['issue_id']);
      $issue->setJournalId($row['journal_id']);
      $issue->setVolume($row['volume']);
      $issue->setNumber($row['number']);
      $issue->setYear($row['year']);
      $issue->setPublished($row['published']);
      $issue->setCurrent($row['current']);
      $issue->setDatePublished($this->datetimeFromDB($row['date_published']));
      $issue->setDateNotified($this->datetimeFromDB($row['date_notified']));
      $issue->setLastModified($this->datetimeFromDB($row['last_modified']));
      $issue->setAccessStatus($row['access_status']);
      $issue->setOpenAccessDate($this->datetimeFromDB($row['open_access_date']));
      $issue->setShowVolume($row['show_volume']);
      $issue->setShowNumber($row['show_number']);
      $issue->setShowYear($row['show_year']);
      $issue->setShowTitle($row['show_title']);
      $issue->setData('urlPath', $row['url_path']);
 
      $this->getDataObjectSettings('issue_settings', 'issue_id', $row['issue_id'], $issue);
 
      HookRegistry::call('IssueDAO::_fromRow', array(&$issue, &$row));
 
      return $issue;
   }
 
   function _returnIssueFromRow($row) {
      $issue = self::_fromRow($row);
      HookRegistry::call('IssueDAO::_returnIssueFromRow', array(&$issue, &$row));
      return $issue;
   }
 
   function getLocaleFieldNames() {
      return array('title', 'description', 'coverImageAltText', 'coverImage');
   }
 
   function getAdditionalFieldNames() {
      $additionalFields = parent::getAdditionalFieldNames();
      // FIXME: Move this to a PID plug-in.
      $additionalFields[] = 'pub-id::publisher-id';
      return $additionalFields;
   }
 
   function updateLocaleFields(&$issue) {
      $this->updateDataObjectSettings('issue_settings', $issue, array(
         'issue_id' => $issue->getId()
      ));
   }
 
   function insertObject($issue) {
      $this->update(
         sprintf('INSERT INTO issues
            (journal_id, volume, number, year, published, current, date_published, date_notified, last_modified, access_status, open_access_date, show_volume, show_number, show_year, show_title, url_path)
            VALUES
            (?, ?, ?, ?, ?, ?, %s, %s, %s, ?, %s, ?, ?, ?, ?, ?)',
            $this->datetimeToDB($issue->getDatePublished()), $this->datetimeToDB($issue->getDateNotified()), $this->datetimeToDB($issue->getLastModified()), $this->datetimeToDB($issue->getOpenAccessDate())),
         array(
            (int) $issue->getJournalId(),
            $this->nullOrInt($issue->getVolume()),
            $issue->getNumber(),
            $this->nullOrInt($issue->getYear()),
            (int) $issue->getPublished(),
            (int) $issue->getCurrent(),
            (int) $issue->getAccessStatus(),
            (int) $issue->getShowVolume(),
            (int) $issue->getShowNumber(),
            (int) $issue->getShowYear(),
            (int) $issue->getShowTitle(),
            $issue->getData('urlPath'),
         )
      );
 
      $issue->setId($this->getInsertId());
 
      $this->updateLocaleFields($issue);
 
      $this->resequenceCustomIssueOrders($issue->getJournalId());
 
      return $issue->getId();
   }
 
   function getInsertId() {
      return $this->_getInsertId('issues', 'issue_id');
   }
 
   function issueExists($journalId, $volume, $number, $year, $issueId) {
      $result = $this->retrieve(
         'SELECT i.* FROM issues i WHERE journal_id = ? AND volume = ? AND number = ? AND year = ? AND issue_id <> ?',
         array((int) $journalId, $this->nullOrInt($volume), $number, $year, (int) $issueId)
      );
      $returner = $result->RecordCount() != 0 ? true : false;
      $result->Close();
      return $returner;
   }
 
   function updateObject($issue) {
      $issue->stampModified();
      $this->update(
         sprintf('UPDATE issues
            SET
               journal_id = ?,
               volume = ?,
               number = ?,
               year = ?,
               published = ?,
               current = ?,
               date_published = %s,
               date_notified = %s,
               last_modified = %s,
               open_access_date = %s,
               access_status = ?,
               show_volume = ?,
               show_number = ?,
               show_year = ?,
               show_title = ?,
               url_path = ?
            WHERE issue_id = ?',
         $this->datetimeToDB($issue->getDatePublished()), $this->datetimeToDB($issue->getDateNotified()), $this->datetimeToDB($issue->getLastModified()), $this->datetimeToDB($issue->getOpenAccessDate())),
         array(
            (int) $issue->getJournalId(),
            $this->nullOrInt($issue->getVolume()),
            $issue->getNumber(),
            $this->nullOrInt($issue->getYear()),
            (int) $issue->getPublished(),
            (int) $issue->getCurrent(),
            (int) $issue->getAccessStatus(),
            (int) $issue->getShowVolume(),
            (int) $issue->getShowNumber(),
            (int) $issue->getShowYear(),
            (int) $issue->getShowTitle(),
            $issue->getData('urlPath'),
            (int) $issue->getId(),
         )
      );
 
      $this->updateLocaleFields($issue);
 
      $this->resequenceCustomIssueOrders($issue->getJournalId());
 
      $this->flushCache();
   }
 
   function deleteObject($issue) {
      import('classes.file.PublicFileManager');
      $publicFileManager = new PublicFileManager();
 
      if (is_array($issue->getCoverImage(null))) {
         foreach ($issue->getCoverImage(null) as $coverImage) {
            if ($coverImage != '') {
               $publicFileManager->removeContextFile($issue->getJournalId(), $coverImage);
            }
         }
      }
 
      $issueId = $issue->getId();
 
      // Delete issue-specific ordering if it exists.
      $sectionDao = DAORegistry::getDAO('SectionDAO'); /* @var $sectionDao SectionDAO */
      $sectionDao->deleteCustomSectionOrdering($issueId);
 
      // Delete published issue galleys and issue files
      $issueGalleyDao = DAORegistry::getDAO('IssueGalleyDAO'); /* @var $issueGalleyDao IssueGalleyDAO */
      $issueGalleyDao->deleteByIssueId($issueId);
 
      $issueFileDao = DAORegistry::getDAO('IssueFileDAO'); /* @var $issueFileDao IssueFileDAO */
      $issueFileDao->deleteByIssueId($issueId);
 
      import('classes.file.IssueFileManager');
      $issueFileManager = new IssueFileManager($issueId);
      $issueFileManager->deleteIssueTree();
 
      // Delete issue settings and issue
      $this->update('DELETE FROM issue_settings WHERE issue_id = ?', (int) $issueId);
      $this->update('DELETE FROM issues WHERE issue_id = ?', (int) $issueId);
      $this->update('DELETE FROM custom_issue_orders WHERE issue_id = ?', (int) $issueId);
      $this->resequenceCustomIssueOrders($issue->getJournalId());
 
      $this->flushCache();
   }
 
   function deleteByJournalId($journalId) {
      $issues = $this->getIssues($journalId);
      while ($issue = $issues->next()) {
         $this->deleteObject($issue);
      }
   }
 
   function issueIdExists($issueId, $journalId) {
      $result = $this->retrieve(
         'SELECT COUNT(*) FROM issues WHERE issue_id = ? AND journal_id = ?',
         array((int) $issueId, (int) $journalId)
      );
      return $result->fields[0] ? true : false;
   }
 
   function getBySubmissionId($articleId, $journalId = null) {
      $params = ['issueId', (int) $articleId];
      if ($journalId) $params[] = (int) $journalId;
 
      $result = $this->retrieve(
         'SELECT  i.*
         FROM  issues i,
            submissions a
         LEFT JOIN publications p ON (p.publication_id = a.current_publication_id)
         LEFT JOIN publication_settings ps ON (ps.publication_id = p.publication_id)
         WHERE ps.setting_name = ? AND ps.setting_value = CAST(i.issue_id as CHAR) AND
            a.submission_id = ? AND
            a.context_id = i.journal_id' .
            ($journalId?' AND i.journal_id = ?':''),
         $params
      );
 
      $issue = null;
      if ($result->RecordCount() != 0) {
         $issue = $this->_returnIssueFromRow($result->GetRowAssoc(false));
      }
 
      $result->Close();
      return $issue;
   }
 
   function getIssues($journalId, $rangeInfo = null) {
      $result = $this->retrieveRange(
         'SELECT i.* FROM issues i WHERE journal_id = ? ORDER BY current DESC, date_published DESC',
         (int) $journalId, $rangeInfo
      );
 
      return new DAOResultFactory($result, $this, '_returnIssueFromRow');
   }
 
   function getPublishedIssues($journalId, $rangeInfo = null) {
      $result = $this->retrieveRange(
         'SELECT i.* FROM issues i LEFT JOIN custom_issue_orders o ON (o.issue_id = i.issue_id) WHERE i.journal_id = ? AND i.published = 1 ORDER BY o.seq ASC, i.current DESC, i.date_published DESC',
         (int) $journalId, $rangeInfo
      );
 
      return new DAOResultFactory($result, $this, '_returnIssueFromRow');
   }
 
   function getUnpublishedIssues($journalId, $rangeInfo = null) {
      $result = $this->retrieveRange(
         'SELECT i.* FROM issues i WHERE journal_id = ? AND published = 0 ORDER BY year ASC, volume ASC, number ASC',
         (int) $journalId, $rangeInfo
      );
 
      return new DAOResultFactory($result, $this, '_returnIssueFromRow');
   }
 
   function getExportable($contextId, $pubIdType = null, $pubIdSettingName = null, $pubIdSettingValue = null, $rangeInfo = null) {
      $params = array();
      if ($pubIdSettingName) {
         $params[] = $pubIdSettingName;
      }
      $params[] = (int) $contextId;
      if ($pubIdType) {
         $params[] = 'pub-id::'.$pubIdType;
      }
      import('classes.plugins.PubObjectsExportPlugin');
      if ($pubIdSettingName && $pubIdSettingValue && $pubIdSettingValue != EXPORT_STATUS_NOT_DEPOSITED) {
         $params[] = $pubIdSettingValue;
      }
 
      $result = $this->retrieveRange(
         'SELECT i.*
         FROM issues i
            LEFT JOIN custom_issue_orders o ON (o.issue_id = i.issue_id)
            ' . ($pubIdType != null?' LEFT JOIN issue_settings ist ON (i.issue_id = ist.issue_id)':'')
            . ($pubIdSettingName != null?' LEFT JOIN issue_settings iss ON (i.issue_id = iss.issue_id AND iss.setting_name = ?)':'') .'
         WHERE
            i.published = 1  AND i.journal_id = ?
            ' . ($pubIdType != null?' AND ist.setting_name = ? AND ist.setting_value IS NOT NULL':'')
            . (($pubIdSettingName != null && $pubIdSettingValue != null && $pubIdSettingValue == EXPORT_STATUS_NOT_DEPOSITED)?' AND iss.setting_value IS NULL':'')
            . (($pubIdSettingName != null && $pubIdSettingValue != null && $pubIdSettingValue != EXPORT_STATUS_NOT_DEPOSITED)?' AND iss.setting_value = ?':'')
            . (($pubIdSettingName != null && is_null($pubIdSettingValue))?' AND (iss.setting_value IS NULL OR iss.setting_value = \'\')':'')
            .' ORDER BY i.date_published DESC',
         $params,
         $rangeInfo
      );
 
      return new DAOResultFactory($result, $this, '_returnIssueFromRow');
   }
 
   function getNumArticles($issueId) {
      $result = $this->retrieve(
         'SELECT COUNT(*)
            FROM submissions s
            LEFT JOIN publications p ON (p.publication_id = s.current_publication_id)
            LEFT JOIN publication_settings ps ON (ps.publication_id = p.publication_id)
            WHERE ps.setting_name = ? AND ps.setting_value = ? AND (s.status = ? or s.status = ?) ',
         ['issueId', (int) $issueId, (int) STATUS_SCHEDULED, (int) STATUS_PUBLISHED]
      );
      $returner = isset($result->fields[0]) ? $result->fields[0] : 0;
      $result->Close();
      return $returner;
   }
 
   function deleteCustomIssueOrdering($journalId) {
      $this->update(
         'DELETE FROM custom_issue_orders WHERE journal_id = ?', (int) $journalId
      );
   }
 
   function resequenceCustomIssueOrders($journalId) {
      // If no custom issue ordering already exists, there is nothing to do
      if (!$this->customIssueOrderingExists($journalId)) {
         return;
      }
      $result = $this->retrieve(
         'SELECT i.issue_id FROM issues i LEFT JOIN custom_issue_orders o ON (o.issue_id = i.issue_id) WHERE i.journal_id = ? ORDER BY o.seq',
         (int) $journalId
      );
 
      for ($i=1; !$result->EOF; $i++) {
         list($issueId) = $result->fields;
         $resultB = $this->retrieve('SELECT issue_id FROM custom_issue_orders WHERE journal_id=? AND issue_id=?', array($journalId, $issueId));
         if (!$resultB->EOF) {
            $this->update(
               'UPDATE custom_issue_orders SET seq = ? WHERE issue_id = ? AND journal_id = ?',
               array($i, $issueId, $journalId)
            );
         } else {
            // This entry is missing. Create it.
            $this->insertCustomIssueOrder($journalId, $issueId, $i);
         }
         $resultB->Close();
         $result->MoveNext();
      }
      $result->Close();
   }
 
   function customIssueOrderingExists($journalId) {
      $result = $this->retrieve(
         'SELECT COUNT(*) FROM custom_issue_orders WHERE journal_id = ?',
         (int) $journalId
      );
      $returner = isset($result->fields[0]) && $result->fields[0] == 0 ? false : true;
      $result->Close();
      return $returner;
   }
 
   function getCustomIssueOrder($journalId, $issueId) {
      $result = $this->retrieve(
         'SELECT seq FROM custom_issue_orders WHERE journal_id = ? AND issue_id = ?',
         array((int) $journalId, (int) $issueId)
      );
 
      $returner = null;
      if (!$result->EOF) {
         list($returner) = $result->fields;
      }
      $result->Close();
      return $returner;
   }
 
   function setDefaultCustomIssueOrders($journalId) {
      $publishedIssues = $this->getPublishedIssues($journalId);
      for ($i=1; $issue = $publishedIssues->next(); $i++) {
         $this->insertCustomIssueOrder($journalId, $issue->getId(), $i);
      }
   }
 
   function insertCustomIssueOrder($journalId, $issueId, $seq) {
      $this->update(
         'INSERT INTO custom_issue_orders (issue_id, journal_id, seq) VALUES (?, ?, ?)',
         array(
            (int) $issueId,
            (int) $journalId,
            $seq
         )
      );
   }
 
   function moveCustomIssueOrder($journalId, $issueId, $newPos) {
      $result = $this->retrieve('SELECT issue_id FROM custom_issue_orders WHERE journal_id=? AND issue_id=?', array((int) $journalId, (int) $issueId));
      if (!$result->EOF) {
         $this->update(
            'UPDATE custom_issue_orders SET seq = ? WHERE journal_id = ? AND issue_id = ?',
            array($newPos, (int) $journalId, (int) $issueId)
         );
      } else {
         // This entry is missing. Create it.
         $this->insertCustomIssueOrder($journalId, $issueId, $newPos);
      }
      $result->Close();
   }
 
   function pubIdExists($pubIdType, $pubId, $excludePubObjectId, $contextId) {
      $result = $this->retrieve(
         'SELECT COUNT(*)
         FROM issue_settings ist
            INNER JOIN issues i ON ist.issue_id = i.issue_id
         WHERE ist.setting_name = ? AND ist.setting_value = ? AND i.issue_id <> ? AND i.journal_id = ?',
         array(
            'pub-id::'.$pubIdType,
            $pubId,
            (int) $excludePubObjectId,
            (int) $contextId
         )
      );
      $returner = $result->fields[0] ? true : false;
      $result->Close();
      return $returner;
   }
 
   function changePubId($pubObjectId, $pubIdType, $pubId) {
      $idFields = array(
         'issue_id', 'locale', 'setting_name'
      );
      $updateArray = array(
         'issue_id' => (int) $pubObjectId,
         'locale' => '',
         'setting_name' => 'pub-id::'.$pubIdType,
         'setting_type' => 'string',
         'setting_value' => (string)$pubId
      );
      $this->replace('issue_settings', $updateArray, $idFields);
      $this->flushCache();
   }
 
   function deletePubId($pubObjectId, $pubIdType) {
      $settingName = 'pub-id::'.$pubIdType;
      $this->update(
         'DELETE FROM issue_settings WHERE setting_name = ? AND issue_id = ?',
         array(
            $settingName,
            (int)$pubObjectId
         )
      );
      $this->flushCache();
   }
 
   function deleteAllPubIds($contextId, $pubIdType) {
      $settingName = 'pub-id::'.$pubIdType;
 
      // issues
      $issues = $this->getIssues($contextId);
      while ($issue = $issues->next()) {
         $this->update(
            'DELETE FROM issue_settings WHERE setting_name = ? AND issue_id = ?',
            array(
               $settingName,
               (int)$issue->getId()
            )
         );
      }
      $this->flushCache();
   }
 
   function flushCache() {
      $this->_getCache('issues')->flush();
      $this->_getCache('current')->flush();
   }
}