PHP Validation::isDirector方法代码示例

 /**
  * View conference event log by record type.
  */
 function conferenceEventLogType($args)
 {
     $assocType = isset($args[1]) ? (int) $args[0] : null;
     $assocId = isset($args[2]) ? (int) $args[1] : null;
     $this->validate();
     $this->setupTemplate(true);
     $conference =& Request::getConference();
     $rangeInfo =& Handler::getRangeInfo('eventLogEntries', array($assocType, $assocId));
     $logDao =& DAORegistry::getDAO('ConferenceEventLogDAO');
     while (true) {
         $eventLogEntries =& $logDao->getConferenceLogEntriesByAssoc($conference->getId(), null, $assocType, $assocId, $rangeInfo);
         if ($eventLogEntries->isInBounds()) {
             break;
         }
         unset($rangeInfo);
         $rangeInfo =& $eventLogEntries->getLastPageRangeInfo();
         unset($eventLogEntries);
     }
     $templateMgr =& TemplateManager::getManager();
     $templateMgr->assign('showBackLink', true);
     $templateMgr->assign('isDirector', Validation::isDirector());
     $templateMgr->assign_by_ref('conference', $conference);
     $templateMgr->assign_by_ref('eventLogEntries', $eventLogEntries);
     $templateMgr->display('manager/conferenceEventLog.tpl');
 }

 /**
  * Display the form.
  * @param $request Request
  */
 function display($request)
 {
     $conferenceDao = DAORegistry::getDAO('ConferenceDAO');
     $conferences =& $conferenceDao->getNames();
     $canOnlyRead = true;
     $canOnlyReview = false;
     if (Validation::isReviewer()) {
         $canOnlyRead = false;
         $canOnlyReview = true;
     }
     if (Validation::isSiteAdmin() || Validation::isConferenceManager() || Validation::isDirector()) {
         $canOnlyRead = false;
         $canOnlyReview = false;
     }
     // Remove the notification setting categories that the user will not be receiving (to simplify the form)
     $notificationSettingCategories = $this->_getNotificationSettingCategories();
     if ($canOnlyRead || $canOnlyReview) {
         unset($notificationSettingCategories['submissions']);
     }
     if ($canOnlyRead) {
         unset($notificationSettingCategories['reviewing']);
     }
     $templateMgr =& TemplateManager::getManager();
     $templateMgr->assign('notificationSettingCategories', $notificationSettingCategories);
     $templateMgr->assign('notificationSettings', $this->_getNotificationSettingsMap());
     $templateMgr =& TemplateManager::getManager();
     $templateMgr->assign('canOnlyRead', $canOnlyRead);
     $templateMgr->assign('canOnlyReview', $canOnlyReview);
     return parent::display($request);
 }

 /**
  * Display the form.
  */
 function display()
 {
     $conferenceDao =& DAORegistry::getDAO('ConferenceDAO');
     $conferences =& $conferenceDao->getConferenceTitles();
     $canOnlyRead = true;
     $canOnlyReview = false;
     if (Validation::isReviewer()) {
         $canOnlyRead = false;
         $canOnlyReview = true;
     }
     if (Validation::isSiteAdmin() || Validation::isConferenceManager() || Validation::isDirector()) {
         $canOnlyRead = false;
         $canOnlyReview = false;
     }
     $templateMgr =& TemplateManager::getManager();
     $templateMgr->assign('canOnlyRead', $canOnlyRead);
     $templateMgr->assign('canOnlyReview', $canOnlyReview);
     return parent::display();
 }

 function checkRole(&$conference, &$schedConf)
 {
     $templateMgr =& TemplateManager::getManager();
     $templateMgr->assign('isConferenceManager', Validation::isConferenceManager($conference->getId()));
     $templateMgr->assign('isDirector', Validation::isDirector($conference->getId(), $schedConf->getId()));
     $templateMgr->assign('isTrackDirector', Validation::isTrackDirector($conference->getId(), $schedConf->getId()));
     $templateMgr->assign('isAuthor', Validation::isAuthor($conference->getId(), $schedConf->getId()));
 }

 /**
  * Gather information about a user's role within a conference.
  * @param $userId int
  * @param $conferenceId int 
  * @param $submissionsCount array reference
  * @param $isValid array reference
  */
 function getRoleDataForConference($userId, $conferenceId, $schedConfId, &$submissionsCount, &$isValid)
 {
     if (Validation::isConferenceManager($conferenceId)) {
         $conferenceDao =& DAORegistry::getDAO('ConferenceDAO');
         $isValid["ConferenceManager"][$conferenceId][$schedConfId] = true;
     }
     if (Validation::isDirector($conferenceId, $schedConfId)) {
         $isValid["Director"][$conferenceId][$schedConfId] = true;
         $directorSubmissionDao =& DAORegistry::getDAO('DirectorSubmissionDAO');
         $submissionsCount["Director"][$conferenceId][$schedConfId] = $directorSubmissionDao->getDirectorSubmissionsCount($schedConfId);
     }
     if (Validation::isTrackDirector($conferenceId, $schedConfId)) {
         $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
         $submissionsCount["TrackDirector"][$conferenceId][$schedConfId] = $trackDirectorSubmissionDao->getTrackDirectorSubmissionsCount($userId, $schedConfId);
         $isValid["TrackDirector"][$conferenceId][$schedConfId] = true;
     }
     if (Validation::isReviewer($conferenceId, $schedConfId)) {
         $reviewerSubmissionDao =& DAORegistry::getDAO('ReviewerSubmissionDAO');
         $submissionsCount["Reviewer"][$conferenceId][$schedConfId] = $reviewerSubmissionDao->getSubmissionsCount($userId, $schedConfId);
         $isValid["Reviewer"][$conferenceId][$schedConfId] = true;
     }
     if (Validation::isAuthor($conferenceId, $schedConfId)) {
         $authorSubmissionDao =& DAORegistry::getDAO('AuthorSubmissionDAO');
         $submissionsCount["Author"][$conferenceId][$schedConfId] = $authorSubmissionDao->getSubmissionsCount($userId, $schedConfId);
         $isValid["Author"][$conferenceId][$schedConfId] = true;
     }
 }

 /**
  * Display conference author index page.
  */
 function index($args)
 {
     $this->validate();
     $this->setupTemplate();
     $conference =& Request::getConference();
     $schedConf =& Request::getSchedConf();
     $user =& Request::getUser();
     $rangeInfo =& Handler::getRangeInfo('submissions');
     $authorSubmissionDao =& DAORegistry::getDAO('AuthorSubmissionDAO');
     $page = isset($args[0]) ? $args[0] : '';
     switch ($page) {
         case 'completed':
             $active = false;
             break;
         default:
             $page = 'active';
             $active = true;
     }
     $sort = Request::getUserVar('sort');
     $sort = isset($sort) ? $sort : 'id';
     $sortDirection = Request::getUserVar('sortDirection');
     if ($sort == 'status') {
         // FIXME Does not pass $rangeInfo else we only get partial results
         $submissions = $authorSubmissionDao->getAuthorSubmissions($user->getId(), $schedConf->getId(), $active, null, $sort, $sortDirection);
         // Sort all submissions by status, which is too complex to do in the DB
         $submissionsArray = $submissions->toArray();
         if ($sortDirection == 'DESC') {
             $submissionsArray = array_reverse($submissionsArray);
         }
         $compare = create_function('$s1, $s2', 'return strcmp($s1->getSubmissionStatus(), $s2->getSubmissionStatus());');
         usort($submissionsArray, $compare);
         // Convert submission array back to an ItemIterator class
         import('core.ArrayItemIterator');
         $submissions =& ArrayItemIterator::fromRangeInfo($submissionsArray, $rangeInfo);
     } else {
         $submissions = $authorSubmissionDao->getAuthorSubmissions($user->getId(), $schedConf->getId(), $active, $rangeInfo, $sort, $sortDirection);
     }
     $templateMgr =& TemplateManager::getManager();
     $templateMgr->assign('pageToDisplay', $page);
     $templateMgr->assign_by_ref('submissions', $submissions);
     $submissionsOpenDate = $schedConf->getSetting('submissionsOpenDate');
     $submissionsCloseDate = $schedConf->getSetting('submissionsCloseDate');
     if (Validation::isDirector($schedConf->getConferenceId(), $schedConf->getId()) || Validation::isTrackDirector($schedConf->getConferenceId(), $schedConf->getId())) {
         // Directors or track directors may always submit
         $acceptingSubmissions = true;
     } elseif (!$submissionsOpenDate || !$submissionsCloseDate || time() < $submissionsOpenDate) {
         // Too soon
         $acceptingSubmissions = false;
         $notAcceptingSubmissionsMessage = __('author.submit.notAcceptingYet');
     } elseif (time() > $submissionsCloseDate) {
         // Too late
         $acceptingSubmissions = false;
         $notAcceptingSubmissionsMessage = __('author.submit.submissionDeadlinePassed', array('closedDate' => strftime(Config::getVar('general', 'date_format_short'), $submissionsCloseDate)));
     } else {
         $acceptingSubmissions = true;
     }
     $templateMgr->assign('acceptingSubmissions', $acceptingSubmissions);
     if (isset($notAcceptingSubmissionsMessage)) {
         $templateMgr->assign('notAcceptingSubmissionsMessage', $notAcceptingSubmissionsMessage);
     }
     $templateMgr->assign('helpTopicId', 'editorial.authorsRole.submissions');
     $templateMgr->assign('sort', $sort);
     $templateMgr->assign('sortDirection', $sortDirection);
     $templateMgr->display('author/index.tpl');
 }

 /**
  * Given a scheduled conference, set up the template with all the
  * required variables for schedConf/view.tpl to function properly.
  * @param $schedConf object The scheduled conference to display
  * 	the cover page will be displayed. Otherwise table of contents
  * 	will be displayed.
  */
 function setupTemplate(&$conference, &$schedConf)
 {
     parent::setupTemplate();
     $templateMgr =& TemplateManager::getManager();
     Locale::requireComponents(array(LOCALE_COMPONENT_OCS_MANAGER));
     // Ensure the user is entitled to view the scheduled conference...
     if (isset($schedConf) && ($conference->getEnabled() || (Validation::isDirector($conference->getId()) || Validation::isConferenceManager($conference->getId())))) {
         // Assign header and content for home page
         $templateMgr->assign('displayPageHeaderTitle', $conference->getPageHeaderTitle(true));
         $templateMgr->assign('displayPageHeaderLogo', $conference->getPageHeaderLogo(true));
         $templateMgr->assign('displayPageHeaderTitleAltText', $conference->getLocalizedSetting('homeHeaderTitleImageAltText'));
         $templateMgr->assign('displayPageHeaderLogoAltText', $conference->getLocalizedSetting('homeHeaderLogoImageAltText'));
         $templateMgr->assign_by_ref('schedConf', $schedConf);
         $templateMgr->assign('additionalHomeContent', $conference->getLocalizedSetting('additionalHomeContent'));
     } else {
         Request::redirect(null, 'index');
     }
     if ($styleFileName = $schedConf->getStyleFileName()) {
         import('file.PublicFileManager');
         $publicFileManager = new PublicFileManager();
         $templateMgr->addStyleSheet(Request::getBaseUrl() . '/' . $publicFileManager->getConferenceFilesPath($conference->getId()) . '/' . $styleFileName);
     }
 }

 function mayEditPaper(&$authorSubmission)
 {
     $schedConf =& Request::getSchedConf();
     if (!$schedConf || $schedConf->getId() != $authorSubmission->getSchedConfId()) {
         unset($schedConf);
         $schedConfDao =& DAORegistry::getDAO('SchedConfDAO');
         $schedConf =& $schedConfDao->getSchedConf($paper->getSchedConfId());
     }
     // Directors acting as Authors can always edit.
     if (Validation::isDirector($schedConf->getConferenceId(), $schedConf->getId()) || Validation::isTrackDirector($schedConf->getConferenceId(), $schedConf->getId())) {
         return true;
     }
     // Incomplete submissions can always be edited.
     if ($authorSubmission->getSubmissionProgress() != 0) {
         return true;
     }
     // Archived or declined submissions can never be edited.
     if ($authorSubmission->getStatus() == STATUS_ARCHIVED || $authorSubmission->getStatus() == STATUS_DECLINED) {
         return false;
     }
     // If the last recorded editorial decision on the current stage
     // was "Revisions Required", the author may edit the submission.
     $decisions = $authorSubmission->getDecisions($authorSubmission->getCurrentStage());
     $decision = array_shift($decisions);
     if ($decision == SUBMISSION_DIRECTOR_DECISION_PENDING_REVISIONS) {
         return true;
     }
     // If there are open reviews for the submission, it may not be edited.
     $assignments = $authorSubmission->getReviewAssignments(null);
     if (is_array($assignments)) {
         foreach ($assignments as $round => $roundAssignments) {
             if (is_array($roundAssignments)) {
                 foreach ($roundAssignments as $assignment) {
                     if (!$assignment->getCancelled() && !$assignment->getReplaced() && !$assignment->getDeclined() && $assignment->getDateCompleted() == null && $assignment->getDateNotified() != null) {
                         return false;
                     }
                 }
             }
         }
     }
     // If the conference isn't closed, the author may edit the submission.
     if (strtotime($schedConf->getEndDate()) > time()) {
         return true;
     }
     // Otherwise, edits are not allowed.
     return false;
 }

 /**
  * Validate that the user is the assigned track director for
  * the paper, or is a managing director.
  * Redirects to trackDirector index page if validation fails.
  * @param $paperId int Paper ID to validate
  * @param $access int Optional name of access level required -- see TRACK_DIRECTOR_ACCESS_... constants
  */
 function validate($request, $paperId, $access = null)
 {
     parent::validate($request);
     $isValid = true;
     $trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
     $conference =& $request->getConference();
     $schedConf =& $request->getSchedConf();
     $user =& $request->getUser();
     $trackDirectorSubmission =& $trackDirectorSubmissionDao->getTrackDirectorSubmission($paperId);
     if ($trackDirectorSubmission == null) {
         $isValid = false;
     } else {
         if ($trackDirectorSubmission->getSchedConfId() != $schedConf->getId()) {
             $isValid = false;
         } else {
             if ($trackDirectorSubmission->getDateSubmitted() == null) {
                 $isValid = false;
             } else {
                 $templateMgr =& TemplateManager::getManager();
                 // If this user isn't the submission's director, they don't have access.
                 $editAssignments =& $trackDirectorSubmission->getEditAssignments();
                 $wasFound = false;
                 foreach ($editAssignments as $editAssignment) {
                     if ($editAssignment->getDirectorId() == $user->getId()) {
                         $wasFound = true;
                     }
                 }
                 if (!$wasFound && !Validation::isDirector()) {
                     $isValid = false;
                 }
             }
         }
     }
     if (!$isValid) {
         $request->redirect(null, null, null, $request->getRequestedPage());
     }
     // If necessary, note the current date and time as the "underway" date/time
     $editAssignmentDao =& DAORegistry::getDAO('EditAssignmentDAO');
     $editAssignments =& $trackDirectorSubmission->getEditAssignments();
     foreach ($editAssignments as $editAssignment) {
         if ($editAssignment->getDirectorId() == $user->getId() && $editAssignment->getDateUnderway() === null) {
             $editAssignment->setDateUnderway(Core::getCurrentDate());
             $editAssignmentDao->updateEditAssignment($editAssignment);
         }
     }
     $this->submission =& $trackDirectorSubmission;
     return true;
 }

 /**
  * Validation check for submission.
  * Checks that paper ID is valid, if specified.
  * @param $request object
  * @param $paperId int
  * @param $step int
  */
 function validate($request, $paperId = null, $step = false)
 {
     parent::validate();
     $conference =& $request->getConference();
     $schedConf =& $request->getSchedConf();
     $paperDao =& DAORegistry::getDAO('PaperDAO');
     $user =& $request->getUser();
     if ($step !== false && ($step < 1 || $step > 5 || !isset($paperId) && $step != 1)) {
         $request->redirect(null, null, null, 'submit', array(1));
     }
     $paper = null;
     if ($paperId) {
         // Check that paper exists for this conference and user and that submission is incomplete
         $paper =& $paperDao->getPaper((int) $paperId);
         if (!$paper || $paper->getUserId() !== $user->getId() || $paper->getSchedConfId() !== $schedConf->getId()) {
             $request->redirect(null, null, null, 'submit');
         }
         if ($step !== false && $step > $paper->getSubmissionProgress()) {
             $request->redirect(null, null, null, 'submit');
         }
     } else {
         // If the paper does not exist, require that the
         // submission window be open or that this user be a
         // director or track director.
         import('classes.schedConf.SchedConfAction');
         $schedConf =& $request->getSchedConf();
         if (!$schedConf || !SchedConfAction::submissionsOpen($schedConf) && !Validation::isDirector($schedConf->getConferenceId(), $schedConf->getId()) && !Validation::isTrackDirector($schedConf->getConferenceId())) {
             $request->redirect(null, null, 'author', 'index');
         }
     }
     $this->paper =& $paper;
     return true;
 }

 /**
  * Return an instance of the template manager.
  * @param $request PKPRequest FIXME: is optional for backwards compatibility only - make mandatory
  * @return TemplateManager the template manager object
  */
 function &getManager($request = null)
 {
     $instance =& Registry::get('templateManager', true, null);
     if ($instance === null) {
         $instance = new TemplateManager($request);
     }
     $supportedLocales = AppLocale::getSupportedLocales();
     $instance->assign('supportedLocales', $supportedLocales);
     $instance->assign('localePrecedence', AppLocale::getLocalePrecedence());
     $instance->assign('requestedPage', Request::getRequestedPage());
     $instance->assign('requestedOp', Request::getRequestedOp());
     $conference =& Request::getConference();
     if (isset($conference)) {
         $instance->assign('conferenceId', $conference->getId());
         $instance->assign('isConferenceManager', Validation::isConferenceManager($conference->getId()));
         $instance->assign('analyticsTrackingID', $conference->getSetting('analyticsTrackingID'));
         $schedConf =& Request::getSchedConf();
         if (isset($schedConf)) {
             $instance->assign('isDirector', Validation::isDirector($conference->getId(), $schedConf->getId()));
             $instance->assign('isTrackDirector', Validation::isTrackDirector($conference->getId(), $schedConf->getId()));
             $instance->assign('isAuthor', Validation::isAuthor($conference->getId(), $schedConf->getId()));
             $registrationDao =& DAORegistry::getDAO('RegistrationDAO');
             $user = Request::getUser();
             if (isset($user)) {
                 $instance->assign('isRegistrationUser', $registrationDao->isValidRegistrationByUser($user->getUserId(), $schedConf->getId()));
             }
         }
     }
     AppLocale::requireComponents(array(LOCALE_COMPONENT_OCS_MANAGER, LOCALE_COMPONENT_OCS_ADMIN, LOCALE_COMPONENT_OCS_DIRECTOR, LOCALE_COMPONENT_PKP_MANAGER, LOCALE_COMPONENT_PKP_SUBMISSION));
     // FIXME: For timeline constants
     return $instance;
 }

 /**
  * Email director decision comment.
  * @param $trackDirectorSubmission object
  * @param $send boolean
  */
 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 .= Locale::translate('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";
                         }
