classes/submission/trackDirector/TrackDirectorAction.inc.php

Go to the documentation of this file.

<?php

import('submission.common.Action');

class TrackDirectorAction extends Action {

   function TrackDirectorAction() {
      parent::Action();
   }

   function changeTrack(&$trackDirectorSubmission, $trackId) {
      if (!HookRegistry::call('TrackDirectorAction::changeTrack', array(&$trackDirectorSubmission, $trackId))) {
         $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
         $trackDirectorSubmission->setTrackId((int) $trackId);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
      }
   }

   function changeSessionType(&$trackDirectorSubmission, $sessionType) {
      if (!HookRegistry::call('TrackDirectorAction::changeSessionType', array(&$trackDirectorSubmission, $sessionType))) {
         $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
         $trackDirectorSubmission->setData('sessionType', (int) $sessionType);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
      }
   }

   function recordDecision($trackDirectorSubmission, $decision, $stage) {
      $editAssignments =& $trackDirectorSubmission->getEditAssignments();
      if (empty($editAssignments)) return;

      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $user =& Request::getUser();
      $directorDecision = array(
         'editDecisionId' => null,
         'directorId' => $user->getId(),
         'decision' => $decision,
         'dateDecided' => date(Core::getCurrentDate())
      );

      if (!HookRegistry::call('TrackDirectorAction::recordDecision', array(&$trackDirectorSubmission, $directorDecision))) {
         if ($decision == SUBMISSION_DIRECTOR_DECISION_DECLINE) {
            $trackDirectorSubmission->setStatus(STATUS_DECLINED);
            $trackDirectorSubmission->stampStatusModified();
         } else {
            $trackDirectorSubmission->setStatus(STATUS_QUEUED);      
            $trackDirectorSubmission->stampStatusModified();
         }

         $trackDirectorSubmission->addDecision($directorDecision, $stage);
         $decisions = TrackDirectorSubmission::getDirectorDecisionOptions();
         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');
         AppLocale::requireComponents(array(LOCALE_COMPONENT_APPLICATION_COMMON, LOCALE_COMPONENT_OCS_DIRECTOR));
         PaperLog::logEvent(
            $trackDirectorSubmission->getPaperId(),
            PAPER_LOG_DIRECTOR_DECISION,
            LOG_TYPE_DIRECTOR,
            $user->getId(),
            'log.director.decision',
            array(
               'directorName' => $user->getFullName(),
               'paperId' => $trackDirectorSubmission->getPaperId(),
               'decision' => __($decisions[$decision]),
               'round' => ($stage == REVIEW_STAGE_ABSTRACT?'submission.abstractReview':'submission.paperReview')
            )
         );
      }

      if($decision == SUBMISSION_DIRECTOR_DECISION_ACCEPT || $decision == SUBMISSION_DIRECTOR_DECISION_INVITE) {
         // completeReview will take care of updating the
         // submission with the new decision.
         TrackDirectorAction::completeReview($trackDirectorSubmission);
      } else {
         // Insert the new decision.
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
      }
   }

   function completeReview($trackDirectorSubmission) {
      $schedConf =& Request::getSchedConf();

      if($trackDirectorSubmission->getReviewMode() == REVIEW_MODE_BOTH_SEQUENTIAL) {
         // two-stage submission; paper required
         // The submission is incomplete, and needs the author to submit
         // more materials (potentially for another stage of reviews)

         if($trackDirectorSubmission->getCurrentStage() == REVIEW_STAGE_ABSTRACT) {

            // We've just completed reviewing the abstract. Prepare for presentation
            // review process.
            $trackDirectorSubmission->setCurrentStage(REVIEW_STAGE_PRESENTATION);

            // The paper itself needs to be collected. Flag it so the author
            // may complete it.
            $trackDirectorSubmission->setSubmissionProgress(2);

            // TODO: notify the author the submission must be completed.
            // Q: should the director be given this option explicitly?

            // Now, reassign all reviewers that submitted a review for the last
            // stage of reviews.
            foreach ($trackDirectorSubmission->getReviewAssignments(REVIEW_STAGE_ABSTRACT) as $reviewAssignment) {
               if ($reviewAssignment->getRecommendation() !== null && $reviewAssignment->getRecommendation() !== '') {
                  // This reviewer submitted a review; reassign them
                  TrackDirectorAction::addReviewer($trackDirectorSubmission, $reviewAssignment->getReviewerId(), REVIEW_STAGE_PRESENTATION);
               }
            }
         }
      }

      $trackDirectorSubmissionDao =& DAORegistry::getDao('TrackDirectorSubmissionDAO');
      $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
      $trackDirectorSubmission->stampStatusModified();

      // Commit the paper changes
      $paperDao =& DAORegistry::getDao('PaperDAO');
      $paperDao->updatePaper($trackDirectorSubmission);
   }

