classes/submission/sectionEditor/SectionEditorSubmission.inc.php

<?php

// $Id: SectionEditorSubmission.inc.php,v 1.41 2008/07/01 01:16:11 asmecher Exp $


import('article.Article');

class SectionEditorSubmission extends Article {

   var $reviewAssignments;

   var $removedReviewAssignments;

   var $editorDecisions;

   var $editorFileRevisions;

   var $authorFileRevisions;

   var $copyeditFileRevisions;

   function SectionEditorSubmission() {
      parent::Article();
      $this->reviewAssignments = array();
      $this->removedReviewAssignments = array();
   }

   function addReviewAssignment($reviewAssignment) {
      if ($reviewAssignment->getArticleId() == null) {
         $reviewAssignment->setArticleId($this->getArticleId());
      }

      if (isset($this->reviewAssignments[$reviewAssignment->getRound()])) {
         $roundReviewAssignments = $this->reviewAssignments[$reviewAssignment->getRound()];
      } else {
         $roundReviewAssignments = Array();
      }
      array_push($roundReviewAssignments, $reviewAssignment);

      return $this->reviewAssignments[$reviewAssignment->getRound()] = $roundReviewAssignments;
   }

   function addDecision($editorDecision, $round) {
      if (isset($this->editorDecisions[$round]) && is_array($this->editorDecisions[$round])) {
         array_push($this->editorDecisions[$round], $editorDecision);
      }
      else $this->editorDecisions[$round] = Array($editorDecision);
   }

   function removeReviewAssignment($reviewId) {
      $found = false;

      if ($reviewId != 0) {
         // FIXME maintain a hash of ID to author for quicker get/remove
         $reviewAssignments = array();
         $empty = array();
         for ($i=1, $outerCount=count($this->reviewAssignments); $i <= $outerCount; $i++) {
            $roundReviewAssignments = $this->reviewAssignments[$i];
            for ($j=0, $innerCount=count($roundReviewAssignments); $j < $innerCount; $j++) {
               if ($roundReviewAssignments[$j]->getReviewId() == $reviewId) {
                  array_push($this->removedReviewAssignments, $reviewId);
                  $found = true;
               } else {
                  array_push($reviewAssignments, $roundReviewAssignments[$j]);
               }
            }
            $this->reviewAssignments[$i] = $reviewAssignments;
            $reviewAssignments = $empty;
         }
      }
      return $found;
   }

   function updateReviewAssignment($reviewAssignment) {
      $reviewAssignments = array();
      $roundReviewAssignments = $this->reviewAssignments[$reviewAssignment->getRound()];
      for ($i=0, $count=count($roundReviewAssignments); $i < $count; $i++) {
         if ($roundReviewAssignments[$i]->getReviewId() == $reviewAssignment->getReviewId()) {
            array_push($reviewAssignments, $reviewAssignment);
         } else {
            array_push($reviewAssignments, $roundReviewAssignments[$i]);
         }
      }
      $this->reviewAssignments[$reviewAssignment->getRound()] = $reviewAssignments;
   }

   function getSubmissionStatus() {
      $status = $this->getStatus();
      if ($status == STATUS_ARCHIVED || $status == STATUS_PUBLISHED ||
          $status == STATUS_DECLINED) return $status;

      // The submission is STATUS_QUEUED or the author's submission was STATUS_INCOMPLETE.
      if ($this->getSubmissionProgress()) return (STATUS_INCOMPLETE);

      // The submission is STATUS_QUEUED. Find out where it's queued.
      $editAssignments = $this->getEditAssignments();
      if (empty($editAssignments))
         return (STATUS_QUEUED_UNASSIGNED);

      $decisions = $this->getDecisions();
      $decision = array_pop($decisions);
      if (!empty($decision)) {
         $latestDecision = array_pop($decision);
         if ($latestDecision['decision'] == SUBMISSION_EDITOR_DECISION_ACCEPT) {
            return STATUS_QUEUED_EDITING;
         }
      }
      return STATUS_QUEUED_REVIEW;
   }

   function &getEditAssignments() {
      $editAssignments = &$this->getData('editAssignments');
      return $editAssignments;
   }

   function setEditAssignments($editAssignments) {
      return $this->setData('editAssignments', $editAssignments);
   }

