Merge branch 'sendReminderAreaModerators-711' into 'stable-3_3_0'

Adiciona envio de lembretes a moderadores de área no envio manual See merge request softwares-pkp/plugins_ojs/scieloModerationStages!22
lepidus · Oct 30, 2024 · 2b5a20f · 2b5a20f
2 parents 294afbf + 16becbd
commit 2b5a20f
Show file tree

Hide file tree

Showing 14 changed files with 406 additions and 84 deletions.
diff --git a/classes/ModerationReminderEmailBuilder.inc.php b/classes/ModerationReminderEmailBuilder.inc.php
@@ -1,39 +1,58 @@
 <?php
 
 import('lib.pkp.classes.mail.Mail');
+import('plugins.generic.scieloModerationStages.classes.ModerationStageDAO');
+
+define('REMINDER_TYPE_PRE_MODERATION', 'preModeration');
+define('REMINDER_TYPE_AREA_MODERATION', 'areaModeration');
 
 class ModerationReminderEmailBuilder
 {
     private $context;
     private $moderator;
     private $submissions;
     private $locale;
-    private $preModerationTimeLimit;
+    private $reminderType;
+    private $moderationTimeLimit;
+    private $moderationStageDao;
 
-    public function __construct($context, $moderator, $submissions, $locale, $preModerationTimeLimit)
+    public function __construct($context, $moderator, $submissions, $locale, $reminderType, $moderationTimeLimit)
     {
         $this->context = $context;
         $this->moderator = $moderator;
         $this->submissions = $submissions;
         $this->locale = $locale;
-        $this->preModerationTimeLimit = $preModerationTimeLimit;
+        $this->reminderType = $reminderType;
+        $this->moderationTimeLimit = $moderationTimeLimit;
+
+        $this->moderationStageDao = new ModerationStageDAO();
+    }
+
+    public function setModerationStageDao($moderationStageDao)
+    {
+        $this->moderationStageDao = $moderationStageDao;
+    }
+    public function setReminderType($reminderType)
+    {
+        $this->reminderType = $reminderType;
     }
 
     public function buildEmail(): Mail
     {
+        $reminderTemplateName = ($this->reminderType == REMINDER_TYPE_PRE_MODERATION ? 'preModerationReminder' : 'areaModerationReminder');
         $email = new Mail();
 
         $email->setFrom($this->context->getContactEmail(), $this->context->getContactName());
         $email->addRecipient($this->moderator->getEmail(), $this->moderator->getFullName());
         $email->addCc($this->context->getContactEmail(), $this->context->getContactName());
 
-        $email->setSubject(__('plugins.generic.scieloModerationStages.emails.moderationReminder.subject', [], $this->locale));
+        $email->setSubject(__("plugins.generic.scieloModerationStages.emails.$reminderTemplateName.subject", [], $this->locale));
 
         $bodyParams = [
             'moderatorName' => $this->moderator->getFullName(),
             'submissions' => $this->getSubmissionsString()
         ];
-        $email->setBody(__('plugins.generic.scieloModerationStages.emails.moderationReminder.body', $bodyParams, $this->locale));
+        $email->setBody(__("plugins.generic.scieloModerationStages.emails.$reminderTemplateName.body", $bodyParams, $this->locale));
 
         return $email;
     }
@@ -58,21 +77,27 @@ private function getSubmissionsString(): string
     private function getSubmissionDaysString($submission): string
     {
         $dateSubmitted = new DateTime($submission->getData('dateSubmitted'));
+        $dateModeratorAssigned = new DateTime($this->moderationStageDao->getDateOfUserAssignment($this->moderator->getId(), $submission->getId()));
+
         $today = new DateTime();
-        $daysBetween = (int) $today->diff($dateSubmitted)->format('%a');
+        $daysSinceSubmission = (int) $today->diff($dateSubmitted)->format('%a');
+        $daysSinceAssignment = (int) $today->diff($dateModeratorAssigned)->format('%a');
 
-        if ($daysBetween < 1) {
+        if ($daysSinceSubmission < 1) {
             return __('plugins.generic.scieloModerationStages.submissionMade.lessThanADayAgo', [], $this->locale);
         }
 
-        if ($daysBetween == 1) {
+        if ($daysSinceSubmission == 1) {
             return __('plugins.generic.scieloModerationStages.submissionMade.aDayAgo', [], $this->locale);
         }
 
-        if ($daysBetween > $this->preModerationTimeLimit) {
-            return __('plugins.generic.scieloModerationStages.submissionMade.nDaysAgo.bold', ['numberOfDays' => $daysBetween], $this->locale);
+        if (
+            ($this->reminderType == REMINDER_TYPE_PRE_MODERATION && $daysSinceSubmission > $this->moderationTimeLimit)
+            || ($this->reminderType == REMINDER_TYPE_AREA_MODERATION && $daysSinceAssignment > $this->moderationTimeLimit)
+        ) {
+            return __('plugins.generic.scieloModerationStages.submissionMade.nDaysAgo.bold', ['numberOfDays' => $daysSinceSubmission], $this->locale);
         }
 
-        return __('plugins.generic.scieloModerationStages.submissionMade.nDaysAgo.regular', ['numberOfDays' => $daysBetween], $this->locale);
+        return __('plugins.generic.scieloModerationStages.submissionMade.nDaysAgo.regular', ['numberOfDays' => $daysSinceSubmission], $this->locale);
     }
 }
diff --git a/classes/ModerationReminderHelper.inc.php b/classes/ModerationReminderHelper.inc.php
@@ -17,20 +17,29 @@ public function setModerationStageDao($moderationStageDao)
     }
 
     public function getResponsiblesUserGroup(int $contextId)
+    {
+        return $this->getUserGroupByAbbrev($contextId, 'resp');
+    }
+
+    public function getAreaModeratorsUserGroup(int $contextId)
+    {
+        return $this->getUserGroupByAbbrev($contextId, 'am');
+    }
+
+    private function getUserGroupByAbbrev(int $contextId, string $abbrev)
     {
         $userGroupDao = DAORegistry::getDAO('UserGroupDAO');
         $contextUserGroups = $userGroupDao->getByContextId($contextId)->toArray();
 
         foreach ($contextUserGroups as $userGroup) {
             $userGroupAbbrev = strtolower($userGroupDao->getSetting($userGroup->getId(), 'abbrev', 'en_US'));
 
-            if ($userGroupAbbrev === 'resp') {
-                $responsiblesUserGroup = $userGroup;
-                break;
+            if ($userGroupAbbrev === $abbrev) {
+                return $userGroup;
             }
         }
 
-        return $responsiblesUserGroup;
+        return null;
     }
 
     public function mapUsersAndSubmissions($users, $assignments)

diff --git a/classes/ModerationStageDAO.inc.php b/classes/ModerationStageDAO.inc.php
@@ -73,4 +73,15 @@ public function getAssignmentsByUserGroupAndModerationStage(int $userGroupId, in
 
         return $assignments;
     }
+
+    public function getDateOfUserAssignment(int $userId, int $submissionId): ?string
+    {
+        $result = Capsule::table('stage_assignments AS sa')
+            ->where('user_id', $userId)
+            ->where('submission_id', $submissionId)
+            ->select('date_assigned')
+            ->first();
+
+        return $result ? get_object_vars($result)['date_assigned'] : null;
+    }
 }
diff --git a/classes/tasks/SendModerationReminders.inc.php b/classes/tasks/SendModerationReminders.inc.php
@@ -38,7 +38,14 @@ public function executeActions()
 
         foreach ($mapModeratorsAndOverdueSubmissions as $userId => $submissions) {
             $moderator = DAORegistry::getDAO('UserDAO')->getById($userId);
-            $moderationReminderEmailBuilder = new ModerationReminderEmailBuilder($context, $moderator, $submissions, $locale, $preModerationTimeLimit);
+            $moderationReminderEmailBuilder = new ModerationReminderEmailBuilder(
+                $context,
+                $moderator,
+                $submissions,
+                $locale,
+                REMINDER_TYPE_PRE_MODERATION,
+                $preModerationTimeLimit
+            );
 
             $reminderEmail = $moderationReminderEmailBuilder->buildEmail();
             $reminderEmail->send();

diff --git a/controllers/ScieloModerationStagesHandler.inc.php b/controllers/ScieloModerationStagesHandler.inc.php
@@ -14,15 +14,27 @@ class ScieloModerationStagesHandler extends Handler
 
     public function getReminderBody($args, $request)
     {
-        $responsiblesUserGroupId = (int) $args['responsiblesUserGroup'];
-        $responsible = DAORegistry::getDAO('UserDAO')->getById((int) $args['responsible']);
+        $userGroupId = (int) $args['userGroup'];
+        $role = $args['role'];
+        $userToRemind = DAORegistry::getDAO('UserDAO')->getById((int) $args['user']);
+
         $context = $request->getContext();
+        $locale = AppLocale::getLocale();
+        $plugin = PluginRegistry::getPlugin('generic', 'scielomoderationstagesplugin');
+
+        if ($role == REMINDER_TYPE_PRE_MODERATION) {
+            $moderationStage = SCIELO_MODERATION_STAGE_CONTENT;
+            $moderationTimeLimit = $plugin->getSetting($context->getId(), 'preModerationTimeLimit');
+        } elseif ($role == REMINDER_TYPE_AREA_MODERATION) {
+            $moderationStage = SCIELO_MODERATION_STAGE_AREA;
+            $moderationTimeLimit = $plugin->getSetting($context->getId(), 'areaModerationTimeLimit');
+        }
 
         $moderationStageDao = new ModerationStageDAO();
         $assignments = $moderationStageDao->getAssignmentsByUserGroupAndModerationStage(
-            $responsiblesUserGroupId,
-            SCIELO_MODERATION_STAGE_CONTENT,
-            $responsible->getId()
+            $userGroupId,
+            $moderationStage,
+            $userToRemind->getId()
         );
 
         $submissions = [];
@@ -35,11 +47,14 @@ public function getReminderBody($args, $request)
             }
         }
 
-        $locale = AppLocale::getLocale();
-        $plugin = PluginRegistry::getPlugin('generic', 'scielomoderationstagesplugin');
-        $preModerationTimeLimit = $plugin->getSetting($context->getId(), 'preModerationTimeLimit');
-
-        $moderationReminderEmailBuilder = new ModerationReminderEmailBuilder($context, $responsible, $submissions, $locale, $preModerationTimeLimit);
+        $moderationReminderEmailBuilder = new ModerationReminderEmailBuilder(
+            $context,
+            $userToRemind,
+            $submissions,
+            $locale,
+            $role,
+            $moderationTimeLimit
+        );
         $reminderEmail = $moderationReminderEmailBuilder->buildEmail();
 
         return json_encode(['reminderBody' => $reminderEmail->getBody()]);

diff --git a/form/ScieloModerationStagesSettingsForm.inc.php b/form/ScieloModerationStagesSettingsForm.inc.php
@@ -6,6 +6,7 @@ class ScieloModerationStagesSettingsForm extends Form
 {
     public const CONFIG_VARS = array(
         'preModerationTimeLimit' => 'int',
+        'areaModerationTimeLimit' => 'int'
     );
 
     public $contextId;
@@ -20,6 +21,9 @@ public function __construct($plugin, $contextId)
         $this->addCheck(new FormValidatorCustom($this, 'preModerationTimeLimit', 'required', 'plugins.generic.scieloModerationStages.settings.timeLimitError', function ($timeLimit) {
             return is_numeric($timeLimit) && intval($timeLimit) > 0;
         }));
+        $this->addCheck(new FormValidatorCustom($this, 'areaModerationTimeLimit', 'required', 'plugins.generic.scieloModerationStages.settings.timeLimitError', function ($timeLimit) {
+            return is_numeric($timeLimit) && intval($timeLimit) > 0;
+        }));
     }
 
     public function initData()

diff --git a/form/SendModerationReminderForm.inc.php b/form/SendModerationReminderForm.inc.php
@@ -18,50 +18,76 @@ public function __construct($plugin, $contextId)
         parent::__construct($plugin->getTemplateResource('sendModerationReminderForm.tpl'));
     }
 
-    private function getResponsiblesUserGroupId(int $contextId): int
+    private function getResponsiblesUserGroupId($contextId)
     {
         $moderationReminderHelper = new ModerationReminderHelper();
         $responsiblesUserGroup = $moderationReminderHelper->getResponsiblesUserGroup($contextId);
 
-        return $responsiblesUserGroup->getId();
+        return ($responsiblesUserGroup ? $responsiblesUserGroup->getId() : null);
     }
 
-    private function getResponsibles(int $responsiblesUserGroupId): array
+    private function getAreaModeratorsUserGroupId($contextId)
+    {
+        $moderationReminderHelper = new ModerationReminderHelper();
+        $areaModeratorsUserGroup = $moderationReminderHelper->getAreaModeratorsUserGroup($contextId);
+
+        return ($areaModeratorsUserGroup ? $areaModeratorsUserGroup->getId() : null);
+    }
+
+    private function getUsersAssignedByGroupAndModerationStage(int $userGroupId, int $moderationStage): array
     {
         $moderationStageDao = new ModerationStageDAO();
-        $responsibleAssignments = $moderationStageDao->getAssignmentsByUserGroupAndModerationStage(
-            $responsiblesUserGroupId,
-            SCIELO_MODERATION_STAGE_CONTENT
+        $userAssignments = $moderationStageDao->getAssignmentsByUserGroupAndModerationStage(
+            $userGroupId,
+            $moderationStage
         );
 
-        if (empty($responsibleAssignments)) {
+        if (empty($userAssignments)) {
             return [];
         }
 
-        $responsibles = [null => null];
+        $usersAssigned = [null => null];
         $userDao = DAORegistry::getDAO('UserDAO');
-        foreach ($responsibleAssignments as $assignment) {
+        foreach ($userAssignments as $assignment) {
             $user = $userDao->getById($assignment['userId']);
-            $fullName = $user->getFullName();
-            $responsibles[$user->getId()] = $fullName;
+            $usersAssigned[$user->getId()] = $user->getFullName();
         }
 
-        asort($responsibles, SORT_STRING);
+        asort($usersAssigned, SORT_STRING);
 
-        return $responsibles;
+        return $usersAssigned;
     }
 
     public function fetch($request, $template = null, $display = false)
     {
         $templateMgr = TemplateManager::getManager($request);
         $contextId = $request->getContext()->getId();
 
+        $roles = [
+            REMINDER_TYPE_PRE_MODERATION => __('plugins.generic.scieloModerationStages.sendModerationReminder.responsible.title'),
+            REMINDER_TYPE_AREA_MODERATION => __('plugins.generic.scieloModerationStages.sendModerationReminder.areaModerator.title')
+        ];
+
         $responsiblesUserGroupId = $this->getResponsiblesUserGroupId($contextId);
-        $responsibles = $this->getResponsibles($responsiblesUserGroupId);
+        if (!is_null($responsiblesUserGroupId)) {
+            $responsibles = $this->getUsersAssignedByGroupAndModerationStage($responsiblesUserGroupId, SCIELO_MODERATION_STAGE_CONTENT);
+            $templateMgr->assign([
+                'responsiblesUserGroupId' => $responsiblesUserGroupId,
+                'responsibles' => $responsibles
+            ]);
+        }
+
+        $areaModeratorsUserGroupId = $this->getAreaModeratorsUserGroupId($contextId);
+        if (!is_null($areaModeratorsUserGroupId)) {
+            $areaModerators = $this->getUsersAssignedByGroupAndModerationStage($areaModeratorsUserGroupId, SCIELO_MODERATION_STAGE_AREA);
+            $templateMgr->assign([
+                'areaModeratorsUserGroupId' => $areaModeratorsUserGroupId,
+                'areaModerators' => $areaModerators
+            ]);
+        }
 
         $templateMgr->assign([
-            'responsiblesUserGroupId' => $responsiblesUserGroupId,
-            'responsibles' => $responsibles,
+            'roles' => $roles,
             'pluginName' => $this->plugin->getName(),
             'applicationName' => Application::get()->getName()
         ]);
@@ -71,21 +97,33 @@ public function fetch($request, $template = null, $display = false)
 
     public function readInputData()
     {
-        $this->readUserVars(['responsible', 'reminderBody']);
+        $this->readUserVars(['reminderRole', 'responsible', 'areaModerator', 'reminderBody']);
     }
 
     public function execute(...$functionArgs)
     {
-        $responsibleUserId = $this->getData('responsible');
-        $reminderBody = $this->getData('reminderBody');
-
-        $responsible = DAORegistry::getDAO('UserDAO')->getById($responsibleUserId);
+        $reminderRole = $this->getData('reminderRole');
+        $locale = AppLocale::getLocale();
         $context = Application::get()->getRequest()->getContext();
+        $reminderBody = $this->getData('reminderBody');
 
-        $locale = AppLocale::getLocale();
-        $preModerationTimeLimit = $this->plugin->getSetting($this->contextId, 'preModerationTimeLimit');
+        if ($reminderRole == REMINDER_TYPE_PRE_MODERATION) {
+            $userId = $this->getData('responsible');
+            $moderationTimeLimit = $this->plugin->getSetting($this->contextId, 'preModerationTimeLimit');
+        } elseif ($reminderRole == REMINDER_TYPE_AREA_MODERATION) {
+            $userId = $this->getData('areaModerator');
+            $moderationTimeLimit = $this->plugin->getSetting($this->contextId, 'areaModerationTimeLimit');
+        }
 
-        $moderationReminderEmailBuilder = new ModerationReminderEmailBuilder($context, $responsible, [], $locale, $preModerationTimeLimit);
+        $user = DAORegistry::getDAO('UserDAO')->getById($userId);
+        $moderationReminderEmailBuilder = new ModerationReminderEmailBuilder(
+            $context,
+            $user,
+            [],
+            $locale,
+            $reminderRole,
+            $moderationTimeLimit
+        );
         $reminderEmail = $moderationReminderEmailBuilder->buildEmail();
         $reminderEmail->setBody($reminderBody);