   function addReviewer($trackDirectorSubmission, $reviewerId, $stage) {
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $user =& Request::getUser();

      $reviewer =& $userDao->getUser($reviewerId);

      // Check to see if the requested reviewer is not already
      // assigned to review this paper.
      if ($stage == null) {
         $stage = $trackDirectorSubmission->getCurrentStage();
      }

      $assigned = $trackDirectorSubmissionDao->reviewerExists($trackDirectorSubmission->getPaperId(), $reviewerId, $stage);

      // Only add the reviewer if he has not already
      // been assigned to review this paper.
      if (!$assigned && isset($reviewer) && !HookRegistry::call('TrackDirectorAction::addReviewer', array(&$trackDirectorSubmission, $reviewerId))) {
         $reviewAssignment = new ReviewAssignment();
         $reviewAssignment->setReviewerId($reviewerId);
         $reviewAssignment->setDateAssigned(Core::getCurrentDate());
         $reviewAssignment->setStage($stage);

         // Assign review form automatically if needed
         $schedConfId = $trackDirectorSubmission->getSchedConfId();
         $schedConfDao =& DAORegistry::getDAO('SchedConfDAO');
         $schedConf =& $schedConfDao->getSchedConf($schedConfId);
         $conferenceId = $schedConf->getConferenceId();
         $trackDao =& DAORegistry::getDAO('TrackDAO');
         $reviewFormDao =& DAORegistry::getDAO('ReviewFormDAO');

         $trackId = $trackDirectorSubmission->getTrackId();
         $track =& $trackDao->getTrack($trackId, $conferenceId);
         if ($track && ($reviewFormId = (int) $track->getReviewFormId())) {
            if ($reviewFormDao->reviewFormExists($reviewFormId, ASSOC_TYPE_CONFERENCE, $conferenceId)) {
               $reviewAssignment->setReviewFormId($reviewFormId);
            }
         }

         $trackDirectorSubmission->addReviewAssignment($reviewAssignment);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

         $reviewAssignment = $reviewAssignmentDao->getReviewAssignment($trackDirectorSubmission->getPaperId(), $reviewerId, $stage);

         $schedConf =& Request::getSchedConf();
         if ($schedConf->getSetting('reviewDeadlineType') != null) {
            $dueDateSet = true;
            if ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_ABSOLUTE) {
               $reviewDeadlineDate = $schedConf->getSetting('numWeeksPerReviewAbsolute');
               $reviewDueDate = strftime(Config::getVar('general', 'date_format_short'), $reviewDeadlineDate);
               TrackDirectorAction::setDueDate($trackDirectorSubmission->getPaperId(), $reviewAssignment->getId(), $reviewDueDate, null, false);
            } elseif ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_RELATIVE) {
               TrackDirectorAction::setDueDate($trackDirectorSubmission->getPaperId(), $reviewAssignment->getId(), null, $schedConf->getSetting('numWeeksPerReviewRelative'), false);
            } else {
               $dueDateSet = false;
            }
            if ($dueDateSet) {
               $reviewAssignment = $reviewAssignmentDao->getReviewAssignment($trackDirectorSubmission->getPaperId(), $reviewerId, $stage);
               $trackDirectorSubmission->updateReviewAssignment($reviewAssignment);
               $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
            }
         }

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');
         PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_REVIEW_ASSIGN, LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewerAssigned', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $trackDirectorSubmission->getPaperId(), 'stage' => $stage));
      }
   }

   function clearReview($trackDirectorSubmission, $reviewId) {
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);

      if (isset($reviewAssignment) && $reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId() && !HookRegistry::call('TrackDirectorAction::clearReview', array(&$trackDirectorSubmission, $reviewAssignment))) {
         $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
         if (!isset($reviewer)) return false;
         $trackDirectorSubmission->removeReviewAssignment($reviewId);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');
         PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_REVIEW_CLEAR, LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewCleared', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $trackDirectorSubmission->getPaperId(), 'stage' => $reviewAssignment->getStage()));
      }     
   }

   function notifyReviewer($trackDirectorSubmission, $reviewId, $send = false) {
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');

      $conference =& Request::getConference();
      $schedConf =& Request::getSchedConf();
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);

      $reviewerAccessKeysEnabled = $schedConf->getSetting('reviewerAccessKeysEnabled');

      // If we're using access keys, disable the address fields
      // for this message. (Prevents security issue: track director
      // could CC or BCC someone else, or change the reviewer address,
      // in order to get the access key.)
      $preventAddressChanges = $reviewerAccessKeysEnabled;

      import('mail.PaperMailTemplate');

      $email = new PaperMailTemplate($trackDirectorSubmission, $reviewerAccessKeysEnabled?'REVIEW_REQUEST_ONECLICK':'REVIEW_REQUEST');

      if ($preventAddressChanges) {
         $email->setAddressFieldsEnabled(false);
      }

      if ($reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId()) {
         $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
         if (!isset($reviewer)) return true;

         if (!$email->isEnabled() || ($send && !$email->hasErrors())) {
            HookRegistry::call('TrackDirectorAction::notifyReviewer', array(&$trackDirectorSubmission, &$reviewAssignment, &$email));
            if ($email->isEnabled()) {
               $email->setAssoc(PAPER_EMAIL_REVIEW_NOTIFY_REVIEWER, PAPER_EMAIL_TYPE_REVIEW, $reviewId);
               if ($reviewerAccessKeysEnabled) {
                  import('security.AccessKeyManager');
                  import('pages.reviewer.ReviewerHandler');
                  $accessKeyManager = new AccessKeyManager();

                  // Key lifetime is the typical review period plus four weeks
                  if ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_ABSOLUTE) {
                     // Get number of days from now until review deadline date
                     $reviewDeadlineDate = $schedConf->getSetting('numWeeksPerReviewAbsolute');
                     $daysDiff = ($reviewDeadlineDate - strtotime(date("Y-m-d"))) / (60 * 60 * 24);
                     $keyLifetime = (round($daysDiff / 7) + 4) * 7;
                  } elseif ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_RELATIVE) {
                     $keyLifetime = ((int) $schedConf->getSetting('numWeeksPerReviewRelative') + 4) * 7;
                  }

                  $email->addPrivateParam('ACCESS_KEY', $accessKeyManager->createKey('ReviewerContext', $reviewer->getId(), $reviewId, $keyLifetime));
               }

               if ($preventAddressChanges) {
                  // Ensure that this messages goes to the reviewer, and the reviewer ONLY.
                  $email->clearAllRecipients();
                  $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());
               }
               $email->send();
            }

            $reviewAssignment->setDateNotified(Core::getCurrentDate());
            $reviewAssignment->setCancelled(0);
            $reviewAssignment->stampModified();
            $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
            return true;
         } else {
            if (!Request::getUserVar('continued')) {
               $weekLaterDate = strftime(Config::getVar('general', 'date_format_short'), strtotime('+1 week'));

               if ($reviewAssignment->getDateDue() != null) {
                  $reviewDueDate = strftime(Config::getVar('general', 'date_format_short'), strtotime($reviewAssignment->getDateDue()));
               } else {
                  if ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_ABSOLUTE) {
                     $reviewDeadlineDate = $schedConf->getSetting('numWeeksPerReviewAbsolute');
                     $reviewDueDate = strftime(Config::getVar('general', 'date_format_short'), $reviewDeadlineDate);
                  } elseif ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_RELATIVE) {
                     $numWeeks = max((int) $schedConf->getSetting('numWeeksPerReviewRelative'), 2);
                     $reviewDueDate = strftime(Config::getVar('general', 'date_format_short'), strtotime('+' . $numWeeks . ' week'));
                  }
                  
               }

               $submissionUrl = Request::url(null, null, 'reviewer', 'submission', $reviewId, $reviewerAccessKeysEnabled?array('key' => 'ACCESS_KEY'):array());

               $paramArray = array(
                  'reviewerName' => $reviewer->getFullName(),
                  'weekLaterDate' => $weekLaterDate,
                  'reviewDueDate' => $reviewDueDate,
                  'reviewerUsername' => $reviewer->getUsername(),
                  'reviewerPassword' => $reviewer->getPassword(),
                  'editorialContactSignature' => $user->getContactSignature(),
                  'reviewGuidelines' => $schedConf->getLocalizedSetting('reviewGuidelines'),
                  'submissionReviewUrl' => $submissionUrl,
                  'passwordResetUrl' => Request::url(null, null, 'login', 'resetPassword', $reviewer->getUsername(), array('confirm' => Validation::generatePasswordResetHash($reviewer->getId())))
               );
               $email->assignParams($paramArray);
               $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());
            }
            $email->displayEditForm(Request::url(null, null, null, 'notifyReviewer'), array('reviewId' => $reviewId, 'paperId' => $trackDirectorSubmission->getPaperId()));
            return false;
         }
      }
      return true;
   }

   function cancelReview($trackDirectorSubmission, $reviewId, $send = false) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');

      $conference =& Request::getConference();
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
      if (!isset($reviewer)) return true;

      if ($reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId()) {
         // Only cancel the review if it is currently not cancelled but has previously
         // been initiated, and has not been completed.
         if ($reviewAssignment->getDateNotified() != null && !$reviewAssignment->getCancelled() && ($reviewAssignment->getDateCompleted() == null || $reviewAssignment->getDeclined())) {
            import('mail.PaperMailTemplate');
            $email = new PaperMailTemplate($trackDirectorSubmission, 'REVIEW_CANCEL');

            if (!$email->isEnabled() || ($send && !$email->hasErrors())) {
               HookRegistry::call('TrackDirectorAction::cancelReview', array(&$trackDirectorSubmission, &$reviewAssignment, &$email));
               if ($email->isEnabled()) {
                  $email->setAssoc(PAPER_EMAIL_REVIEW_CANCEL, PAPER_EMAIL_TYPE_REVIEW, $reviewId);
                  $email->send();
               }

               $reviewAssignment->setCancelled(1);
               $reviewAssignment->setDateCompleted(Core::getCurrentDate());
               $reviewAssignment->stampModified();

               $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);

               // Add log
               import('paper.log.PaperLog');
               import('paper.log.PaperEventLogEntry');
               PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_REVIEW_CANCEL, LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewCancelled', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $trackDirectorSubmission->getPaperId(), 'stage' => $reviewAssignment->getStage()));
            } else {
               if (!Request::getUserVar('continued')) {
                  $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());

                  $paramArray = array(
                     'reviewerName' => $reviewer->getFullName(),
                     'reviewerUsername' => $reviewer->getUsername(),
                     'reviewerPassword' => $reviewer->getPassword(),
                     'editorialContactSignature' => $user->getContactSignature()
                  );
                  $email->assignParams($paramArray);
               }
               $email->displayEditForm(Request::url(null, null, null, 'cancelReview', 'send'), array('reviewId' => $reviewId, 'paperId' => $trackDirectorSubmission->getPaperId()));
               return false;
            }
         }           
      }
      return true;
   }

   function remindReviewer($trackDirectorSubmission, $reviewId, $send = false) {
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');

      $conference =& Request::getConference();
      $schedConf =& Request::getSchedConf();
      $user =& Request::getUser();
      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $reviewerAccessKeysEnabled = $schedConf->getSetting('reviewerAccessKeysEnabled');

      // If we're using access keys, disable the address fields
      // for this message. (Prevents security issue: track director
      // could CC or BCC someone else, or change the reviewer address,
      // in order to get the access key.)
      $preventAddressChanges = $reviewerAccessKeysEnabled;

      import('mail.PaperMailTemplate');
      $email = new PaperMailTemplate($trackDirectorSubmission, $reviewerAccessKeysEnabled?'REVIEW_REMIND_ONECLICK':'REVIEW_REMIND');

      if ($preventAddressChanges) {
         $email->setAddressFieldsEnabled(false);
      }

      if ($send && !$email->hasErrors()) {
         HookRegistry::call('TrackDirectorAction::remindReviewer', array(&$trackDirectorSubmission, &$reviewAssignment, &$email));
         $email->setAssoc(PAPER_EMAIL_REVIEW_REMIND, PAPER_EMAIL_TYPE_REVIEW, $reviewId);

         $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());

         if ($reviewerAccessKeysEnabled) {
            import('security.AccessKeyManager');
            import('pages.reviewer.ReviewerHandler');
            $accessKeyManager = new AccessKeyManager();

            // Key lifetime is the typical review period plus four weeks
            if ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_ABSOLUTE) {
               // Get number of days from now until review deadline date
               $reviewDeadlineDate = $schedConf->getSetting('numWeeksPerReviewAbsolute');
               $daysDiff = ($reviewDeadlineDate - strtotime(date("Y-m-d"))) / (60 * 60 * 24);
               $keyLifetime = (round($daysDiff / 7) + 4) * 7;
            } elseif ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_RELATIVE) {
               $keyLifetime = ((int) $schedConf->getSetting('numWeeksPerReviewRelative') + 4) * 7;
            }
            $email->addPrivateParam('ACCESS_KEY', $accessKeyManager->createKey('ReviewerContext', $reviewer->getId(), $reviewId, $keyLifetime));
         }

         if ($preventAddressChanges) {
            // Ensure that this messages goes to the reviewer, and the reviewer ONLY.
            $email->clearAllRecipients();
            $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());
         }

         $email->send();

         $reviewAssignment->setDateReminded(Core::getCurrentDate());
         $reviewAssignment->setReminderWasAutomatic(0);
         $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
         return true;
      } elseif ($reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId()) {
         $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());

         if (!Request::getUserVar('continued')) {
            if (!isset($reviewer)) return true;
            $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());

            $submissionUrl = Request::url(null, null, 'reviewer', 'submission', $reviewId, $reviewerAccessKeysEnabled?array('key' => 'ACCESS_KEY'):array());

            // Format the review due date
            $reviewDueDate = strtotime($reviewAssignment->getDateDue());
            $dateFormatShort = Config::getVar('general', 'date_format_short');
            if ($reviewDueDate === -1 || $reviewDueDate === false) {
               // Use something human-readable if unspecified.
               $reviewDueDate = '_____';
            } else {
               $reviewDueDate = strftime($dateFormatShort, $reviewDueDate);
            }

            $paramArray = array(
               'reviewerName' => $reviewer->getFullName(),
               'reviewerUsername' => $reviewer->getUsername(),
               'reviewerPassword' => $reviewer->getPassword(),
               'reviewDueDate' => $reviewDueDate,
               'editorialContactSignature' => $user->getContactSignature(),
               'passwordResetUrl' => Request::url(null, null, 'login', 'resetPassword', $reviewer->getUsername(), array('confirm' => Validation::generatePasswordResetHash($reviewer->getId()))),
               'submissionReviewUrl' => $submissionUrl
            );
            $email->assignParams($paramArray);

         }
         $email->displayEditForm(
            Request::url(null, null, null, 'remindReviewer', 'send'),
            array(
               'reviewerId' => $reviewer->getId(),
               'paperId' => $trackDirectorSubmission->getPaperId(),
               'reviewId' => $reviewId
            )
         );
         return false;
      }
      return true;
   }

   function thankReviewer($trackDirectorSubmission, $reviewId, $send = false) {
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');

      $conference =& Request::getConference();
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);

      import('mail.PaperMailTemplate');
      $email = new PaperMailTemplate($trackDirectorSubmission, 'REVIEW_ACK');

      if ($reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId()) {
         $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
         if (!isset($reviewer)) return true;

         if (!$email->isEnabled() || ($send && !$email->hasErrors())) {
            HookRegistry::call('TrackDirectorAction::thankReviewer', array(&$trackDirectorSubmission, &$reviewAssignment, &$email));
            if ($email->isEnabled()) {
               $email->setAssoc(PAPER_EMAIL_REVIEW_THANK_REVIEWER, PAPER_EMAIL_TYPE_REVIEW, $reviewId);
               $email->send();
            }

            $reviewAssignment->setDateAcknowledged(Core::getCurrentDate());
            $reviewAssignment->stampModified();
            $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
         } else {
            if (!Request::getUserVar('continued')) {
               $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());

               $paramArray = array(
                  'reviewerName' => $reviewer->getFullName(),
                  'editorialContactSignature' => $user->getContactSignature()
               );
               $email->assignParams($paramArray);
            }
            $email->displayEditForm(Request::url(null, null, null, 'thankReviewer', 'send'), array('reviewId' => $reviewId, 'paperId' => $trackDirectorSubmission->getPaperId()));
            return false;
         }
      }
      return true;
   }

   function rateReviewer($paperId, $reviewId, $quality = null) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
      if (!isset($reviewer)) return false;

      if ($reviewAssignment->getPaperId() == $paperId && !HookRegistry::call('TrackDirectorAction::rateReviewer', array(&$reviewAssignment, &$reviewer, &$quality))) {
         // Ensure that the value for quality
         // is between 1 and 5.
         if ($quality != null && ($quality >= 1 && $quality <= 5)) {
            $reviewAssignment->setQuality($quality);
         }

         $reviewAssignment->setDateRated(Core::getCurrentDate());
         $reviewAssignment->stampModified();

         $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');
         PaperLog::logEvent($paperId, PAPER_LOG_REVIEW_RATE, LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewerRated', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $paperId, 'stage' => $reviewAssignment->getStage()));
      }
   }

   function makeReviewerFileViewable($paperId, $reviewId, $fileId, $revision, $viewable = false) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $paperFile =& $paperFileDao->getPaperFile($fileId, $revision);

      if ($reviewAssignment->getPaperId() == $paperId && $reviewAssignment->getReviewerFileId() == $fileId && !HookRegistry::call('TrackDirectorAction::makeReviewerFileViewable', array(&$reviewAssignment, &$paperFile, &$viewable))) {
         $paperFile->setViewable($viewable);
         $paperFileDao->updatePaperFile($paperFile);           
      }
   }

   function setDueDate($paperId, $reviewId, $dueDate = null, $numWeeks = null, $logChange = true) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
      if (!isset($reviewer)) return false;

      if ($reviewAssignment->getPaperId() == $paperId && !HookRegistry::call('TrackDirectorAction::setDueDate', array(&$reviewAssignment, &$reviewer, &$dueDate, &$numWeeks))) {
         $today = getDate();
         $todayTimestamp = mktime(0, 0, 0, $today['mon'], $today['mday'], $today['year']);
         if ($dueDate != null) {
            $dueDateParts = explode('-', $dueDate);

            // Ensure that the specified due date is today or after today's date.
            if ($todayTimestamp <= strtotime($dueDate)) {
               $reviewAssignment->setDateDue(date('Y-m-d H:i:s', mktime(0, 0, 0, $dueDateParts[1], $dueDateParts[2], $dueDateParts[0])));
            } else {
               $reviewAssignment->setDateDue(date('Y-m-d H:i:s', $todayTimestamp));
            }
         } else {
            // Add the equivilant of $numWeeks weeks, measured in seconds, to $todaysTimestamp.
            $newDueDateTimestamp = $todayTimestamp + ($numWeeks * 7 * 24 * 60 * 60);

            $reviewAssignment->setDateDue(date('Y-m-d H:i:s', $newDueDateTimestamp));
         }

         $reviewAssignment->stampModified();
         $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);

         if ($logChange) {
            // Add log
            import('paper.log.PaperLog');
            import('paper.log.PaperEventLogEntry');
            PaperLog::logEvent(
               $paperId,
               PAPER_LOG_REVIEW_SET_DUE_DATE,
               LOG_TYPE_REVIEW,
               $reviewAssignment->getId(),
               'log.review.reviewDueDateSet',
               array(
                  'reviewerName' => $reviewer->getFullName(),
                  'dueDate' => strftime(Config::getVar('general', 'date_format_short'), strtotime($reviewAssignment->getDateDue())),
                  'paperId' => $paperId,
                  'stage' => $reviewAssignment->getStage()
               )
            );
         } // $logChange
      }
   }

   function unsuitableSubmission($trackDirectorSubmission, $send = false) {
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');

      $conference =& Request::getConference();
      $schedConf =& Request::getSchedConf();
      $user =& Request::getUser();

      $author =& $userDao->getUser($trackDirectorSubmission->getUserId());
      if (!isset($author)) return true;

      import('mail.PaperMailTemplate');
      $email = new PaperMailTemplate($trackDirectorSubmission, 'SUBMISSION_UNSUITABLE');

      if (!$email->isEnabled() || ($send && !$email->hasErrors())) {
         HookRegistry::call('TrackDirectorAction::unsuitableSubmission', array(&$trackDirectorSubmission, &$author, &$email));
         if ($email->isEnabled()) {
            $email->setAssoc(PAPER_EMAIL_DIRECTOR_NOTIFY_AUTHOR_UNSUITABLE, PAPER_EMAIL_TYPE_DIRECTOR, $user->getId());
            $email->send();
         }
         TrackDirectorAction::archiveSubmission($trackDirectorSubmission);
         return true;
      } else {
         if (!Request::getUserVar('continued')) {
            $paramArray = array(
               'editorialContactSignature' => $user->getContactSignature(),
               'authorName' => $author->getFullName(),
               'locationCity' => $schedConf->getSetting('locationCity')
            );
            $email->assignParams($paramArray);
            $email->addRecipient($author->getEmail(), $author->getFullName());
         }
         $email->displayEditForm(Request::url(null, null, null, 'unsuitableSubmission'), array('paperId' => $trackDirectorSubmission->getPaperId()));
         return false;
      }
   }

   function setReviewerRecommendation($paperId, $reviewId, $recommendation, $acceptOption) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId(), true);

      if ($reviewAssignment->getPaperId() == $paperId && !HookRegistry::call('TrackDirectorAction::setReviewerRecommendation', array(&$reviewAssignment, &$reviewer, &$recommendation, &$acceptOption))) {
         $reviewAssignment->setRecommendation($recommendation);

         $nowDate = Core::getCurrentDate();
         if (!$reviewAssignment->getDateConfirmed()) {
            $reviewAssignment->setDateConfirmed($nowDate);
         }
         $reviewAssignment->setDateCompleted($nowDate);
         $reviewAssignment->stampModified();

         $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');
         PaperLog::logEvent($paperId, PAPER_LOG_REVIEW_RECOMMENDATION_BY_PROXY, LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewRecommendationSetByProxy', array('directorName' => $user->getFullName(), 'reviewerName' => $reviewer->getFullName(), 'paperId' => $paperId, 'stage' => $reviewAssignment->getStage()));
      }
   }   

   function clearReviewForm($trackDirectorSubmission, $reviewId) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);

      if (HookRegistry::call('TrackDirectorAction::clearReviewForm', array(&$trackDirectorSubmission, &$reviewAssignment, &$reviewId))) return $reviewId;

      if (isset($reviewAssignment) && $reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId()) {
         $reviewFormResponseDao =& DAORegistry::getDAO('ReviewFormResponseDAO');
         $responses = $reviewFormResponseDao->getReviewReviewFormResponseValues($reviewId);
         if (!empty($responses)) {
            $reviewFormResponseDao->deleteByReviewId($reviewId);
         }
         $reviewAssignment->setReviewFormId(null);
         $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
      }
   }

   function addReviewForm($trackDirectorSubmission, $reviewId, $reviewFormId) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);

      if (HookRegistry::call('TrackDirectorAction::addReviewForm', array(&$trackDirectorSubmission, &$reviewAssignment, &$reviewId, &$reviewFormId))) return $reviewFormId;

      if (isset($reviewAssignment) && $reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId()) {
         // Only add the review form if it has not already
         // been assigned to the review.
         if ($reviewAssignment->getReviewFormId() != $reviewFormId) {
            $reviewFormResponseDao =& DAORegistry::getDAO('ReviewFormResponseDAO');
            $responses = $reviewFormResponseDao->getReviewReviewFormResponseValues($reviewId);
            if (!empty($responses)) {
               $reviewFormResponseDao->deleteByReviewId($reviewId);
            }
            $reviewAssignment->setReviewFormId($reviewFormId);
            $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
         }
      }
   }

   function viewReviewFormResponse($trackDirectorSubmission, $reviewId) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);

      if (HookRegistry::call('TrackDirectorAction::viewReviewFormResponse', array(&$trackDirectorSubmission, &$reviewAssignment, &$reviewId))) return $reviewId;

      if (isset($reviewAssignment) && $reviewAssignment->getPaperId() == $trackDirectorSubmission->getPaperId()) {
         $reviewFormId = $reviewAssignment->getReviewFormId();
         if ($reviewFormId != null) {
            import('submission.form.ReviewFormResponseForm');
            $reviewForm = new ReviewFormResponseForm($reviewId, $reviewFormId);
            $reviewForm->initData();
            $reviewForm->display();
         }
      }
   }

   function setEditingFile($trackDirectorSubmission, $fileId, $revision, $createGalley = false) {
      import('file.PaperFileManager');
      $paperFileManager = new PaperFileManager($trackDirectorSubmission->getPaperId());
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');
      $user =& Request::getUser();

      if (!HookRegistry::call('TrackDirectorAction::setEditingFile', array(&$trackDirectorSubmission, &$fileId, &$revision))) {
         // Copy the file from the director decision file folder to the layout folder
         $newFileId = $paperFileManager->copyToLayoutFile($fileId, $revision);

         $trackDirectorSubmission->setLayoutFileId($newFileId);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

         if ($createGalley) {
            $paperGalleyDao =& DAORegistry::getDAO('PaperGalleyDAO');
            $galleys =& $paperGalleyDao->getGalleysByPaper($trackDirectorSubmission->getPaperId());
            if (empty($galleys)) {
               $layoutFile =& $paperFileDao->getPaperFile($newFileId, $revision);
               $fileType = $layoutFile->getFileType();
               $fileId = $paperFileManager->copyPublicFile($layoutFile->getFilePath(), $fileType);
               if (strstr($fileType, 'html')) {
                  $galley = new PaperHTMLGalley();
               } else {
                  $galley = new PaperGalley();
               }
               $galley->setPaperId($trackDirectorSubmission->getPaperId());
               $galley->setLocale(AppLocale::getLocale());
               $galley->setFileId($fileId);
               if ($galley->isHTMLGalley()) {
                  $galley->setLabel('HTML');
               } elseif (strstr($fileType, 'pdf')) {
                  $galley->setLabel('PDF');
               } else if (strstr($fileType, 'postscript')) {
                  $galley->setLabel('Postscript');
               } else if (strstr($fileType, 'xml')) {
                  $galley->setLabel('XML');
               } else {
                  $galley->setLabel(__('common.untitled'));
               }
               $paperGalleyDao->insertGalley($galley);
            }
         }

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');
         PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_LAYOUT_SET_FILE, LOG_TYPE_FILE, $trackDirectorSubmission->getLayoutFileId(), 'log.layout.layoutFileSet', array('directorName' => $user->getFullName(), 'paperId' => $trackDirectorSubmission->getPaperId()));
      }
   }

   function uploadReviewVersion($trackDirectorSubmission) {
      import('file.PaperFileManager');
      $paperFileManager = new PaperFileManager($trackDirectorSubmission->getPaperId());
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');

      $fileName = 'upload';
      if ($paperFileManager->uploadError($fileName)) return false;
      if (!$paperFileManager->uploadedFileExists($fileName)) return false;
      if (HookRegistry::call('TrackDirectorAction::uploadReviewVersion', array(&$trackDirectorSubmission))) return true;

      if ($trackDirectorSubmission->getReviewFileId() != null) {
         $reviewFileId = $paperFileManager->uploadReviewFile($fileName, $trackDirectorSubmission->getReviewFileId());
         // Increment the review revision.
         $trackDirectorSubmission->setReviewRevision($trackDirectorSubmission->getReviewRevision()+1);
      } else {
         $reviewFileId = $paperFileManager->uploadReviewFile($fileName);
         $trackDirectorSubmission->setReviewRevision(1);
      }
      $directorFileId = $paperFileManager->copyToDirectorFile($reviewFileId, $trackDirectorSubmission->getReviewRevision(), $trackDirectorSubmission->getDirectorFileId());

      if ($reviewFileId != 0 && isset($directorFileId) && $directorFileId != 0) {
         $trackDirectorSubmission->setReviewFileId($reviewFileId);
         $trackDirectorSubmission->setDirectorFileId($directorFileId);

         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
      }
      return true;
   }

   function uploadDirectorVersion($trackDirectorSubmission) {
      import('file.PaperFileManager');
      $paperFileManager = new PaperFileManager($trackDirectorSubmission->getPaperId());
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $user =& Request::getUser();

      $fileName = 'upload';
      if ($paperFileManager->uploadError($fileName)) return false;
      if ($paperFileManager->uploadedFileExists($fileName) && !HookRegistry::call('TrackDirectorAction::uploadDirectorVersion', array(&$trackDirectorSubmission))) {
         if ($trackDirectorSubmission->getDirectorFileId() != null) {
            $fileId = $paperFileManager->uploadDirectorDecisionFile($fileName, $trackDirectorSubmission->getDirectorFileId());
         } else {
            $fileId = $paperFileManager->uploadDirectorDecisionFile($fileName);
         }
      }

      if (isset($fileId) && $fileId != 0) {
         $trackDirectorSubmission->setDirectorFileId($fileId);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');
         PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_DIRECTOR_FILE, LOG_TYPE_DIRECTOR, $trackDirectorSubmission->getDirectorFileId(), 'log.director.directorFile');
      }
   }

   function completePaper($trackDirectorSubmission, $complete) {
      import('file.PaperFileManager');
      $paperFileManager = new PaperFileManager($trackDirectorSubmission->getPaperId());
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $user =& Request::getUser();

      import('paper.log.PaperLog');
      import('paper.log.PaperEventLogEntry');

      if ($complete) { // Publish the paper.
         $trackDirectorSubmission->setStatus(STATUS_PUBLISHED);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

         // Add a published paper object
         $publishedPaperDao =& DAORegistry::getDAO('PublishedPaperDAO');
         if(($publishedPaper = $publishedPaperDao->getPublishedPaperByPaperId($trackDirectorSubmission->getPaperId())) == null) {
            $schedConfId = $trackDirectorSubmission->getSchedConfId();

            $publishedPaper = new PublishedPaper();
            $publishedPaper->setPaperId($trackDirectorSubmission->getPaperId());
            $publishedPaper->setSchedConfId($schedConfId);
            $publishedPaper->setDatePublished(Core::getCurrentDate());
            $publishedPaper->setSeq(REALLY_BIG_NUMBER);
            $publishedPaper->setViews(0);

            $publishedPaperDao->insertPublishedPaper($publishedPaper);

            // Resequence the published papers.
            $publishedPaperDao->resequencePublishedPapers($trackDirectorSubmission->getTrackId(), $schedConfId);
         }

         // Add log
         PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_DIRECTOR_PUBLISH, LOG_TYPE_DIRECTOR, $trackDirectorSubmission->getDirectorFileId(), 'log.director.publish');

      } else { // Un-publish the paper.

         $trackDirectorSubmission->setStatus(STATUS_QUEUED);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

         // Add log
         PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_DIRECTOR_UNPUBLISH, LOG_TYPE_DIRECTOR, $trackDirectorSubmission->getDirectorFileId(), 'log.director.unpublish');
      }
   }

   function archiveSubmission($trackDirectorSubmission) {
      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $user =& Request::getUser();

      if (HookRegistry::call('TrackDirectorAction::archiveSubmission', array(&$trackDirectorSubmission))) return;

      $trackDirectorSubmission->setStatus(STATUS_ARCHIVED);
      $trackDirectorSubmission->stampStatusModified();
      $trackDirectorSubmission->stampDateToArchive();

      $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

      // Add log
      import('paper.log.PaperLog');
      import('paper.log.PaperEventLogEntry');
      PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_DIRECTOR_ARCHIVE, LOG_TYPE_DIRECTOR, $trackDirectorSubmission->getPaperId(), 'log.director.archived', array('paperId' => $trackDirectorSubmission->getPaperId()));
   }

   function restoreToQueue($trackDirectorSubmission) {
      if (HookRegistry::call('TrackDirectorAction::restoreToQueue', array(&$trackDirectorSubmission))) return;

      $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');

      // Determine which queue to return the paper to: the
      // scheduling queue or the editing queue.
      $publishedPaperDao =& DAORegistry::getDAO('PublishedPaperDAO');
      $publishedPaper =& $publishedPaperDao->getPublishedPaperByPaperId($trackDirectorSubmission->getPaperId());
      if ($publishedPaper) {
         $trackDirectorSubmission->setStatus(STATUS_PUBLISHED);
      } else {
         $trackDirectorSubmission->setStatus(STATUS_QUEUED);
      }
      unset($publishedPaper);

      $trackDirectorSubmission->stampStatusModified();

      $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);

      // Add log
      import('paper.log.PaperLog');
      import('paper.log.PaperEventLogEntry');
      PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_DIRECTOR_RESTORE, LOG_TYPE_DIRECTOR, $trackDirectorSubmission->getPaperId(), 'log.director.restored', array('paperId' => $trackDirectorSubmission->getPaperId()));
   }

   //
   // Layout Editing
   //

   function orderGalley($paper, $galleyId, $direction) {
      $galleyDao =& DAORegistry::getDAO('PaperGalleyDAO');
      $galley =& $galleyDao->getGalley($galleyId, $paper->getId());
      if (isset($galley)) {
         $galley->setSequence($galley->getSequence() + ($direction == 'u' ? -1.5 : 1.5));
         $galleyDao->updateGalley($galley);
         $galleyDao->resequenceGalleys($paper->getId());
      }
   }

   function deleteGalley($paper, $galleyId) {
import('file.PaperFileManager');

      $galleyDao =& DAORegistry::getDAO('PaperGalleyDAO');
      $galley =& $galleyDao->getGalley($galleyId, $paper->getId());

      if (isset($galley) && !HookRegistry::call('TrackDirectorAction::deleteGalley', array(&$paper, &$galley))) {
         $paperFileManager = new PaperFileManager($paper->getId());

         if ($galley->getFileId()) {
            $paperFileManager->deleteFile($galley->getFileId());
            import('search.PaperSearchIndex');
            PaperSearchIndex::deleteTextIndex($paper->getId(), PAPER_SEARCH_GALLEY_FILE, $galley->getFileId());
         }
         if ($galley->isHTMLGalley()) {
            if ($galley->getStyleFileId()) {
               $paperFileManager->deleteFile($galley->getStyleFileId());
            }
            foreach ($galley->getImageFiles() as $image) {
               $paperFileManager->deleteFile($image->getFileId());
            }
         }
         $galleyDao->deleteGalley($galley);
      }
   }

   function orderSuppFile($paper, $suppFileId, $direction) {
      $suppFileDao =& DAORegistry::getDAO('SuppFileDAO');
      $suppFile =& $suppFileDao->getSuppFile($suppFileId, $paper->getId());
      if (isset($suppFile)) {
         $suppFile->setSequence($suppFile->getSequence() + ($direction == 'u' ? -1.5 : 1.5));
         $suppFileDao->updateSuppFile($suppFile);
         $suppFileDao->resequenceSuppFiles($paper->getId());
      }
   }

   function deleteSuppFile($paper, $suppFileId) {
      import('file.PaperFileManager');

      $suppFileDao =& DAORegistry::getDAO('SuppFileDAO');

      $suppFile =& $suppFileDao->getSuppFile($suppFileId, $paper->getId());
      if (isset($suppFile) && !HookRegistry::call('TrackDirectorAction::deleteSuppFile', array(&$paper, &$suppFile))) {
         if ($suppFile->getFileId()) {
            $paperFileManager = new PaperFileManager($paper->getId());
            $paperFileManager->deleteFile($suppFile->getFileId());
            import('search.PaperSearchIndex');
            PaperSearchIndex::deleteTextIndex($paper->getId(), PAPER_SEARCH_SUPPLEMENTARY_FILE, $suppFile->getFileId());
         }
         $suppFileDao->deleteSuppFile($suppFile);
      }
   }

   function deletePaperFile($submission, $fileId, $revision) {
      import('file.PaperFileManager');
      $file =& $submission->getDirectorFile();

      if (isset($file) && $file->getFileId() == $fileId && !HookRegistry::call('TrackDirectorAction::deletePaperFile', array(&$submission, &$fileId, &$revision))) {
         $paperFileManager = new PaperFileManager($submission->getPaperId());
         $paperFileManager->deleteFile($fileId, $revision);
      }
   }

   function deletePaperImage($submission, $fileId, $revision) {
      import('file.PaperFileManager');
      $paperGalleyDao =& DAORegistry::getDAO('PaperGalleyDAO');
      if (HookRegistry::call('TrackDirectorAction::deletePaperImage', array(&$submission, &$fileId, &$revision))) return;
      foreach ($submission->getGalleys() as $galley) {
         $images =& $paperGalleyDao->getGalleyImages($galley->getId());
         foreach ($images as $imageFile) {
            if ($imageFile->getPaperId() == $submission->getPaperId() && $fileId == $imageFile->getFileId() && $imageFile->getRevision() == $revision) {
               $paperFileManager = new PaperFileManager($submission->getPaperId());
               $paperFileManager->deleteFile($imageFile->getFileId(), $imageFile->getRevision());
            }
         }
         unset($images);
      }
   }

   function addSubmissionNote($paperId) {
      import('file.PaperFileManager');

      $paperNoteDao =& DAORegistry::getDAO('PaperNoteDAO');
      $user =& Request::getUser();

      $paperNote = new PaperNote();
      $paperNote->setPaperId($paperId);
      $paperNote->setUserId($user->getId());
      $paperNote->setDateCreated(Core::getCurrentDate());
      $paperNote->setDateModified(Core::getCurrentDate());
      $paperNote->setTitle(Request::getUserVar('title'));
      $paperNote->setNote(Request::getUserVar('note'));

      if (!HookRegistry::call('TrackDirectorAction::addSubmissionNote', array(&$paperId, &$paperNote))) {
         $paperFileManager = new PaperFileManager($paperId);
         if ($paperFileManager->uploadedFileExists('upload')) {
            if ($paperFileManager->uploadError('upload')) return false;
            $fileId = $paperFileManager->uploadSubmissionNoteFile('upload');
         } else {
            $fileId = 0;
         }

         $paperNote->setFileId($fileId);

         $paperNoteDao->insertPaperNote($paperNote);
      }
   }

   function removeSubmissionNote($paperId) {
      $noteId = Request::getUserVar('noteId');
      $fileId = Request::getUserVar('fileId');

      if (HookRegistry::call('TrackDirectorAction::removeSubmissionNote', array(&$paperId, &$noteId, &$fileId))) return;

      // if there is an attached file, remove it as well
      if ($fileId) {
         import('file.PaperFileManager');
         $paperFileManager = new PaperFileManager($paperId);
         $paperFileManager->deleteFile($fileId);
      }

      $paperNoteDao =& DAORegistry::getDAO('PaperNoteDAO');
      $paperNoteDao->deletePaperNoteById($noteId);
   }

   function updateSubmissionNote($paperId) {
      import('file.PaperFileManager');

      $paperNoteDao =& DAORegistry::getDAO('PaperNoteDAO');
      $user =& Request::getUser();

      $paperNote = new PaperNote();
      $paperNote->setNoteId(Request::getUserVar('noteId'));
      $paperNote->setPaperId($paperId);
      $paperNote->setUserId($user->getId());
      $paperNote->setDateModified(Core::getCurrentDate());
      $paperNote->setTitle(Request::getUserVar('title'));
      $paperNote->setNote(Request::getUserVar('note'));
      $paperNote->setFileId(Request::getUserVar('fileId'));

      if (HookRegistry::call('TrackDirectorAction::updateSubmissionNote', array(&$paperId, &$paperNote))) return;

      $paperFileManager = new PaperFileManager($paperId);

      if ($paperFileManager->uploadError('upload')) return false;
      // if there is a new file being uploaded
      if ($paperFileManager->uploadedFileExists('upload')) {
         // Attach the new file to the note, overwriting existing file if necessary
         $fileId = $paperFileManager->uploadSubmissionNoteFile('upload', $paperNote->getFileId(), true);
         $paperNote->setFileId($fileId);

      } else {
         if (Request::getUserVar('removeUploadedFile')) {
            $paperFileManager = new PaperFileManager($paperId);
            $paperFileManager->deleteFile($paperNote->getFileId());
            $paperNote->setFileId(0);
         }
      }

      $paperNoteDao->updatePaperNote($paperNote);
   }

   function clearAllSubmissionNotes($paperId) {
      if (HookRegistry::call('TrackDirectorAction::clearAllSubmissionNotes', array(&$paperId))) return;

      import('file.PaperFileManager');

      $paperNoteDao =& DAORegistry::getDAO('PaperNoteDAO');

      $fileIds = $paperNoteDao->getAllPaperNoteFileIds($paperId);

      if (!empty($fileIds)) {
         $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');
         $paperFileManager = new PaperFileManager($paperId);

         foreach ($fileIds as $fileId) {
            $paperFileManager->deleteFile($fileId);
         }        
      }

      $paperNoteDao->clearAllPaperNotes($paperId);

   }

   //
   // Comments
   //

   function viewPeerReviewComments(&$paper, $reviewId) {
      if (HookRegistry::call('TrackDirectorAction::viewPeerReviewComments', array(&$paper, &$reviewId))) return;

      import('submission.form.comment.PeerReviewCommentForm');

      $commentForm = new PeerReviewCommentForm($paper, $reviewId, Validation::isDirector()?ROLE_ID_DIRECTOR:ROLE_ID_TRACK_DIRECTOR);
      $commentForm->initData();
      $commentForm->display();
   }

   function postPeerReviewComment(&$paper, $reviewId, $emailComment) {
      if (HookRegistry::call('TrackDirectorAction::postPeerReviewComment', array(&$paper, &$reviewId, &$emailComment))) return;

      import('submission.form.comment.PeerReviewCommentForm');

      $commentForm = new PeerReviewCommentForm($paper, $reviewId, Validation::isDirector()?ROLE_ID_DIRECTOR:ROLE_ID_TRACK_DIRECTOR);
      $commentForm->readInputData();

      if ($commentForm->validate()) {
         $commentForm->execute();
         
         // Send a notification to associated users
         import('notification.NotificationManager');
         $notificationManager = new NotificationManager();
         $notificationUsers = $paper->getAssociatedUserIds();
         foreach ($notificationUsers as $userRole) {
            $url = Request::url(null, null, $userRole['role'], 'submissionReview', $paper->getId(), null, 'peerReview');
            $notificationManager->createNotification(
               $userRole['id'], 'notification.type.reviewerComment',
               $paper->getLocalizedTitle(), $url, 1, NOTIFICATION_TYPE_REVIEWER_COMMENT
            );
         }

         if ($emailComment) {
            $commentForm->email();
         }

      } else {
         $commentForm->display();
         return false;
      }
      return true;
   }

   function viewDirectorDecisionComments($paper) {
      if (HookRegistry::call('TrackDirectorAction::viewDirectorDecisionComments', array(&$paper))) return;

      import('submission.form.comment.DirectorDecisionCommentForm');

      $commentForm = new DirectorDecisionCommentForm($paper, Validation::isDirector()?ROLE_ID_DIRECTOR:ROLE_ID_TRACK_DIRECTOR);
      $commentForm->initData();
      $commentForm->display();
   }

   function postDirectorDecisionComment($paper, $emailComment) {
      if (HookRegistry::call('TrackDirectorAction::postDirectorDecisionComment', array(&$paper, &$emailComment))) return;

      import('submission.form.comment.DirectorDecisionCommentForm');

      $commentForm = new DirectorDecisionCommentForm($paper, Validation::isDirector()?ROLE_ID_DIRECTOR:ROLE_ID_TRACK_DIRECTOR);
      $commentForm->readInputData();

      if ($commentForm->validate()) {
         $commentForm->execute();

         // Send a notification to associated users
         import('notification.NotificationManager');
         $notificationManager = new NotificationManager();
         $notificationUsers = $paper->getAssociatedUserIds(true, false);
         foreach ($notificationUsers as $userRole) {
            $url = Request::url(null, null, $userRole['role'], 'submissionReview', $paper->getId(), null, 'directorDecision');
            $notificationManager->createNotification(
               $userRole['id'], 'notification.type.directorDecisionComment',
               $paper->getLocalizedTitle(), $url, 1, NOTIFICATION_TYPE_DIRECTOR_DECISION_COMMENT
            );
         }
            
         if ($emailComment) {
            $commentForm->email();
         }
      } else {
         $commentForm->display();
         return false;
      }
      return true;
   }

   function emailDirectorDecisionComment($trackDirectorSubmission, $send) {
      $userDao =& DAORegistry::getDAO('UserDAO');
      $paperCommentDao =& DAORegistry::getDAO('PaperCommentDAO');
      $conference =& Request::getConference();
      $schedConf =& Request::getSchedConf();

      $templateName = null;
      $reviewMode = $trackDirectorSubmission->getReviewMode();
      $stages = $trackDirectorSubmission->getDecisions();
      if (is_array($stages)) {
         $isAbstract = array_pop(array_keys($stages)) == REVIEW_STAGE_ABSTRACT;
      }
      if (isset($stages) && is_array($stages)) {
         $decisions = array_pop($stages);
         // If this round has no decision, revert to prior round
         if (empty($decisions)) $decisions = array_pop($stages);
      }
      if (isset($decisions) && is_array($decisions)) $lastDecision = array_pop($decisions);
      if (isset($lastDecision) && is_array($lastDecision)) switch ($lastDecision['decision']) {
         case SUBMISSION_DIRECTOR_DECISION_INVITE:
            $templateName = ($reviewMode==REVIEW_MODE_BOTH_SEQUENTIAL?'SUBMISSION_PAPER_INVITE':'SUBMISSION_ABSTRACT_ACCEPT');
            break;
         case SUBMISSION_DIRECTOR_DECISION_ACCEPT:
            $templateName = 'SUBMISSION_PAPER_ACCEPT';
            break;
         case SUBMISSION_DIRECTOR_DECISION_PENDING_REVISIONS:
            $templateName = $isAbstract?'SUBMISSION_ABSTRACT_REVISE':'SUBMISSION_PAPER_REVISE';
            break;
         case SUBMISSION_DIRECTOR_DECISION_DECLINE:
            $templateName = $isAbstract?'SUBMISSION_ABSTRACT_DECLINE':'SUBMISSION_PAPER_DECLINE';
            break;
      }

      $user =& Request::getUser();
      import('mail.PaperMailTemplate');
      $email = new PaperMailTemplate($trackDirectorSubmission, $templateName);

      if ($send && !$email->hasErrors()) {
         HookRegistry::call('TrackDirectorAction::emailDirectorDecisionComment', array(&$trackDirectorSubmission, &$send));
         $email->send();

         $paperComment = new PaperComment();
         $paperComment->setCommentType(COMMENT_TYPE_DIRECTOR_DECISION);
         $paperComment->setRoleId(Validation::isDirector()?ROLE_ID_DIRECTOR:ROLE_ID_TRACK_DIRECTOR);
         $paperComment->setPaperId($trackDirectorSubmission->getPaperId());
         $paperComment->setAuthorId($trackDirectorSubmission->getUserId());
         $paperComment->setCommentTitle($email->getSubject());
         $paperComment->setComments($email->getBody());
         $paperComment->setDatePosted(Core::getCurrentDate());
         $paperComment->setViewable(true);
         $paperComment->setAssocId($trackDirectorSubmission->getPaperId());
         $paperCommentDao->insertPaperComment($paperComment);

         return true;
      } else {
         if (!Request::getUserVar('continued')) {
            $authorUser =& $userDao->getUser($trackDirectorSubmission->getUserId());
            $authorEmail = $authorUser->getEmail();
            $email->addRecipient($authorEmail, $authorUser->getFullName());
            if ($schedConf->getSetting('notifyAllAuthorsOnDecision')) foreach ($trackDirectorSubmission->getAuthors() as $author) {
               if ($author->getEmail() != $authorEmail) {
                  $email->addCc ($author->getEmail(), $author->getFullName());
               }
            }
            $email->assignParams(array(
               'conferenceDate' => strftime(Config::getVar('general', 'date_format_short'), $schedConf->getSetting('startDate')),
               'authorName' => $authorUser->getFullName(),
               'conferenceTitle' => $conference->getConferenceTitle(),
               'editorialContactSignature' => $user->getContactSignature(),
               'locationCity' => $schedConf->getSetting('locationCity'),
               'paperTitle' => $trackDirectorSubmission->getLocalizedTitle()
            ));
         } elseif (Request::getUserVar('importPeerReviews')) {
            $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
            $hasBody = false;
            for ($stage = $trackDirectorSubmission->getCurrentStage(); $stage == REVIEW_STAGE_ABSTRACT || $stage == REVIEW_STAGE_PRESENTATION; $stage--) {
               $reviewAssignments =& $reviewAssignmentDao->getReviewAssignmentsByPaperId($trackDirectorSubmission->getPaperId(), $stage);
               $reviewIndexes =& $reviewAssignmentDao->getReviewIndexesForStage($trackDirectorSubmission->getPaperId(), $stage);

               $body = '';
               foreach ($reviewAssignments as $reviewAssignment) {
                  // If the reviewer has completed the assignment, then import the review.
                  if ($reviewAssignment->getDateCompleted() != null && !$reviewAssignment->getCancelled()) {
                     // Get the comments associated with this review assignment
                     $paperComments =& $paperCommentDao->getPaperComments($trackDirectorSubmission->getPaperId(), COMMENT_TYPE_PEER_REVIEW, $reviewAssignment->getId());
                     
                     if ($paperComments) {
                        $body .= "------------------------------------------------------\n";
                        $body .= __('submission.comments.importPeerReviews.reviewerLetter', array('reviewerLetter' => chr(ord('A') + $reviewIndexes[$reviewAssignment->getId()]))) . "\n";
                        if (is_array($paperComments)) {
                           foreach ($paperComments as $comment) {
                              // If the comment is viewable by the author, then add the comment.
                              if ($comment->getViewable()) {
                                 $body .= String::html2utf(
                                    strip_tags(
                                       str_replace(array('<p>', '<br>', '<br/>'), array("\n", "\n", "\n"), $comment->getComments())
                                    )
                                 ) . "\n\n";
                                 $hasBody = true;
                              }
                           }
                        }
                        $body .= "------------------------------------------------------\n\n";
                     } 
                     if ($reviewFormId = $reviewAssignment->getReviewFormId()){
                        $reviewId = $reviewAssignment->getId();
                        
                        $reviewFormResponseDao =& DAORegistry::getDAO('ReviewFormResponseDAO');
                        $reviewFormElementDao =& DAORegistry::getDAO('ReviewFormElementDAO');
                        $reviewFormElements =& $reviewFormElementDao->getReviewFormElements($reviewFormId);
                        if (!$paperComments) {
                           $body .= "------------------------------------------------------\n";
                           $body .= __('submission.comments.importPeerReviews.reviewerLetter', array('reviewerLetter' => chr(ord('A') + $reviewIndexes[$reviewAssignment->getId()]))) . "\n\n";
                        }
                        foreach ($reviewFormElements as $reviewFormElement) if ($reviewFormElement->getIncluded()) {
                           $body .= strip_tags($reviewFormElement->getLocalizedQuestion()) . ": \n";
                           $reviewFormResponse = $reviewFormResponseDao->getReviewFormResponse($reviewId, $reviewFormElement->getId());
         
                           if ($reviewFormResponse) {
                              $possibleResponses = $reviewFormElement->getLocalizedPossibleResponses();
                              if (in_array($reviewFormElement->getElementType(), $reviewFormElement->getMultipleResponsesElementTypes())) {
                                 if ($reviewFormElement->getElementType() == REVIEW_FORM_ELEMENT_TYPE_CHECKBOXES) {
                                    foreach ($reviewFormResponse->getValue() as $value) {
                                       $body .= "\t" . String::html2utf(strip_tags($possibleResponses[$value-1]['content'])) . "\n";
                                    }
                                 } else {
                                    $body .= "\t" . String::html2utf(strip_tags($possibleResponses[$reviewFormResponse->getValue()-1]['content'])) . "\n";
                                 }
                                 $body .= "\n";
                              } else {
                                 $body .= "\t" . String::html2utf(strip_tags($reviewFormResponse->getValue())) . "\n\n";
                              }
                           }
                        }
                        $body .= "------------------------------------------------------\n\n";
                        $hasBody = true;
                     }
                  } // if
               } // foreach
               if ($hasBody) {
                  $oldBody = $email->getBody();
                  if (!empty($oldBody)) $oldBody .= "\n";
                  $email->setBody($oldBody . $body);
                  break;
               }
            } // foreach
         }

         $email->displayEditForm(Request::url(null, null, null, 'emailDirectorDecisionComment', 'send'), array('paperId' => $trackDirectorSubmission->getPaperId()), 'submission/comment/directorDecisionEmail.tpl', array('isADirector' => true));

         return false;
      }
   }

   function blindCcReviewsToReviewers($paper, $send = false, $inhibitExistingEmail = false) {
      $commentDao =& DAORegistry::getDAO('PaperCommentDAO');
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $conference =& Request::getConference();

      $comments =& $commentDao->getPaperComments($paper->getId(), COMMENT_TYPE_DIRECTOR_DECISION);
      $reviewAssignments =& $reviewAssignmentDao->getReviewAssignmentsByPaperId($paper->getId(), $paper->getCurrentStage());

      $commentsText = "";
      foreach ($comments as $comment) {
         $commentsText .= String::html2utf(strip_tags($comment->getComments())) . "\n\n";
      }

      $user =& Request::getUser();
      import('mail.PaperMailTemplate');
      $email = new PaperMailTemplate($paper, 'SUBMISSION_DECISION_REVIEWERS', null, null, null, null, true, true);

      if ($send && !$email->hasErrors() && !$inhibitExistingEmail) {
         HookRegistry::call('TrackDirectorAction::blindCcReviewsToReviewers', array(&$paper, &$reviewAssignments, &$email));
         $email->send();
         return true;
      } else {
         if ($inhibitExistingEmail || !Request::getUserVar('continued')) {
            $email->clearRecipients();
            foreach ($reviewAssignments as $reviewAssignment) {
               if ($reviewAssignment->getDateCompleted() != null && !$reviewAssignment->getCancelled()) {
                  $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());

                  if (isset($reviewer)) $email->addBcc($reviewer->getEmail(), $reviewer->getFullName());
               }
            }

            $paramArray = array(
               'comments' => $commentsText,
               'editorialContactSignature' => $user->getContactSignature()
            );
            $email->assignParams($paramArray);
         }

         $email->displayEditForm(Request::url(null, null, null, 'blindCcReviewsToReviewers'), array('paperId' => $paper->getId()));
         return false;
      }
   }

   function confirmReviewForReviewer($reviewId) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId(), true);

      if (HookRegistry::call('TrackDirectorAction::confirmReviewForReviewer', array(&$reviewAssignment, &$reviewer))) return;

      // Only confirm the review for the reviewer if 
      // he has not previously done so.
      if ($reviewAssignment->getDateConfirmed() == null) {
         $reviewAssignment->setDeclined(0);
         $reviewAssignment->setDateConfirmed(Core::getCurrentDate());
         $reviewAssignment->stampModified();
         $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');

         $entry = new PaperEventLogEntry();
         $entry->setPaperId($reviewAssignment->getPaperId());
         $entry->setUserId($user->getId());
         $entry->setDateLogged(Core::getCurrentDate());
         $entry->setEventType(PAPER_LOG_REVIEW_ACCEPT_BY_PROXY);
         $entry->setLogMessage('log.review.reviewAcceptedByProxy', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $reviewAssignment->getPaperId(), 'stage' => $reviewAssignment->getStage(), 'userName' => $user->getFullName()));
         $entry->setAssocType(LOG_TYPE_REVIEW);
         $entry->setAssocId($reviewAssignment->getId());

         PaperLog::logEventEntry($reviewAssignment->getPaperId(), $entry);
      }
   }

   function uploadReviewForReviewer($reviewId) {
      $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
      $userDao =& DAORegistry::getDAO('UserDAO');
      $user =& Request::getUser();

      $reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewId);
      $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId(), true);

      if (HookRegistry::call('TrackDirectorAction::uploadReviewForReviewer', array(&$reviewAssignment, &$reviewer))) return;

      // Upload the review file.
      import('file.PaperFileManager');
      $paperFileManager = new PaperFileManager($reviewAssignment->getPaperId());
      // Only upload the file if the reviewer has yet to submit a recommendation
      if (($reviewAssignment->getRecommendation() === null || $reviewAssignment->getRecommendation() === '') && !$reviewAssignment->getCancelled()) {
         $fileName = 'upload';
         if ($paperFileManager->uploadError($fileName)) return false;
         if ($paperFileManager->uploadedFileExists($fileName)) {
            if ($reviewAssignment->getReviewerFileId() != null) {
               $fileId = $paperFileManager->uploadReviewFile($fileName, $reviewAssignment->getReviewerFileId());
            } else {
               $fileId = $paperFileManager->uploadReviewFile($fileName);
            }
         }
      }

      if (isset($fileId) && $fileId != 0) {
         // Only confirm the review for the reviewer if 
         // he has not previously done so.
         if ($reviewAssignment->getDateConfirmed() == null) {
            $reviewAssignment->setDeclined(0);
            $reviewAssignment->setDateConfirmed(Core::getCurrentDate());
         }

         $reviewAssignment->setReviewerFileId($fileId);
         $reviewAssignment->stampModified();
         $reviewAssignmentDao->updateReviewAssignment($reviewAssignment);

         // Add log
         import('paper.log.PaperLog');
         import('paper.log.PaperEventLogEntry');

         $entry = new PaperEventLogEntry();
         $entry->setPaperId($reviewAssignment->getPaperId());
         $entry->setUserId($user->getId());
         $entry->setDateLogged(Core::getCurrentDate());
         $entry->setEventType(PAPER_LOG_REVIEW_FILE_BY_PROXY);
         $entry->setLogMessage('log.review.reviewFileByProxy', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $reviewAssignment->getPaperId(), 'stage' => $reviewAssignment->getStage(), 'userName' => $user->getFullName()));
         $entry->setAssocType(LOG_TYPE_REVIEW);
         $entry->setAssocId($reviewAssignment->getId());

         PaperLog::logEventEntry($reviewAssignment->getPaperId(), $entry);
      }
   }

   function updateCommentsStatus($submission, $commentsStatus) {
      if (HookRegistry::call('TrackDirectorAction::updateCommentsStatus', array(&$submission, &$commentsStatus))) return;

      $submissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
      $submission->setCommentsStatus($commentsStatus); // FIXME validate this?
      $submissionDao->updateTrackDirectorSubmission($submission);
   }

   function submissionBreadcrumb($paperId, $parentPage, $track) {
      $breadcrumb = array();
      if ($paperId) {
         $breadcrumb[] = array(Request::url(null, null, $track, 'submission', $paperId), "#$paperId", true);
      }

      if ($parentPage) {
         switch($parentPage) {
            case 'summary':
               $parent = array(Request::url(null, null, $track, 'submission', $paperId), 'submission.summary');
               break;
            case 'review':
               $parent = array(Request::url(null, null, $track, 'submissionReview', $paperId), 'submission.review');
               break;
            case 'history':
               $parent = array(Request::url(null, null, $track, 'submissionHistory', $paperId), 'submission.history');
               break;
         }
         if ($track != 'director' && $track != 'trackDirector') {
            $parent[0] = Request::url(null, null, $track, 'submission', $paperId);
         }
         if (isset($parent)) $breadcrumb[] = $parent;
      }
      return $breadcrumb;
   }

}

?>

---