   //
   // Review Assignments
   //

   function &getReviewAssignments($round = null) {
      if ($round == null) {
         return $this->reviewAssignments;
      } else {
         return $this->reviewAssignments[$round];
      }
   }

   function setReviewAssignments($reviewAssignments, $round) {
      return $this->reviewAssignments[$round] = $reviewAssignments;
   }

   function &getRemovedReviewAssignments() {
      return $this->removedReviewAssignments;
   }

   //
   // Editor Decisions
   //

   function getDecisions($round = null) {
      if ($round == null) {
         return $this->editorDecisions;
      } else {
         if (isset($this->editorDecisions[$round])) return $this->editorDecisions[$round];
         else return null;
      }
   }

   function setDecisions($editorDecisions, $round) {
      return $this->editorDecisions[$round] = $editorDecisions;
   }

   // 
   // Files
   // 

   function &getSubmissionFile() {
      $returner =& $this->getData('submissionFile');
      return $returner;
   }

   function setSubmissionFile($submissionFile) {
      return $this->setData('submissionFile', $submissionFile);
   }

   function &getRevisedFile() {
      $returner =& $this->getData('revisedFile');
      return $returner;
   }

   function setRevisedFile($revisedFile) {
      return $this->setData('revisedFile', $revisedFile);
   }

   function &getSuppFiles() {
      $returner =& $this->getData('suppFiles');
      return $returner;
   }

   function setSuppFiles($suppFiles) {
      return $this->setData('suppFiles', $suppFiles);
   }

   function &getReviewFile() {
      $returner =& $this->getData('reviewFile');
      return $returner;
   }

   function setReviewFile($reviewFile) {
      return $this->setData('reviewFile', $reviewFile);
   }

   function getCopyeditFileRevisions() {
      return $this->copyeditFileRevisions;
   }

   function setCopyeditFileRevisions($copyeditFileRevisions) {
      return $this->copyeditFileRevisions = $copyeditFileRevisions;
   }

   function getEditorFileRevisions($round = null) {
      if ($round == null) {
         return $this->editorFileRevisions;
      } else {
         return $this->editorFileRevisions[$round];
      }
   }

   function setEditorFileRevisions($editorFileRevisions, $round) {
      return $this->editorFileRevisions[$round] = $editorFileRevisions;
   }

   function getAuthorFileRevisions($round = null) {
      if ($round == null) {
         return $this->authorFileRevisions;
      } else {
         return $this->authorFileRevisions[$round];
      }
   }

   function setAuthorFileRevisions($authorFileRevisions, $round) {
      return $this->authorFileRevisions[$round] = $authorFileRevisions;
   }

   function &getEditorFile() {
      $returner =& $this->getData('editorFile');
      return $returner;
   }

   function setEditorFile($editorFile) {
      return $this->setData('editorFile', $editorFile);
   }

   function &getCopyeditFile() {
      $returner =& $this->getData('copyeditFile');
      return $returner;
   }


   function setCopyeditFile($copyeditFile) {
      return $this->setData('copyeditFile', $copyeditFile);
   }

   function &getInitialCopyeditFile() {
      $returner =& $this->getData('initialCopyeditFile');
      return $returner;
   }


   function setInitialCopyeditFile($initialCopyeditFile) {
      return $this->setData('initialCopyeditFile', $initialCopyeditFile);
   }

   function &getEditorAuthorCopyeditFile() {
      $returner =& $this->getData('editorAuthorCopyeditFile');
      return $returner;
   }


   function setEditorAuthorCopyeditFile($editorAuthorCopyeditFile) {
      return $this->setData('editorAuthorCopyeditFile', $editorAuthorCopyeditFile);
   }

   function &getFinalCopyeditFile() {
      $returner =& $this->getData('finalCopyeditFile');
      return $returner;
   }


   function setFinalCopyeditFile($finalCopyeditFile) {
      return $this->setData('finalCopyeditFile', $finalCopyeditFile);
   }


   //
   // Review Rounds
   //

   function getReviewRevision() {
      return $this->getData('reviewRevision');
   }

   function setReviewRevision($reviewRevision) {
      return $this->setData('reviewRevision', $reviewRevision);
   }

   //
   // Comments
   //

