AddParticipantForm.inc.php

<?php
 
import('controllers.grid.users.stageParticipant.form.StageParticipantNotifyForm');
 
class AddParticipantForm extends StageParticipantNotifyForm {
   var $_submission;
 
   var $_assignmentId;
 
   var $_managerGroupIds;
 
   var $_possibleRecommendOnlyUserGroupIds;
 
   var $_contextId;
 
   function __construct($submission, $stageId, $assignmentId = null) {
      parent::__construct($submission->getId(), ASSOC_TYPE_SUBMISSION, $stageId, 'controllers/grid/users/stageParticipant/addParticipantForm.tpl');
      $this->_submission = $submission;
      $this->_stageId = $stageId;
      $this->_assignmentId = $assignmentId;
      $this->_contextId = $submission->getContextId();
 
      // add checks in addition to anything that the Notification form may apply.
      // FIXME: should use a custom validator to check that the userId belongs to this group.
      $this->addCheck(new FormValidator($this, 'userGroupId', 'required', 'editor.submission.addStageParticipant.form.userGroupRequired'));
      $this->addCheck(new FormValidatorPost($this));
      $this->addCheck(new FormValidatorCSRF($this));
 
      $this->initialize();
   }
 
   //
   // Getters and Setters
   //
   function getSubmission() {
      return $this->_submission;
   }
 
   function initialize() {
      $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); /* @var $userGroupDao UserGroupDAO */
 
