DepositObjectDAO.inc.php

<?php
 
import('lib.pkp.classes.db.DAO');
import('lib.pkp.classes.submission.PKPSubmission'); // STATUS_PUBLISHED constant
 
class DepositObjectDAO extends DAO {
   public function getById($journalId, $depositObjectId) {
      $result = $this->retrieve(
         'SELECT * FROM pln_deposit_objects WHERE journal_id = ? and deposit_object_id = ?',
         array(
            (int) $journalId,
            (int) $depositObjectId
         )
      );
 
      $returner = null;
      if ($result->RecordCount() != 0) {
         $returner = $this->_fromRow($result->GetRowAssoc(false));
      }
 
      $result->Close();
 
      return $returner;
   }
 
   public function getByDepositId($journalId, $depositId) {
      $result = $this->retrieve(
         'SELECT * FROM pln_deposit_objects WHERE journal_id = ? AND deposit_id = ?',
         array (
            (int) $journalId,
            (int) $depositId
         )
      );
 
      return new DAOResultFactory($result, $this, '_fromRow');
   }
 
   public function getNew($journalId) {
      $result = $this->retrieve(
         'SELECT * FROM pln_deposit_objects WHERE journal_id = ? AND deposit_id = 0',
         (int) $journalId
      );
 
      return new DAOResultFactory($result, $this, '_fromRow');
   }
 
   public function markHavingUpdatedContent($journalId, $objectType) {
      $depositDao = DAORegistry::getDAO('DepositDAO');
 
      switch ($objectType) {
         case 'PublishedArticle': // Legacy (OJS pre-3.2)
         case PLN_PLUGIN_DEPOSIT_OBJECT_SUBMISSION:
            $result = $this->retrieve(
               'SELECT pdo.deposit_object_id, a.last_modified FROM pln_deposit_objects pdo
               JOIN submissions s ON pdo.object_id = s.submission_id
               JOIN publications p ON p.publication_id = s.current_publication_id
               WHERE s.context_id = ? AND pdo.journal_id = ? AND pdo.date_modified < p.last_modified',
               array (
                  (int) $journalId,
                  (int) $journalId
               )
            );
            while (!$result->EOF) {
               $row = $result->GetRowAssoc(false);
               $depositObject = $this->getById($journalId, $row['deposit_object_id']);
               $deposit = $depositDao->getById($depositObject->getDepositId());
               if($deposit->getSentStatus() || !$deposit->getTransferredStatus()) {
                  // only update a deposit after it has been synced in LOCKSS.
                  $depositObject->setDateModified($row['last_modified']);
                  $this->updateObject($depositObject);
                  $deposit->setNewStatus();
                  $deposit->setLockssAgreementStatus(true); // this is an update.
                  $depositDao->updateObject($deposit);
               }
               $result->MoveNext();
            }
            $result->Close();
            break;
         case PLN_PLUGIN_DEPOSIT_OBJECT_ISSUE:
            $result = $this->retrieve(
               'SELECT pdo.deposit_object_id, MAX(i.last_modified) as issue_modified, MAX(p.last_modified) as article_modified
               FROM issues i
               JOIN pln_deposit_objects pdo ON pdo.object_id = i.issue_id
               JOIN publication_settings ps ON (CAST(i.issue_id AS CHAR) = ps.setting_value AND ps.setting_name = ?)
               JOIN publications p ON (p.publication_id = ps.publication_id AND p.status = ?)
               JOIN submissions s ON s.current_publication_id = p.publication_id
               WHERE (pdo.date_modified < p.last_modified OR pdo.date_modified < i.last_modified)
               AND (pdo.journal_id = ?)
               GROUP BY pdo.deposit_object_id',
               array(
                  'issueId',
                  STATUS_PUBLISHED,
                  (int) $journalId,
               )
            );
            while (!$result->EOF) {
               $row = $result->GetRowAssoc(false);
               $depositObject = $this->getById($journalId, $row['deposit_object_id']);
               $deposit = $depositDao->getById($depositObject->getDepositId());
               if($deposit->getSentStatus() || !$deposit->getTransferredStatus()) {
                  // only update a deposit after it has been synced in LOCKSS.
                  if ($row['issue_modified'] > $row['article_modified']) {
                     $depositObject->setDateModified($row['issue_modified']);
                  } else {
                     $depositObject->setDateModified($row['article_modified']);
                  }
 
                  $this->updateObject($depositObject);
                  $deposit->setNewStatus();
                  $deposit->setLockssAgreementStatus(true); // this is an update.
                  $depositDao->updateObject($deposit);
               }
               $result->MoveNext();
            }
            $result->Close();
            break;
         default: assert(false);
      }
   }
 