   function getMostRecentEditorDecisionComment() {
      return $this->getData('mostRecentEditorDecisionComment');
   }

   function setMostRecentEditorDecisionComment($mostRecentEditorDecisionComment) {
      return $this->setData('mostRecentEditorDecisionComment', $mostRecentEditorDecisionComment);
   }

   function getMostRecentCopyeditComment() {
      return $this->getData('mostRecentCopyeditComment');
   }

   function setMostRecentCopyeditComment($mostRecentCopyeditComment) {
      return $this->setData('mostRecentCopyeditComment', $mostRecentCopyeditComment);
   }

   function getMostRecentLayoutComment() {
      return $this->getData('mostRecentLayoutComment');
   }

   function setMostRecentLayoutComment($mostRecentLayoutComment) {
      return $this->setData('mostRecentLayoutComment', $mostRecentLayoutComment);
   }

   function getMostRecentProofreadComment() {
      return $this->getData('mostRecentProofreadComment');
   }

   function setMostRecentProofreadComment($mostRecentProofreadComment) {
      return $this->setData('mostRecentProofreadComment', $mostRecentProofreadComment);
   }

   //
   // Copyeditor Assignment
   //

   function getCopyedId() {
      return $this->getData('copyedId');
   }

   function setCopyedId($copyedId) {
      return $this->setData('copyedId', $copyedId);
   }

   function getCopyeditorId() {
      return $this->getData('copyeditorId');
   }

   function setCopyeditorId($copyeditorId) {
      return $this->setData('copyeditorId', $copyeditorId);
   }

   function &getCopyeditor() {
      $copyEditor = &$this->getData('copyeditor');
      return $copyEditor;
   }

   function setCopyeditor($copyeditor) {
      return $this->setData('copyeditor', $copyeditor);
   }

   function getCopyeditorDateNotified() {
      return $this->getData('copyeditorDateNotified');
   }

   function setCopyeditorDateNotified($copyeditorDateNotified) {
      return $this->setData('copyeditorDateNotified', $copyeditorDateNotified);
   }

   function getCopyeditorDateUnderway() {
      return $this->getData('copyeditorDateUnderway');
   }

   function setCopyeditorDateUnderway($copyeditorDateUnderway) {
      return $this->setData('copyeditorDateUnderway', $copyeditorDateUnderway);
   }

   function getCopyeditorDateCompleted() {
      return $this->getData('copyeditorDateCompleted');
   }

   function setCopyeditorDateCompleted($copyeditorDateCompleted) {
      return $this->setData('copyeditorDateCompleted', $copyeditorDateCompleted);
   }

   function getCopyeditorDateAcknowledged() {
      return $this->getData('copyeditorDateAcknowledged');
   }

   function setCopyeditorDateAcknowledged($copyeditorDateAcknowledged) {
      return $this->setData('copyeditorDateAcknowledged', $copyeditorDateAcknowledged);
   }

   function getCopyeditorDateAuthorNotified() {
      return $this->getData('copyeditorDateAuthorNotified');
   }

   function setCopyeditorDateAuthorNotified($copyeditorDateAuthorNotified) {
      return $this->setData('copyeditorDateAuthorNotified', $copyeditorDateAuthorNotified);
   }

   function getCopyeditorDateAuthorUnderway() {
      return $this->getData('copyeditorDateAuthorUnderway');
   }

   function setCopyeditorDateAuthorUnderway($copyeditorDateAuthorUnderway) {
      return $this->setData('copyeditorDateAuthorUnderway', $copyeditorDateAuthorUnderway);
   }  

   function getCopyeditorDateAuthorCompleted() {
      return $this->getData('copyeditorDateAuthorCompleted');
   }

   function setCopyeditorDateAuthorCompleted($copyeditorDateAuthorCompleted) {
      return $this->setData('copyeditorDateAuthorCompleted', $copyeditorDateAuthorCompleted);
   }

   function getCopyeditorDateAuthorAcknowledged() {
      return $this->getData('copyeditorDateAuthorAcknowledged');
   }

   function setCopyeditorDateAuthorAcknowledged($copyeditorDateAuthorAcknowledged) {
      return $this->setData('copyeditorDateAuthorAcknowledged', $copyeditorDateAuthorAcknowledged);
   }

   function getCopyeditorDateFinalNotified() {
      return $this->getData('copyeditorDateFinalNotified');
   }