      // assign all user group IDs with ROLE_ID_MANAGER or ROLE_ID_SUB_EDITOR
      $this->_managerGroupIds = $userGroupDao->getUserGroupIdsByRoleId(ROLE_ID_MANAGER, $this->_contextId);
      $subEditorGroupIds = $userGroupDao->getUserGroupIdsByRoleId(ROLE_ID_SUB_EDITOR, $this->_contextId);
      $this->_possibleRecommendOnlyUserGroupIds = array_merge($this->_managerGroupIds, $subEditorGroupIds);
   }
 
   protected function _isChangePermitMetadataAllowed($userGroupId) {
      return !in_array($userGroupId, $this->_managerGroupIds);
   }
 
   protected function _isChangeRecommendOnlyAllowed($userGroupId) {
      return in_array($userGroupId, $this->_possibleRecommendOnlyUserGroupIds);
   }
 
   function fetch($request, $template = null, $display = false) {
      $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); /* @var $userGroupDao UserGroupDAO */
      $userGroups = $userGroupDao->getUserGroupsByStage(
         $request->getContext()->getId(),
         $this->getStageId()
      );
 
      $userGroupOptions = array();
      while ($userGroup = $userGroups->next()) {
         // Exclude reviewers.
         if ($userGroup->getRoleId() == ROLE_ID_REVIEWER) continue;
         $userGroupOptions[$userGroup->getId()] = $userGroup->getLocalizedName();
      }
 
      $templateMgr = TemplateManager::getManager($request);
      $keys = array_keys($userGroupOptions);
      $templateMgr->assign(array(
         'userGroupOptions' => $userGroupOptions,
         'selectedUserGroupId' => array_shift($keys), // assign the first element as selected
         'possibleRecommendOnlyUserGroupIds' => $this->_possibleRecommendOnlyUserGroupIds,
         'recommendOnlyUserGroupIds' => $userGroupDao->getRecommendOnlyGroupIds($request->getContext()->getId()),
         'notPossibleEditSubmissionMetadataPermissionChange' => $this->_managerGroupIds,
         'permitMetadataEditUserGroupIds' => $userGroupDao->getPermitMetadataEditGroupIds($request->getContext()->getId()),
         'submissionId' => $this->getSubmission()->getId(),
         'userGroupId' => '',
         'userIdSelected' => '',
      ));
 
      if ($this->_assignmentId) {
         $stageAssignmentDao = DAORegistry::getDAO('StageAssignmentDAO'); /* @var $stageAssignmentDao StageAssignmentDAO */
 
         $stageAssignment = $stageAssignmentDao->getById($this->_assignmentId);
 
         $userDao = DAORegistry::getDAO('UserDAO'); /* @var $userDao UserDAO */
         $currentUser = $userDao->getById($stageAssignment->getUserId());
 
         $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); /* @var $userGroupDao UserGroupDAO */
         $userGroup = $userGroupDao->getById($stageAssignment->getUserGroupId());
 
         $templateMgr->assign(array(
            'assignmentId' => $this->_assignmentId,
            'currentUserName' => $currentUser->getFullName(),
            'currentUserGroup' => $userGroup->getLocalizedName(),
            'userGroupId' => $stageAssignment->getUserGroupId(),
            'userIdSelected' => $stageAssignment->getUserId(),
            'currentAssignmentRecommendOnly' => $stageAssignment->getRecommendOnly(),
            'currentAssignmentPermitMetadataEdit' => $stageAssignment->getCanChangeMetadata(),
            'isChangePermitMetadataAllowed' => $this->_isChangePermitMetadataAllowed($userGroup->getId()),
            'isChangeRecommendOnlyAllowed' => $this->_isChangeRecommendOnlyAllowed($userGroup->getId()),
         ));
      }
 
 
      // If submission is in review, add a list of reviewer Ids that should not be
      // assigned as participants because they have blind peer reviews in progress
      import('lib.pkp.classes.submission.reviewAssignment.ReviewAssignment');
      $blindReviewerIds = array();
      if (in_array($this->getSubmission()->getStageId(), array(WORKFLOW_STAGE_ID_INTERNAL_REVIEW, WORKFLOW_STAGE_ID_EXTERNAL_REVIEW))) {
         $blindReviewMethods = array(SUBMISSION_REVIEW_METHOD_BLIND, SUBMISSION_REVIEW_METHOD_DOUBLEBLIND);
         $reviewAssignmentDao = DAORegistry::getDAO('ReviewAssignmentDAO'); /* @var $reviewAssignmentDao ReviewAssignmentDAO */
         $reviewAssignments = $reviewAssignmentDao->getBySubmissionId($this->getSubmission()->getId());
         $blindReviews = array_filter($reviewAssignments, function($reviewAssignment) use ($blindReviewMethods) {
            return in_array($reviewAssignment->getReviewMethod(), $blindReviewMethods) && !$reviewAssignment->getDeclined();
         });
         $blindReviewerIds = array_map(function($reviewAssignment) {
            return $reviewAssignment->getReviewerId();
         }, $blindReviews);
 
      }
      $templateMgr->assign(array(
         'blindReviewerIds' => array_values(array_unique($blindReviewerIds)),
         'blindReviewerWarning' => __('editor.submission.addStageParticipant.form.reviewerWarning'),
         'blindReviewerWarningOk' => __('common.ok'),
      ));
 
      return parent::fetch($request, $template, $display);
   }
 
   function readInputData() {
      $this->readUserVars(array(
         'userGroupId',
         'userId',
         'message',
         'template',
         'recommendOnly',
         'canChangeMetadata',
      ));
   }
 
   function validate($callHooks = true) {
      $userGroupId = (int) $this->getData('userGroupId');
      $userId = (int) $this->getData('userId');
      $submission = $this->getSubmission();
 
      $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); /* @var $userGroupDao UserGroupDAO */
      return $userGroupDao->userInGroup($userId, $userGroupId) && $userGroupDao->getById($userGroupId, $submission->getContextId());
   }
 
   function execute(...$functionParams) {
      $stageAssignmentDao = DAORegistry::getDAO('StageAssignmentDAO'); 
      $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); 
      $submission = $this->getSubmission();
      $userGroupId = (int) $this->getData('userGroupId');
      $userId = (int) $this->getData('userId');
      $recommendOnly = $this->_isChangeRecommendOnlyAllowed($userGroupId) ? (boolean) $this->getData('recommendOnly') : false;
      $canChangeMetadata = $this->_isChangePermitMetadataAllowed($userGroupId) ? (boolean) $this->getData('canChangeMetadata') : true;
 
      // sanity check
      if ($userGroupDao->userGroupAssignedToStage($userGroupId, $this->getStageId())) {
         $updated = false;
 
         if ($this->_assignmentId) {
            $stageAssignment = $stageAssignmentDao->getById($this->_assignmentId);
 
            if ($stageAssignment) {
               $stageAssignment->setRecommendOnly($recommendOnly);
               $stageAssignment->setCanChangeMetadata($canChangeMetadata);
               $stageAssignmentDao->updateObject($stageAssignment);
               $updated = true;
            }
         }
 
         if (!$updated) {
            // insert the assignment
            $stageAssignment = $stageAssignmentDao->build($submission->getId(), $userGroupId, $userId, $recommendOnly, $canChangeMetadata);
         }
      }
 
      parent::execute(...$functionParams);
      return array($userGroupId, $userId, $stageAssignment->getId());
   }
 
   function isMessageRequired() {
      return false;
   }
}