//.........这里部分代码省略.........

 /**
  * Checks if a user has access to view papers
  * @param $schedConf object
  * @param $conference object
  * @return bool
  */
 function mayViewPapers(&$schedConf, &$conference)
 {
     if (Validation::isSiteAdmin() || Validation::isConferenceManager() || Validation::isDirector() || Validation::isTrackDirector()) {
         return true;
     }
     if (!SchedConfAction::mayViewSchedConf($schedConf)) {
         return false;
     }
     // Allow open access once the "open access" date has passed.
     $paperAccess = $conference->getSetting('paperAccess');
     if ($paperAccess == PAPER_ACCESS_OPEN) {
         return true;
     }
     if ($schedConf->getSetting('delayOpenAccess') && time() > $schedConf->getSetting('delayOpenAccessDate')) {
         if (Validation::isReader() && $paperAccess == PAPER_ACCESS_ACCOUNT_REQUIRED) {
             return true;
         }
     }
     if ($schedConf->getSetting('postPapers') && time() > $schedConf->getSetting('postPapersDate')) {
         if (SchedConfAction::registeredUser($schedConf)) {
             return true;
         }
         if (SchedConfAction::registeredDomain($schedConf)) {
             return true;
         }
     }
     return false;
 }

 /**
  * Setup common template variables.
  * @param $subclass boolean set to true if caller is below this handler in the hierarchy
  */
 function setupTemplate($request, $subclass = false, $paperId = 0, $parentPage = null)
 {
     parent::setupTemplate();
     Locale::requireComponents(array(LOCALE_COMPONENT_OCS_DIRECTOR, LOCALE_COMPONENT_PKP_SUBMISSION, LOCALE_COMPONENT_OCS_AUTHOR));
     $templateMgr =& TemplateManager::getManager();
     $isDirector = Validation::isDirector();
     $pageHierarchy = array();
     $conference =& $request->getConference();
     $schedConf =& $request->getSchedConf();
     $templateMgr->assign('helpTopicId', $isDirector ? 'editorial.directorsRole' : 'editorial.trackDirectorsRole');
     if ($schedConf) {
         $pageHierarchy[] = array($request->url(null, null, 'index'), $schedConf->getFullTitle(), true);
     } elseif ($conference) {
         $pageHierarchy[] = array($request->url(null, 'index', 'index'), $conference->getConferenceTitle(), true);
     }
     $roleSymbolic = $isDirector ? 'director' : 'trackDirector';
     $roleKey = $isDirector ? 'user.role.director' : 'user.role.trackDirector';
     $pageHierarchy[] = array($request->url(null, null, 'user'), 'navigation.user');
     $pageHierarchy[] = array($request->url(null, null, $roleSymbolic), $roleKey);
     if ($subclass) {
         $pageHierarchy[] = array($request->url(null, null, $roleSymbolic), 'paper.submissions');
     }
     import('classes.submission.trackDirector.TrackDirectorAction');
     $submissionCrumb = TrackDirectorAction::submissionBreadcrumb($paperId, $parentPage, $roleSymbolic);
     if (isset($submissionCrumb)) {
         $pageHierarchy = array_merge($pageHierarchy, $submissionCrumb);
     }
     $templateMgr->assign('pageHierarchy', $pageHierarchy);
 }

 function email($args)
 {
     $this->validate();
     $this->setupTemplate(true);
     $conference =& Request::getConference();
     $schedConf =& Request::getSchedConf();
     $templateMgr =& TemplateManager::getManager();
     $userDao =& DAORegistry::getDAO('UserDAO');
     $user =& Request::getUser();
     // See if this is the Director or Manager and an email template has been chosen
     $template = Request::getUserVar('template');
     if (!$conference || empty($template) || !Validation::isConferenceManager() && !Validation::isDirector() && !Validation::isTrackDirector()) {
         $template = null;
     }
     // Determine whether or not this account is subject to
     // email sending restrictions.
     $canSendUnlimitedEmails = Validation::isSiteAdmin();
     $unlimitedEmailRoles = array(ROLE_ID_CONFERENCE_MANAGER, ROLE_ID_DIRECTOR, ROLE_ID_TRACK_DIRECTOR);
     $roleDao =& DAORegistry::getDAO('RoleDAO');
     if ($conference) {
         $roles =& $roleDao->getRolesByUserId($user->getId(), $conference->getId());
         foreach ($roles as $role) {
             if (in_array($role->getRoleId(), $unlimitedEmailRoles)) {
                 $canSendUnlimitedEmails = true;
             }
         }
     }
     // Check when this user last sent an email, and if it's too
     // recent, make them wait.
     if (!$canSendUnlimitedEmails) {
         $dateLastEmail = $user->getDateLastEmail();
         if ($dateLastEmail && strtotime($dateLastEmail) + (int) Config::getVar('email', 'time_between_emails') > strtotime(Core::getCurrentDate())) {
             $templateMgr->assign('pageTitle', 'email.compose');
             $templateMgr->assign('message', 'email.compose.tooSoon');
             $templateMgr->assign('backLink', 'javascript:history.back()');
             $templateMgr->assign('backLinkLabel', 'email.compose');
             return $templateMgr->display('common/message.tpl');
         }
     }
     $email = null;
     if ($paperId = Request::getUserVar('paperId')) {
         // This message is in reference to a paper.
         // Determine whether the current user has access
         // to the paper in some form, and if so, use an
         // PaperMailTemplate.
         $paperDao =& DAORegistry::getDAO('PaperDAO');
         $paper =& $paperDao->getPaper($paperId);
         $hasAccess = false;
         // First, conditions where access is OK.
         // 1. User is submitter
         if ($paper && $paper->getUserId() == $user->getId()) {
             $hasAccess = true;
         }
         // 2. User is director
         $editAssignmentDao =& DAORegistry::getDAO('EditAssignmentDAO');
         $editAssignments =& $editAssignmentDao->getEditAssignmentsByPaperId($paperId);
         while ($editAssignment =& $editAssignments->next()) {
             if ($editAssignment->getDirectorId() === $user->getId()) {
                 $hasAccess = true;
             }
         }
         if (Validation::isDirector()) {
             $hasAccess = true;
         }
         // 3. User is reviewer
         $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
         foreach ($reviewAssignmentDao->getBySubmissionId($paperId) as $reviewAssignment) {
             if ($reviewAssignment->getReviewerId() === $user->getId()) {
                 $hasAccess = true;
             }
         }
         // Last, "deal-breakers" -- access is not allowed.
         if ($paper && $paper->getSchedConfId() !== $schedConf->getId()) {
             $hasAccess = false;
         }
         if ($hasAccess) {
             import('classes.mail.PaperMailTemplate');
             $email = new PaperMailTemplate($paperDao->getPaper($paperId));
         }
     }
     if ($email === null) {
         import('classes.mail.MailTemplate');
         $email = new MailTemplate();
     }
     if (Request::getUserVar('send') && !$email->hasErrors()) {
         $recipients = $email->getRecipients();
         $ccs = $email->getCcs();
         $bccs = $email->getBccs();
         // Make sure there aren't too many recipients (to
         // prevent use as a spam relay)
         $recipientCount = 0;
         if (is_array($recipients)) {
             $recipientCount += count($recipients);
         }
         if (is_array($ccs)) {
             $recipientCount += count($ccs);
         }
         if (is_array($bccs)) {
             $recipientCount += count($bccs);
         }
//.........这里部分代码省略.........