   function setCopyeditorDateFinalNotified($copyeditorDateFinalNotified) {
      return $this->setData('copyeditorDateFinalNotified', $copyeditorDateFinalNotified);
   }

   function getCopyeditorDateFinalUnderway() {
      return $this->getData('copyeditorDateFinalUnderway');
   }

   function setCopyeditorDateFinalUnderway($copyeditorDateFinalUnderway) {
      return $this->setData('copyeditorDateFinalUnderway', $copyeditorDateFinalUnderway);
   }

   function getCopyeditorDateFinalCompleted() {
      return $this->getData('copyeditorDateFinalCompleted');
   }

   function setCopyeditorDateFinalCompleted($copyeditorDateFinalCompleted) {
      return $this->setData('copyeditorDateFinalCompleted', $copyeditorDateFinalCompleted);
   }

   function getCopyeditorDateFinalAcknowledged() {
      return $this->getData('copyeditorDateFinalAcknowledged');
   }

   function setCopyeditorDateFinalAcknowledged($copyeditorDateFinalAcknowledged) {
      return $this->setData('copyeditorDateFinalAcknowledged', $copyeditorDateFinalAcknowledged);
   }

   function getCopyeditorInitialRevision() {
      return $this->getData('copyeditorInitialRevision');
   }

   function setCopyeditorInitialRevision($copyeditorInitialRevision) {
      return $this->setData('copyeditorInitialRevision', $copyeditorInitialRevision);
   }

   function getCopyeditorEditorAuthorRevision() {
      return $this->getData('copyeditorEditorAuthorRevision');
   }

   function setCopyeditorEditorAuthorRevision($copyeditorEditorAuthorRevision)   {
      return $this->setData('copyeditorEditorAuthorRevision', $copyeditorEditorAuthorRevision);
   }

   function getCopyeditorFinalRevision() {
      return $this->getData('copyeditorFinalRevision');
   }

   function setCopyeditorFinalRevision($copyeditorFinalRevision)  {
      return $this->setData('copyeditorFinalRevision', $copyeditorFinalRevision);
   }

   function &getLayoutAssignment() {
      $layoutAssignment = &$this->getData('layoutAssignment');
      return $layoutAssignment;
   }

   function setLayoutAssignment(&$layoutAssignment) {
      return $this->setData('layoutAssignment', $layoutAssignment);
   }

   function &getGalleys() {
      $galleys = &$this->getData('galleys');
      return $galleys;
   }

   function setGalleys(&$galleys) {
      return $this->setData('galleys', $galleys);
   }

   function &getProofAssignment() {
      $proofAssignment = &$this->getData('proofAssignment');
      return $proofAssignment;
   }

   function setProofAssignment($proofAssignment) {
      return $this->setData('proofAssignment', $proofAssignment);
   }

   function &getEditorDecisionOptions() {
      static $editorDecisionOptions = array(
         '' => 'common.chooseOne',
         SUBMISSION_EDITOR_DECISION_ACCEPT => 'editor.article.decision.accept',
         SUBMISSION_EDITOR_DECISION_PENDING_REVISIONS => 'editor.article.decision.pendingRevisions',
         SUBMISSION_EDITOR_DECISION_RESUBMIT => 'editor.article.decision.resubmit',
         SUBMISSION_EDITOR_DECISION_DECLINE => 'editor.article.decision.decline'
      );
      return $editorDecisionOptions;
   }

