<?php
/**
* @file pages/workflow/PKPWorkflowHandler.php
*
* Copyright (c) 2014-2021 Simon Fraser University
* Copyright (c) 2003-2021 John Willinsky
* Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
*
* @class PKPWorkflowHandler
*
* @ingroup pages_reviewer
*
* @brief Handle requests for the submssion workflow.
*/
namespace PKP\pages\workflow;
use APP\core\Application;
use APP\core\PageRouter;
use APP\core\Request;
use APP\core\Services;
use APP\facades\Repo;
use APP\handler\Handler;
use APP\publication\Publication;
use APP\submission\Submission;
use APP\template\TemplateManager;
use Exception;
use Illuminate\Support\Enumerable;
use PKP\components\forms\publication\PKPCitationsForm;
use PKP\components\forms\publication\PKPMetadataForm;
use PKP\components\forms\publication\PKPPublicationLicenseForm;
use PKP\components\forms\publication\TitleAbstractForm;
use PKP\components\listPanels\ContributorsListPanel;
use PKP\context\Context;
use PKP\core\JSONMessage;
use PKP\core\PKPApplication;
use PKP\core\PKPRequest;
use PKP\db\DAORegistry;
use PKP\notification\NotificationDAO;
use PKP\notification\PKPNotification;
use PKP\plugins\PluginRegistry;
use PKP\security\authorization\internal\SubmissionRequiredPolicy;
use PKP\security\authorization\internal\UserAccessibleWorkflowStageRequiredPolicy;
use PKP\security\authorization\WorkflowStageAccessPolicy;
use PKP\security\Role;
use PKP\stageAssignment\StageAssignmentDAO;
use PKP\submission\GenreDAO;
use PKP\submission\PKPSubmission;
use PKP\submission\reviewRound\ReviewRoundDAO;
use PKP\user\User;
use PKP\workflow\WorkflowStageDAO;
abstract class PKPWorkflowHandler extends Handler
{
/** @copydoc PKPHandler::_isBackendPage */
public $_isBackendPage = true;
//
// Implement template methods from PKPHandler
//
/**
* @copydoc PKPHandler::authorize()
*/
public function authorize($request, &$args, $roleAssignments)
{
/** @var PageRouter */
$router = $request->getRouter();
$operation = $router->getRequestedOp($request);
if ($operation == 'access') {
// Authorize requested submission.
$this->addPolicy(new SubmissionRequiredPolicy($request, $args, 'submissionId'));
// This policy will deny access if user has no accessible workflow stage.
// Otherwise it will build an authorized object with all accessible
// workflow stages and authorize user operation access.
$this->addPolicy(new UserAccessibleWorkflowStageRequiredPolicy($request, PKPApplication::WORKFLOW_TYPE_EDITORIAL));
$this->markRoleAssignmentsChecked();
} else {
$this->addPolicy(new WorkflowStageAccessPolicy($request, $args, $roleAssignments, 'submissionId', $this->identifyStageId($request, $args), PKPApplication::WORKFLOW_TYPE_EDITORIAL));
}
return parent::authorize($request, $args, $roleAssignments);
}
//
// Public handler methods
//
/**
* Redirect users to their most appropriate
* submission workflow stage.
*
* @param array $args
* @param PKPRequest $request
*/
public function access($args, $request)
{
$submission = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_SUBMISSION);
$currentStageId = $submission->getStageId();
$accessibleWorkflowStages = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_ACCESSIBLE_WORKFLOW_STAGES);
$workflowRoles = Application::getWorkflowTypeRoles();
$editorialWorkflowRoles = $workflowRoles[PKPApplication::WORKFLOW_TYPE_EDITORIAL];
// Get the closest workflow stage that user has an assignment.
$workingStageId = null;
for ($workingStageId = $currentStageId; $workingStageId >= WORKFLOW_STAGE_ID_SUBMISSION; $workingStageId--) {
if (isset($accessibleWorkflowStages[$workingStageId]) && array_intersect($editorialWorkflowRoles, $accessibleWorkflowStages[$workingStageId] ?? [])) {
break;
}
}
// If no stage was found, user still have access to future stages of the
// submission. Try to get the closest future workflow stage.
if ($workingStageId == null) {
for ($workingStageId = $currentStageId; $workingStageId <= WORKFLOW_STAGE_ID_PRODUCTION; $workingStageId++) {
if (isset($accessibleWorkflowStages[$workingStageId]) && array_intersect($editorialWorkflowRoles, $accessibleWorkflowStages[$workingStageId] ?? [])) {
break;
}
}
}
assert(isset($workingStageId));
$router = $request->getRouter();
$request->redirectUrl($router->url($request, null, 'workflow', 'index', [$submission->getId(), $workingStageId]));
}
/**
* Show the workflow stage, with the stage path as an #anchor.
*
* @param array $args
* @param PKPRequest $request
*/
public function index($args, $request)
{
$this->setupTemplate($request);
$templateMgr = TemplateManager::getManager($request);
$submission = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_SUBMISSION);
$requestedStageId = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_WORKFLOW_STAGE);
$submissionContext = $request->getContext();
if ($submission->getContextId() !== $submissionContext->getId()) {
$submissionContext = Services::get('context')->get($submission->getContextId());
}
$workflowStages = WorkflowStageDAO::getWorkflowStageKeysAndPaths();
$accessibleWorkflowStages = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_ACCESSIBLE_WORKFLOW_STAGES);
$workflowRoles = Application::getWorkflowTypeRoles();
$editorialWorkflowRoles = $workflowRoles[PKPApplication::WORKFLOW_TYPE_EDITORIAL];
$result = Repo::userGroup()->getCollector()
->filterByContextIds([$submission->getData('contextId')])
->getMany();
$authorUserGroups = Repo::userGroup()->getByRoleIds([Role::ROLE_ID_AUTHOR], $submission->getData('contextId'));
$workflowUserGroups = Repo::userGroup()->getByRoleIds($editorialWorkflowRoles, $submission->getData('contextId'));
// Publication tab
// Users have access to the publication tab if they are assigned to
// the active stage id or if they are assigned as an editor or if
// they are not assigned in any role and have a manager role in the
// context.
$currentStageId = $submission->getStageId();
$accessibleWorkflowStages = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_ACCESSIBLE_WORKFLOW_STAGES);
$canAccessPublication = false; // View title, metadata, etc.
$canEditPublication = Repo::submission()->canEditPublication($submission->getId(), $request->getUser()->getId());
$canAccessProduction = false; // Access to galleys and issue entry
$canPublish = false; // Ability to publish, unpublish and create versions
$canAccessEditorialHistory = false; // Access to activity log
// unassigned managers
if (!$accessibleWorkflowStages && array_intersect($this->getAuthorizedContextObject(Application::ASSOC_TYPE_USER_ROLES), [Role::ROLE_ID_MANAGER, Role::ROLE_ID_SITE_ADMIN] ?? [])) {
$canAccessProduction = true;
$canPublish = true;
$canAccessPublication = true;
$canAccessEditorialHistory = true;
} elseif (!empty($accessibleWorkflowStages[$currentStageId]) && array_intersect($editorialWorkflowRoles, $accessibleWorkflowStages[$currentStageId] ?? [])) {
$canAccessProduction = (bool) array_intersect($editorialWorkflowRoles, $accessibleWorkflowStages[WORKFLOW_STAGE_ID_PRODUCTION] ?? []);
$canAccessPublication = true;
$stageAssignmentDao = DAORegistry::getDAO('StageAssignmentDAO'); /** @var StageAssignmentDAO $stageAssignmentDao */
$result = $stageAssignmentDao->getBySubmissionAndUserIdAndStageId(
$submission->getId(),
$request->getUser()->getId(),
WORKFLOW_STAGE_ID_PRODUCTION
)->toArray();
// If they have no stage assignments, check the role they have been granted
// for the production workflow stage. An unassigned admin or manager may
// have been granted access and should be allowed to publish.
if (empty($result) && is_array($accessibleWorkflowStages[WORKFLOW_STAGE_ID_PRODUCTION])) {
$canPublish = (bool) array_intersect([Role::ROLE_ID_SITE_ADMIN, Role::ROLE_ID_MANAGER], $accessibleWorkflowStages[WORKFLOW_STAGE_ID_PRODUCTION] ?? []);
// Otherwise, check stage assignments
// "Recommend only" stage assignments can not publish
} else {
foreach ($result as $stageAssignment) {
foreach ($workflowUserGroups as $workflowUserGroup) {
if ($stageAssignment->getUserGroupId() == $workflowUserGroup->getId() &&
!$stageAssignment->getRecommendOnly()) {
$canPublish = true;
break;
}
}
}
}
}
if (!empty($accessibleWorkflowStages[$currentStageId]) && array_intersect([Role::ROLE_ID_MANAGER, Role::ROLE_ID_SITE_ADMIN, Role::ROLE_ID_SUB_EDITOR], $accessibleWorkflowStages[$currentStageId] ?? [])) {
$canAccessEditorialHistory = true;
}
/** @var GenreDAO $genreDao */
$genreDao = DAORegistry::getDAO('GenreDAO');
$genres = $genreDao->getByContextId($submission->getData('contextId'))->toArray();
$locales = $submissionContext->getSupportedSubmissionLocaleNames();
$locales = array_map(fn (string $locale, string $name) => ['key' => $locale, 'label' => $name], array_keys($locales), $locales);
$latestPublication = $submission->getLatestPublication();
$submissionApiUrl = $request->getDispatcher()->url($request, Application::ROUTE_API, $submissionContext->getData('urlPath'), 'submissions/' . $submission->getId());
$submissionFileApiUrl = $request->getDispatcher()->url($request, Application::ROUTE_API, $submissionContext->getData('urlPath'), 'submissions/' . $submission->getId() . '/files');
$latestPublicationApiUrl = $request->getDispatcher()->url($request, Application::ROUTE_API, $submissionContext->getData('urlPath'), 'submissions/' . $submission->getId() . '/publications/' . $latestPublication->getId());
$decisionUrl = $request->url(
$submissionContext->getData('urlPath'),
'decision',
'record',
$submission->getId(),
[
'decision' => '__decision__',
'reviewRoundId' => '__reviewRoundId__',
]
);
$editorialHistoryUrl = $request->getDispatcher()->url(
$request,
Application::ROUTE_COMPONENT,
null,
'informationCenter.SubmissionInformationCenterHandler',
'viewInformationCenter',
null,
['submissionId' => $submission->getId()]
);
$submissionLibraryUrl = $request->getDispatcher()->url(
$request,
Application::ROUTE_COMPONENT,
null,
'modals.documentLibrary.DocumentLibraryHandler',
'documentLibrary',
null,
['submissionId' => $submission->getId()]
);
$publishUrl = $request->getDispatcher()->url(
$request,
Application::ROUTE_COMPONENT,
null,
'modals.publish.PublishHandler',
'publish',
null,
[
'submissionId' => $submission->getId(),
'publicationId' => '__publicationId__',
]
);
$citationsForm = new PKPCitationsForm($latestPublicationApiUrl, $latestPublication);
$publicationLicenseForm = new PKPPublicationLicenseForm($latestPublicationApiUrl, $locales, $latestPublication, $submissionContext, $authorUserGroups);
$titleAbstractForm = $this->getTitleAbstractForm($latestPublicationApiUrl, $locales, $latestPublication, $submissionContext);
$authorItems = [];
foreach ($latestPublication->getData('authors') as $contributor) {
$authorItems[] = Repo::author()->getSchemaMap()->map($contributor);
}
$contributorsListPanel = $this->getContributorsListPanel(
$submission,
$submissionContext,
$locales,
$authorItems,
$canEditPublication
);
// Import constants
import('classes.components.forms.publication.PublishForm');
$templateMgr->setConstants([
'STATUS_QUEUED' => PKPSubmission::STATUS_QUEUED,
'STATUS_PUBLISHED' => PKPSubmission::STATUS_PUBLISHED,
'STATUS_DECLINED' => PKPSubmission::STATUS_DECLINED,
'STATUS_SCHEDULED' => PKPSubmission::STATUS_SCHEDULED,
'FORM_CITATIONS' => FORM_CITATIONS,
'FORM_PUBLICATION_LICENSE' => FORM_PUBLICATION_LICENSE,
'FORM_PUBLISH' => FORM_PUBLISH,
'FORM_TITLE_ABSTRACT' => FORM_TITLE_ABSTRACT,
]);
// Get the submission props without the full publication details. We'll
// retrieve just the publication information that we need separately to
// reduce the amount of data passed to the browser
$submissionProps = Repo::submission()->getSchemaMap()->summarizeWithoutPublication($submission);
// Get an array of publications
$publications = $submission->getData('publications'); /** @var Enumerable $publications */
$publicationList = $publications->map(function ($publication) {
return [
'id' => $publication->getId(),
'datePublished' => $publication->getData('datePublished'),
'status' => $publication->getData('status'),
'version' => $publication->getData('version')
];
})->values();
// Get full details of the working publication and the current publication
$mapper = Repo::publication()->getSchemaMap($submission, $authorUserGroups, $genres);
$workingPublicationProps = $mapper->map($submission->getLatestPublication());
$currentPublicationProps = $submission->getLatestPublication()->getId() === $submission->getCurrentPublication()->getId()
? $workingPublicationProps
: $mapper->map($submission->getCurrentPublication());
$state = [
'activityLogLabel' => __('submission.list.infoCenter'),
'canAccessPublication' => $canAccessPublication,
'canEditPublication' => $canEditPublication,
'components' => [
$contributorsListPanel->id => $contributorsListPanel->getConfig(),
$citationsForm->id => $citationsForm->getConfig(),
$publicationLicenseForm->id => $publicationLicenseForm->getConfig(),
$titleAbstractForm->id => $titleAbstractForm->getConfig(),
],
'currentPublication' => $currentPublicationProps,
'decisionUrl' => $decisionUrl,
'editorialHistoryUrl' => $editorialHistoryUrl,
'publicationFormIds' => [
FORM_CITATIONS,
FORM_PUBLICATION_LICENSE,
FORM_PUBLISH,
FORM_TITLE_ABSTRACT,
],
'publicationList' => $publicationList,
'publicationTabsLabel' => __('publication.version.details'),
'publishLabel' => __('publication.publish'),
'publishUrl' => $publishUrl,
'representationsGridUrl' => $this->_getRepresentationsGridUrl($request, $submission),
'schedulePublicationLabel' => __('editor.submission.schedulePublication'),
'statusLabel' => __('semicolon', ['label' => __('common.status')]),
'submission' => $submissionProps,
'submissionFileApiUrl' => $submissionFileApiUrl,
'submissionApiUrl' => $submissionApiUrl,
'submissionLibraryLabel' => __('grid.libraryFiles.submission.title'),
'submissionLibraryUrl' => $submissionLibraryUrl,
'supportsReferences' => !!$submissionContext->getData('citations'),
'unpublishConfirmLabel' => __('publication.unpublish.confirm'),
'unpublishLabel' => __('publication.unpublish'),
'unscheduleConfirmLabel' => __('publication.unschedule.confirm'),
'unscheduleLabel' => __('publication.unschedule'),
'versionLabel' => __('semicolon', ['label' => __('admin.version')]),
'versionConfirmTitle' => __('publication.createVersion'),
'versionConfirmMessage' => __('publication.version.confirm'),
'workingPublication' => $workingPublicationProps,
];
// Add the metadata form if one or more metadata fields are enabled
$vocabSuggestionUrlBase = $request->getDispatcher()->url($request, PKPApplication::ROUTE_API, $submissionContext->getData('urlPath'), 'vocabs', null, null, ['vocab' => '__vocab__']);
$metadataForm = new PKPMetadataForm($latestPublicationApiUrl, $locales, $latestPublication, $submissionContext, $vocabSuggestionUrlBase, true);
$metadataFormConfig = $metadataForm->getConfig();
$metadataEnabled = count($metadataForm->fields);
if ($metadataEnabled) {
$templateMgr->setConstants([
'FORM_METADATA' => FORM_METADATA,
]);
$state['components'][FORM_METADATA] = $metadataFormConfig;
$state['publicationFormIds'][] = FORM_METADATA;
}
// Add the identifiers form if one or more identifier is enabled
$identifiersEnabled = false;
$pubIdPlugins = PluginRegistry::getPlugins('pubIds');
foreach ($pubIdPlugins as $pubIdPlugin) {
if ($pubIdPlugin->isObjectTypeEnabled('Publication', $request->getContext()->getId())) {
$identifiersEnabled = true;
break;
}
}
if ($identifiersEnabled) {
$identifiersForm = new \PKP\components\forms\publication\PKPPublicationIdentifiersForm($latestPublicationApiUrl, $locales, $latestPublication, $submissionContext);
$templateMgr->setConstants([
'FORM_PUBLICATION_IDENTIFIERS' => FORM_PUBLICATION_IDENTIFIERS,
]);
$state['components'][FORM_PUBLICATION_IDENTIFIERS] = $identifiersForm->getConfig();
$state['publicationFormIds'][] = FORM_PUBLICATION_IDENTIFIERS;
}
// Add the revision decision/recommendation forms if this app supports a review stage
if (count(array_intersect([WORKFLOW_STAGE_ID_INTERNAL_REVIEW, WORKFLOW_STAGE_ID_EXTERNAL_REVIEW], Application::getApplicationStages() ?? []))) {
$selectRevisionDecisionForm = new \PKP\components\forms\decision\SelectRevisionDecisionForm();
$selectRevisionRecommendationForm = new \PKP\components\forms\decision\SelectRevisionRecommendationForm();
$state['components'][$selectRevisionDecisionForm->id] = $selectRevisionDecisionForm->getConfig();
$state['components'][$selectRevisionRecommendationForm->id] = $selectRevisionRecommendationForm->getConfig();
$templateMgr->setConstants([
'FORM_SELECT_REVISION_DECISION' => FORM_SELECT_REVISION_DECISION,
'FORM_SELECT_REVISION_RECOMMENDATION' => FORM_SELECT_REVISION_RECOMMENDATION,
]);
}
$templateMgr->setState($state);
$templateMgr->assign([
'canAccessEditorialHistory' => $canAccessEditorialHistory,
'canAccessPublication' => $canAccessPublication,
'canEditPublication' => $canEditPublication,
'canAccessProduction' => $canAccessProduction,
'canPublish' => $canPublish,
'identifiersEnabled' => $identifiersEnabled,
'metadataEnabled' => $metadataEnabled,
'pageComponent' => 'WorkflowPage',
'pageTitle' => implode(__('common.titleSeparator'), array_filter([
$submission->getLatestPublication()->getShortAuthorString(),
$submission->getLocalizedTitle()
])),
'pageWidth' => TemplateManager::PAGE_WIDTH_WIDE,
'requestedStageId' => $requestedStageId,
'submission' => $submission,
'workflowStages' => $workflowStages,
]);
$this->setupIndex($request);
$templateMgr->display('workflow/workflow.tpl');
}
/**
* Show the submission stage.
*
* @param array $args
* @param PKPRequest $request
*/
public function submission($args, $request)
{
$this->_redirectToIndex($args, $request);
}
/**
* Show the external review stage.
*
* @param array $args
* @param PKPRequest $request
*/
public function externalReview($args, $request)
{
$this->_redirectToIndex($args, $request);
}
/**
* Show the editorial stage
*
* @param PKPRequest $request
* @param array $args
*/
public function editorial($args, $request)
{
$this->_redirectToIndex($args, $request);
}
/**
* Show the production stage
*
* @param PKPRequest $request
* @param array $args
*/
public function production($args, $request)
{
$this->_redirectToIndex($args, $request);
}
/**
* Redirect all old stage paths to index
*
* @param array $args
* @param PKPRequest $request
*/
protected function _redirectToIndex($args, $request)
{
// Translate the operation to a workflow stage identifier.
$submission = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_SUBMISSION);
$router = $request->getRouter();
$workflowPath = $router->getRequestedOp($request);
$stageId = WorkflowStageDAO::getIdFromPath($workflowPath);
$request->redirectUrl($router->url($request, null, 'workflow', 'index', [$submission->getId(), $stageId]));
}
/**
* Fetch JSON-encoded editor decision options.
*
* @param array $args
* @param Request $request
*
* @return JSONMessage JSON object
*/
public function editorDecisionActions($args, $request)
{
$this->setupTemplate($request);
$reviewRoundId = (int) $request->getUserVar('reviewRoundId');
// Prepare the action arguments.
$submission = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_SUBMISSION);
$stageId = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_WORKFLOW_STAGE);
$actionArgs = [
'submissionId' => $submission->getId(),
'stageId' => (int) $stageId,
];
// If a review round was specified, include it in the args;
// must also check that this is the last round or decisions
// cannot be recorded.
$reviewRound = null;
if ($reviewRoundId) {
$actionArgs['reviewRoundId'] = $reviewRoundId;
$reviewRoundDao = DAORegistry::getDAO('ReviewRoundDAO'); /** @var ReviewRoundDAO $reviewRoundDao */
$lastReviewRound = $reviewRoundDao->getLastReviewRoundBySubmissionId($submission->getId(), $stageId);
$reviewRound = $reviewRoundDao->getById($reviewRoundId);
} else {
$lastReviewRound = null;
}
// If there is an editor assigned, retrieve stage decisions.
$stageAssignmentDao = DAORegistry::getDAO('StageAssignmentDAO'); /** @var StageAssignmentDAO $stageAssignmentDao */
$editorsStageAssignments = $stageAssignmentDao->getEditorsAssignedToStage($submission->getId(), $stageId);
$user = $request->getUser();
$makeRecommendation = $makeDecision = false;
// if the user is assigned several times in an editorial role, check his/her assignments permissions i.e.
// if the user is assigned with both possibilities: to only recommend as well as make decision
foreach ($editorsStageAssignments as $editorsStageAssignment) {
if ($editorsStageAssignment->getUserId() == $user->getId()) {
if (!$editorsStageAssignment->getRecommendOnly()) {
$makeDecision = true;
} else {
$makeRecommendation = true;
}
}
}
// If user is not assigned to the submission,
// see if the user is manager, and
// if the group is recommendOnly
if (!$makeRecommendation && !$makeDecision) {
$userGroups = Repo::userGroup()->userUserGroups($user->getId(), $request->getContext()->getId());
foreach ($userGroups as $userGroup) {
if (in_array($userGroup->getRoleId(), [Role::ROLE_ID_MANAGER, Role::ROLE_ID_SITE_ADMIN])) {
if (!$userGroup->getRecommendOnly()) {
$makeDecision = true;
} else {
$makeRecommendation = true;
}
}
}
}
// if the user can make recommendations, check whether there are any decisions that can be made given
// the stage that we are operating into.
$isOnlyRecommending = $makeRecommendation && !$makeDecision;
if ($isOnlyRecommending) {
$recommendatorsAvailableDecisions = Repo::decision()
->getDecisionTypesMadeByRecommendingUsers($stageId);
if (!empty($recommendatorsAvailableDecisions)) {
// If there are any, then the user can be considered a decision user.
$makeDecision = true;
}
}
$lastRecommendation = null;
$allRecommendations = null;
$hasDecidingEditors = false;
if (!empty($editorsStageAssignments) && (!$reviewRoundId || ($lastReviewRound && $reviewRoundId == $lastReviewRound->getId()))) {
// If this is a review stage and the user has "recommend only role"
if (($stageId == WORKFLOW_STAGE_ID_EXTERNAL_REVIEW || $stageId == WORKFLOW_STAGE_ID_INTERNAL_REVIEW)) {
if ($makeRecommendation) {
// Get the made editorial decisions from the current user
$editorDecisions = Repo::decision()->getCollector()
->filterBySubmissionIds([$submission->getId()])
->filterByStageIds([$stageId])
->filterByReviewRoundIds([$reviewRound->getId()])
->filterByEditorIds([$user->getId()])
->getMany();
// Get the last recommendation
foreach ($editorDecisions as $editorDecision) {
if (Repo::decision()->isRecommendation($editorDecision->getData('decision'))) {
if ($lastRecommendation) {
if ($editorDecision->getData('dateDecided') >= $lastRecommendation->getData('dateDecided')) {
$lastRecommendation = $editorDecision;
}
} else {
$lastRecommendation = $editorDecision;
}
}
}
if ($lastRecommendation) {
$lastRecommendation = $this->getRecommendationLabel($lastRecommendation->getData('decision'));
}
// At least one deciding editor must be assigned before a recommendation can be made
/** @var StageAssignmentDAO $stageAssignmentDao */
$stageAssignmentDao = DAORegistry::getDAO('StageAssignmentDAO');
$decidingEditorIds = $stageAssignmentDao->getDecidingEditorIds($submission->getId(), $stageId);
$hasDecidingEditors = count($decidingEditorIds) > 0;
} elseif ($makeDecision) {
// Get the made editorial decisions from all users
$editorDecisions = Repo::decision()
->getCollector()
->filterBySubmissionIds([$submission->getId()])
->filterByStageIds([$stageId])
->filterByReviewRoundIds([$reviewRound->getId()])
->getMany();
// Get all recommendations
$recommendations = [];
foreach ($editorDecisions as $editorDecision) {
if (Repo::decision()->isRecommendation($editorDecision->getData('decision'))) {
if (array_key_exists($editorDecision->getData('editorId'), $recommendations)) {
if ($editorDecision->getData('dateDecided') >= $recommendations[$editorDecision->getData('editorId')]['dateDecided']) {
$recommendations[$editorDecision->getData('editorId')] = ['dateDecided' => $editorDecision->getData('dateDecided'), 'decision' => $editorDecision->getData('decision')];
}
} else {
$recommendations[$editorDecision->getData('editorId')] = ['dateDecided' => $editorDecision->getData('dateDecided'), 'decision' => $editorDecision->getData('decision')];
}
}
}
$allRecommendations = [];
foreach ($recommendations as $recommendation) {
$allRecommendations[] = $this->getRecommendationLabel($recommendation['decision']);
}
$allRecommendations = join(__('common.commaListSeparator'), $allRecommendations);
}
}
}
$hasSubmissionPassedThisStage = $submission->getStageId() > $stageId;
$lastDecision = null;
switch ($submission->getStatus()) {
case PKPSubmission::STATUS_QUEUED:
switch ($stageId) {
case WORKFLOW_STAGE_ID_SUBMISSION:
if ($hasSubmissionPassedThisStage) {
$lastDecision = 'editor.submission.workflowDecision.submission.underReview';
}
break;
case WORKFLOW_STAGE_ID_INTERNAL_REVIEW:
case WORKFLOW_STAGE_ID_EXTERNAL_REVIEW:
if ($reviewRoundId < $lastReviewRound->getId()) {
$lastDecision = 'editor.submission.workflowDecision.submission.reviewRound';
} elseif ($hasSubmissionPassedThisStage) {
$lastDecision = 'editor.submission.workflowDecision.submission.accepted';
}
break;
case WORKFLOW_STAGE_ID_EDITING:
if ($hasSubmissionPassedThisStage) {
$lastDecision = 'editor.submission.workflowDecision.submission.production';
}
break;
}
break;
case PKPSubmission::STATUS_PUBLISHED:
$lastDecision = 'editor.submission.workflowDecision.submission.published';
break;
case PKPSubmission::STATUS_DECLINED:
$lastDecision = 'editor.submission.workflowDecision.submission.declined';
break;
}
$canRecordDecision =
// Only allow decisions to be recorded on the submission's current stage
$submission->getData('stageId') == $stageId
// Only allow decisions on the latest review round
&& (!$lastReviewRound || $lastReviewRound->getId() == $reviewRoundId)
// At least one deciding editor must be assigned to make a recommendation
&& ($makeDecision || $hasDecidingEditors);
$decisions = $this->getStageDecisionTypes($stageId);
if ($isOnlyRecommending) {
$decisions = Repo::decision()
->getDecisionTypesMadeByRecommendingUsers($stageId);
}
// Assign the actions to the template.
$templateMgr = TemplateManager::getManager($request);
$templateMgr->assign([
'canRecordDecision' => $canRecordDecision,
'decisions' => $decisions,
'recommendations' => $this->getStageRecommendationTypes($stageId),
'primaryDecisions' => $this->getPrimaryDecisionTypes(),
'warnableDecisions' => $this->getWarnableDecisionTypes(),
'editorsAssigned' => count($editorsStageAssignments) > 0,
'stageId' => $stageId,
'reviewRoundId' => $reviewRound
? $reviewRound->getId()
: null,
'lastDecision' => $lastDecision,
'lastReviewRound' => $lastReviewRound,
'submission' => $submission,
'makeRecommendation' => $makeRecommendation,
'makeDecision' => $makeDecision,
'lastRecommendation' => $lastRecommendation,
'allRecommendations' => $allRecommendations,
]);
return $templateMgr->fetchJson('workflow/editorialLinkActions.tpl');
}
/**
* Fetch the JSON-encoded submission progress bar.
*
* @param array $args
* @param Request $request
*
* @return JSONMessage JSON object
*/
public function submissionProgressBar($args, $request)
{
$this->setupTemplate($request);
$submission = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_SUBMISSION);
$workflowStages = WorkflowStageDAO::getWorkflowStageKeysAndPaths();
$templateMgr = TemplateManager::getManager($request);
$templateMgr->assign([
'submission' => $submission,
'currentStageId' => $this->identifyStageId($request, $args),
'workflowStages' => $workflowStages,
]);
return $templateMgr->fetchJson('workflow/submissionProgressBar.tpl');
}
/**
* Placeholder method to be overridden by apps in order to add
* app-specific data to the template
*
* @param Request $request
*/
public function setupIndex($request)
{
}
//
// Protected helper methods
//
/**
* Translate the requested operation to a stage id.
*
* @param Request $request
* @param array $args
*
* @return int One of the WORKFLOW_STAGE_* constants.
*/
protected function identifyStageId($request, $args)
{
if ($stageId = $request->getUserVar('stageId')) {
return (int) $stageId;
}
// Maintain the old check for previous path urls
$router = $request->getRouter();
$workflowPath = $router->getRequestedOp($request);
$stageId = WorkflowStageDAO::getIdFromPath($workflowPath);
if ($stageId) {
return $stageId;
}
// Finally, retrieve the requested operation, if the stage id is
// passed in via an argument in the URL, like index/submissionId/stageId
$stageId = $args[1];
// Translate the operation to a workflow stage identifier.
assert(WorkflowStageDAO::getPathFromId($stageId) !== null);
return $stageId;
}
/**
* Determine if a particular stage has a notification pending. If so, return true.
* This is used to set the CSS class of the submission progress bar.
*
* @param User $user
* @param int $stageId
* @param int $contextId
*
* @return bool
*/
protected function notificationOptionsByStage($user, $stageId, $contextId)
{
$submission = $this->getAuthorizedContextObject(Application::ASSOC_TYPE_SUBMISSION);
$notificationDao = DAORegistry::getDAO('NotificationDAO'); /** @var NotificationDAO $notificationDao */
$editorAssignmentNotificationType = $this->getEditorAssignmentNotificationTypeByStageId($stageId);
$editorAssignments = $notificationDao->getByAssoc(Application::ASSOC_TYPE_SUBMISSION, $submission->getId(), null, $editorAssignmentNotificationType, $contextId);
// if the User has assigned TASKs in this stage check, return true
if ($editorAssignments->next()) {
return true;
}
// check for more specific notifications on those stages that have them.
if ($stageId == WORKFLOW_STAGE_ID_PRODUCTION) {
$submissionApprovalNotification = $notificationDao->getByAssoc(Application::ASSOC_TYPE_SUBMISSION, $submission->getId(), null, PKPNotification::NOTIFICATION_TYPE_APPROVE_SUBMISSION, $contextId);
if ($submissionApprovalNotification->next()) {
return true;
}
}
return false;
}
/**
* Get a label for a recommendation decision type
*/
protected function getRecommendationLabel(int $decision): string
{
$decisionType = Repo::decision()->getDecisionType($decision);
if (!$decisionType || !method_exists($decisionType, 'getRecommendationLabel')) {
throw new Exception('Could not find label for unknown recommendation type.');
}
return $decisionType->getRecommendationLabel();
}
/**
* Get the contributor list panel
*/
protected function getContributorsListPanel(Submission $submission, Context $context, array $locales, array $authorItems, bool $canEditPublication): ContributorsListPanel
{
return new ContributorsListPanel(
'contributors',
__('publication.contributors'),
$submission,
$context,
$locales,
$authorItems,
$canEditPublication
);
}
//
// Abstract protected methods.
//
/**
* Return the editor assignment notification type based on stage id.
*
* @param int $stageId
*
* @return int
*/
abstract protected function getEditorAssignmentNotificationTypeByStageId($stageId);
/**
* Get the URL for the galley/publication formats grid with a placeholder for
* the publicationId value
*
* @param Request $request
* @param Submission $submission
*
* @return string
*/
abstract protected function _getRepresentationsGridUrl($request, $submission);
/**
* A helper method to get a list of editor decisions to
* show on the right panel of each stage
*
* @return string[]
*/
abstract protected function getStageDecisionTypes(int $stageId): array;
/**
* A helper method to get a list of editor recommendations to
* show on the right panel of the review stage
*
*/
abstract protected function getStageRecommendationTypes(int $stageId): array;
/**
* Get the editor decision types that should be shown
* as primary buttons (eg - Accept)
*
* @return string[]
*/
abstract protected function getPrimaryDecisionTypes(): array;
/**
* Get the editor decision types that should be shown
* as warnable buttons (eg - Decline)
*
* @return string[]
*/
abstract protected function getWarnableDecisionTypes(): array;
/**
* Get the form for entering the title/abstract details
*/
abstract protected function getTitleAbstractForm(string $latestPublicationApiUrl, array $locales, Publication $latestPublication, Context $context): TitleAbstractForm;
}
|