   public function createNew($journalId, $objectType) {
      $objects = array();
 
      switch ($objectType) {
         case 'PublishedArticle': // Legacy (OJS pre-3.2)
         case PLN_PLUGIN_DEPOSIT_OBJECT_SUBMISSION:
            $submissionDao = DAORegistry::getDAO('SubmissionDAO'); // Constants
            $result = $this->retrieve(
               'SELECT p.submission_id FROM publications p
               JOIN submissions s ON s.current_publication_id = p.publication_id
               LEFT JOIN pln_deposit_objects pdo ON s.submission_id = pdo.object_id
               WHERE s.journal_id = ? AND pdo.object_id is null AND p.status = ?',
               array(
                  (int) $journalId,
                  STATUS_PUBLISHED,
               )
            );
            while (!$result->EOF) {
               $row = $result->GetRowAssoc(false);
               $objects[] = $submissionDao->getById($row['submission_id']);
               $result->MoveNext();
            }
            $result->Close();
            break;
         case PLN_PLUGIN_DEPOSIT_OBJECT_ISSUE:
            $issueDao = DAORegistry::getDAO('IssueDAO');
            $result = $this->retrieve(
               'SELECT i.issue_id
               FROM issues i
               LEFT JOIN pln_deposit_objects pdo ON pdo.object_id = i.issue_id
               WHERE i.journal_id = ?
               AND i.published = 1
               AND pdo.object_id is null',
               (int) $journalId
            );
            while (!$result->EOF) {
               $row = $result->GetRowAssoc(false);
               $objects[] = $issueDao->getById($row['issue_id']);
               $result->MoveNext();
            }
            $result->Close();
            break;
         default: assert(false);
      }
 
      $depositObjects = array();
      foreach($objects as $object) {
         $depositObject = $this->newDataObject();
         $depositObject->setContent($object);
         $depositObject->setJournalId($journalId);
         $this->insertObject($depositObject);
         $depositObjects[] = $depositObject;
      }
 
      return $depositObjects;
   }
 
   public function insertObject($depositObject) {
      $this->update(
         sprintf('
            INSERT INTO pln_deposit_objects
               (journal_id,
               object_id,
               object_type,
               deposit_id,
               date_created,
               date_modified)
            VALUES
               (?, ?, ?, ?, NOW(), %s)',
            $this->datetimeToDB($depositObject->getDateModified())
         ),
         array(
            (int) $depositObject->getJournalId(),
            (int) $depositObject->getObjectId(),
            $depositObject->getObjectType(),
            (int)$depositObject->getDepositId()
         )
      );
 
      $depositObject->setId($this->getInsertId());
      return $depositObject->getId();
   }
 
   public function updateObject($depositObject) {
      $this->update(
         sprintf('
            UPDATE pln_deposit_objects SET
               journal_id = ?,
               object_type = ?,
               object_id = ?,
               deposit_id = ?,
               date_created = %s,
               date_modified = NOW()
            WHERE deposit_object_id = ?',
            $this->datetimeToDB($depositObject->getDateCreated())
         ),
         array(
            (int) $depositObject->getJournalId(),
            $depositObject->getObjectType(),
            (int) $depositObject->getObjectId(),
            (int) $depositObject->getDepositId(),
            (int) $depositObject->getId()
         )
      );
   }
 
   public function deleteObject($depositObject) {
      $this->update(
         'DELETE from pln_deposit_objects WHERE deposit_object_id = ?',
         (int) $depositObject->getId()
      );
   }
 
   public function getInsertId() {
      return $this->_getInsertId('pln_deposit_objects', 'object_id');
   }
 
   public function newDataObject() {
      return new DepositObject();
   }
 
   public function _fromRow($row) {
      $depositObject = $this->newDataObject();
      $depositObject->setId($row['deposit_object_id']);
      $depositObject->setJournalId($row['journal_id']);
      $depositObject->setObjectType($row['object_type']);
      $depositObject->setObjectId($row['object_id']);
      $depositObject->setDepositId($row['deposit_id']);
      $depositObject->setDateCreated($this->datetimeFromDB($row['date_created']));
      $depositObject->setDateModified($this->datetimeFromDB($row['date_modified']));
 
      HookRegistry::call('DepositObjectDAO::_fromRow', array(&$depositObject, &$row));
 
      return $depositObject;
   }
}