   function getHighlightClass() {
      $highlightClass = 'highlight';
      $overdueSeconds = 60 * 60 * 24 * 14; // Two weeks

      // Submissions that are not still queued (i.e. published) are not highlighted.
      if ($this->getStatus() != STATUS_QUEUED) return null;

      // Awaiting assignment.
      $editAssignments = $this->getEditAssignments();
      if (empty($editAssignments)) return $highlightClass;

      $journal =& Request::getJournal();
      // Sanity check
      if (!$journal || $journal->getJournalId() != $this->getJournalId()) return null;

      // Check whether it's in review or editing.
      $inEditing = false;
      $decisionsEmpty = true;
      $lastDecisionDate = null;
      $decisions = $this->getDecisions();
      $decision = array_pop($decisions);
      if (!empty($decision)) {
         $latestDecision = array_pop($decision);
         if (is_array($latestDecision)) {
            if ($latestDecision['decision'] == SUBMISSION_EDITOR_DECISION_ACCEPT) $inEditing = true;
            $decisionsEmpty = false;
            $lastDecisionDate = strtotime($latestDecision['dateDecided']);
         }
      }

      if ($inEditing) {
         // ---
         // --- Highlighting conditions for submissions in editing
         // ---

         // COPYEDITING

         // First round of copyediting
         $dateCopyeditorNotified = $this->getCopyeditorDateNotified() ?
            strtotime($this->getCopyeditorDateNotified()) : 0;
         $dateCopyeditorUnderway = $this->getCopyeditorDateUnderway() ?
            strtotime($this->getCopyeditorDateUnderway()) : 0;
         $dateCopyeditorCompleted = $this->getCopyeditorDateCompleted() ?
            strtotime($this->getCopyeditorDateCompleted()) : 0;
         $dateCopyeditorAcknowledged = $this->getCopyeditorDateAcknowledged() ?
            strtotime($this->getCopyeditorDateAcknowledged()) : 0;
         $dateLastCopyeditor = max($dateCopyeditorNotified, $dateCopyeditorUnderway);

         // If the Copyeditor has not been notified, highlight.
         if (!$dateCopyeditorNotified) return $highlightClass;

         // Check if the copyeditor is overdue on round 1
         if (  $dateLastCopyeditor &&
            !$dateCopyeditorCompleted &&
            $dateLastCopyeditor + $overdueSeconds < time()
         ) return $highlightClass;

         // Check if acknowledgement is overdue for CE round 1
         if ($dateCopyeditorCompleted && !$dateCopyeditorAcknowledged) return $highlightClass;

         // Second round of copyediting
         $dateCopyeditorAuthorNotified = $this->getCopyeditorDateAuthorNotified() ?
            strtotime($this->getCopyeditorDateAuthorNotified()) : 0;
         $dateCopyeditorAuthorUnderway = $this->getCopyeditorDateAuthorUnderway() ?
            strtotime($this->getCopyeditorDateAuthorUnderway()) : 0;
         $dateCopyeditorAuthorCompleted = $this->getCopyeditorDateAuthorCompleted() ?
            strtotime($this->getCopyeditorDateAuthorCompleted()) : 0;
         $dateCopyeditorAuthorAcknowledged = $this->getCopyeditorDateAuthorAcknowledged() ?
            strtotime($this->getCopyeditorDateAuthorAcknowledged()) : 0;
         $dateLastCopyeditorAuthor = max($dateCopyeditorAuthorNotified, $dateCopyeditorAuthorUnderway);

         // Check if round 2 is awaiting notification.
         if ($dateCopyeditorAcknowledged && !$dateCopyeditorAuthorNotified) return $highlightClass;

         // Check if acknowledgement is overdue for CE round 2
         if ($dateCopyeditorAuthorCompleted && !$dateCopyeditorAuthorAcknowledged) return $highlightClass;

         // Check if author is overdue on CE round 2
         if (  $dateLastCopyeditorAuthor &&
            !$dateCopyeditorAuthorCompleted &&
            $dateLastCopyeditorAuthor + $overdueSeconds < time()
         ) return $highlightClass;

         // Third round of copyediting
         $dateCopyeditorFinalNotified = $this->getCopyeditorDateFinalNotified() ?
            strtotime($this->getCopyeditorDateFinalNotified()) : 0;
         $dateCopyeditorFinalUnderway = $this->getCopyeditorDateFinalUnderway() ?
            strtotime($this->getCopyeditorDateFinalUnderway()) : 0;
         $dateCopyeditorFinalCompleted = $this->getCopyeditorDateFinalCompleted() ?
            strtotime($this->getCopyeditorDateFinalCompleted()) : 0;
         $dateLastCopyeditorFinal = max($dateCopyeditorFinalNotified, $dateCopyeditorUnderway);

         // Check if round 3 is awaiting notification.
         if ($dateCopyeditorAuthorAcknowledged && !$dateCopyeditorFinalNotified) return $highlightClass;

         // Check if copyeditor is overdue on round 3
         if (  $dateLastCopyeditorFinal &&
            !$dateCopyeditorFinalCompleted &&
            $dateLastCopyeditorFinal + $overdueSeconds < time()
         ) return $highlightClass;

         // Check if acknowledgement is overdue for CE round 3
         if ($dateCopyeditorFinalCompleted && !$dateCopyeditorFinalAcknowledged) return $highlightClass;

         // LAYOUT EDITING
         $layoutAssignment =& $this->getLayoutAssignment();

         $dateLayoutNotified = $layoutAssignment->getDateNotified() ?
            strtotime($layoutAssignment->getDateNotified()) : 0;
         $dateLayoutUnderway = $layoutAssignment->getDateUnderway() ?
            strtotime($layoutAssignment->getDateUnderway()) : 0;
         $dateLayoutCompleted = $layoutAssignment->getDateCompleted() ?
            strtotime($layoutAssignment->getDateCompleted()) : 0;
         $dateLayoutAcknowledged = $layoutAssignment->getDateAcknowledged() ?
            strtotime($layoutAssignment->getDateAcknowledged()) : 0;
         $dateLastLayout = max($dateLayoutNotified, $dateLayoutUnderway);

         // Check if Layout Editor needs to be notified.
         if ($dateLastCopyeditorFinal && !$dateLayoutNotified) return $highlightClass;

         // Check if layout editor is overdue
         if (  $dateLastLayout &&
            !$dateLayoutCompleted &&
            $dateLastLayout + $overdueSeconds < time()
         ) return $highlightClass;

         // Check if acknowledgement is overdue for layout
         if ($dateLayoutCompleted && !$dateLayoutAcknowledged) return $highlightClass;

         // PROOFREADING
         $proofAssignment =& $this->getProofAssignment();

         // First round of proofreading
         $dateAuthorNotified = $proofAssignment->getDateAuthorNotified() ?
            strtotime($proofAssignment->getDateAuthorNotified()) : 0;
         $dateAuthorUnderway = $proofAssignment->getDateAuthorUnderway() ?
            strtotime($proofAssignment->getDateAuthorUnderway()) : 0;
         $dateAuthorCompleted = $proofAssignment->getDateAuthorCompleted() ?
            strtotime($proofAssignment->getDateAuthorCompleted()) : 0;
         $dateAuthorAcknowledged = $proofAssignment->getDateAuthorAcknowledged() ?
            strtotime($proofAssignment->getDateAuthorAcknowledged()) : 0;
         $dateLastAuthor = max($dateAuthorNotified, $dateAuthorUnderway);

         // Check if the author is awaiting proofreading notification.
         if ($dateLayoutAcknowledged && !$dateAuthorNotified) return $highlightClass;

         // Check if the author is overdue on round 1 of proofreading
         if (  $dateLastAuthor &&
            !$dateAuthorCompleted &&
            $dateLastAuthor + $overdueSeconds < time()
         ) return $highlightClass;

         // Check if acknowledgement is overdue for proofreading round 1
         if ($dateAuthorCompleted && !$dateAuthorAcknowledged) return $highlightClass;

         // Second round of proofreading
         $dateProofreaderNotified = $proofAssignment->getDateProofreaderNotified() ?
            strtotime($proofAssignment->getDateProofreaderNotified()) : 0;
         $dateProofreaderUnderway = $proofAssignment->getDateProofreaderUnderway() ?
            strtotime($proofAssignment->getDateProofreaderUnderway()) : 0;
         $dateProofreaderCompleted = $proofAssignment->getDateProofreaderCompleted() ?
            strtotime($proofAssignment->getDateProofreaderCompleted()) : 0;
         $dateProofreaderAcknowledged = $proofAssignment->getDateProofreaderAcknowledged() ?
            strtotime($proofAssignment->getDateProofreaderAcknowledged()) : 0;
         $dateLastProofreader = max($dateProofreaderNotified, $dateProofreaderUnderway);

         // Check if the proofreader is awaiting notification.
         if ($dateAuthorAcknowledged && !$dateProofreaderNotified) return $highlightClass;

         // Check if acknowledgement is overdue for proofreading round 2
         if ($dateProofreaderCompleted && !$dateProofreaderAcknowledged) return $highlightClass;

         // Check if proofreader is overdue on proofreading round 2
         if (  $dateLastProofreader &&
            !$dateProofreaderCompleted &&
            $dateLastProofreader + $overdueSeconds < time()
         ) return $highlightClass;

         // Third round of proofreading
         $dateLayoutEditorNotified = $proofAssignment->getDateLayoutEditorNotified() ?
            strtotime($proofAssignment->getDateLayoutEditorNotified()) : 0;
         $dateLayoutEditorUnderway = $proofAssignment->getDateLayoutEditorUnderway() ?
            strtotime($proofAssignment->getDateLayoutEditorUnderway()) : 0;
         $dateLayoutEditorCompleted = $proofAssignment->getDateLayoutEditorCompleted() ?
            strtotime($proofAssignment->getDateLayoutEditorCompleted()) : 0;
         $dateLastLayoutEditor = max($dateLayoutEditorNotified, $dateCopyeditorUnderway);

         // Check if the layout editor is awaiting notification.
         if ($dateProofreaderAcknowledged && !$dateLayoutEditorNotified) return $highlightClass;

         // Check if proofreader is overdue on round 3 of proofreading
         if (  $dateLastLayoutEditor &&
            !$dateLayoutEditorCompleted &&
            $dateLastLayoutEditor + $overdueSeconds < time()
         ) return $highlightClass;

         // Check if acknowledgement is overdue for proofreading round 3
         if ($dateLayoutEditorCompleted && !$dateLayoutEditorAcknowledged) return $highlightClass;
      } else {
         // ---
         // --- Highlighting conditions for submissions in review
         // ---
         $reviewAssignments =& $this->getReviewAssignments($this->getCurrentRound());
         if (is_array($reviewAssignments) && !empty($reviewAssignments)) {
            $allReviewsComplete = true;
            foreach ($reviewAssignments as $i => $junk) {
               $reviewAssignment =& $reviewAssignments[$i];

               // If the reviewer has not been notified, highlight.
               if ($reviewAssignment->getDateNotified() === null) return $highlightClass;

               // Check review status.
               if (!$reviewAssignment->getCancelled() && !$reviewAssignment->getDeclined()) {
                  if (!$reviewAssignment->getDateCompleted()) $allReviewsComplete = false;

                  $dateReminded = $reviewAssignment->getDateReminded() ?
                     strtotime($reviewAssignment->getDateReminded()) : 0;
                  $dateNotified = $reviewAssignment->getDateNotified() ?
                     strtotime($reviewAssignment->getDateNotified()) : 0;
                  $dateConfirmed = $reviewAssignment->getDateConfirmed() ?
                     strtotime($reviewAssignment->getDateConfirmed()) : 0;

                  // Check whether a reviewer is overdue to confirm invitation
                  if (  !$reviewAssignment->getDateCompleted() &&
                     !$dateConfirmed &&
                     !$journal->getSetting('remindForInvite') &&
                     max($dateReminded, $dateNotified) + $overdueSeconds < time()
                  ) return $highlightClass;

                  // Check whether a reviewer is overdue to complete review
                  if (  !$reviewAssignment->getDateCompleted() &&
                     $dateConfirmed &&
                     !$journal->getSetting('remindForSubmit') &&
                     max($dateReminded, $dateConfirmed) + $overdueSeconds < time()
                  ) return $highlightClass;
               }

               unset($reviewAssignment);
            }
            // If all reviews are complete but no decision is recorded, highlight.
            if ($allReviewsComplete && $decisionsEmpty) return $highlightClass;

            // If the author's last file upload hasn't been taken into account in
            // the most recent decision or author/editor correspondence, highlight.
            $comment = $this->getMostRecentEditorDecisionComment();
            $commentDate = $comment ? strtotime($comment->getDatePosted()) : 0;
            $authorFileRevisions = $this->getAuthorFileRevisions($this->getCurrentRound());
            $authorFileDate = null;
            if (is_array($authorFileRevisions) && !empty($authorFileRevisions)) {
               $authorFile = array_pop($authorFileRevisions);
               $authorFileDate = strtotime($authorFile->getDateUploaded());
            }
            if (  ($lastDecisionDate || $commentDate) &&
               $authorFileDate &&
               $authorFileDate > max($lastDecisionDate, $commentDate)
            ) return $highlightClass;
         }
      }
      return null;
   }
}

?>

---