PKPStatsEditorialService.inc.php

<?php
 
namespace PKP\Services;
 
class PKPStatsEditorialService {
 
   public function getOverview($args = []) {
      import('classes.workflow.EditorDecisionActionsManager');
      import('lib.pkp.classes.submission.PKPSubmission');
      \AppLocale::requireComponents(LOCALE_COMPONENT_PKP_MANAGER, LOCALE_COMPONENT_APP_MANAGER);
 
      $received = $this->countSubmissionsReceived($args);
      $accepted = $this->countByDecisions(SUBMISSION_EDITOR_DECISION_ACCEPT, $args);
      $declinedDesk = $this->countByDecisions(SUBMISSION_EDITOR_DECISION_INITIAL_DECLINE, $args);
      $declinedReview = $this->countByDecisions(SUBMISSION_EDITOR_DECISION_DECLINE, $args);
      $declined = $declinedDesk + $declinedReview;
 
      // Calculate the acceptance/decline rates
      if (!$received) {
         // Never divide by 0
         $acceptanceRate = 0;
         $declineRate = 0;
         $declinedDeskRate = 0;
         $declinedReviewRate = 0;
      } elseif (empty($args['dateStart']) && empty($args['dateEnd'])) {
         $acceptanceRate = $accepted / $received;
         $declineRate = $declined / $received;
         $declinedDeskRate = $declinedDesk / $received;
         $declinedReviewRate = $declinedReview / $received;
      } else {
         // To calculate the acceptance/decline rates within a date range
         // we must collect the total number of all submissions made within
         // that date range which have received a decision. The acceptance
         // rate is the number of submissions made within the date range
         // that were accepted divided by the number of submissions made
         // within the date range that were accepted or declined. This
         // excludes submissions that were made within the date range but
         // have not yet been accepted or declined.
         $acceptedForSubmissionDate = $this->countByDecisionsForSubmittedDate(SUBMISSION_EDITOR_DECISION_ACCEPT, $args);
         $declinedDeskForSubmissionDate = $this->countByDecisionsForSubmittedDate(SUBMISSION_EDITOR_DECISION_INITIAL_DECLINE, $args);
         $declinedReviewForSubmissionDate = $this->countByDecisionsForSubmittedDate(SUBMISSION_EDITOR_DECISION_DECLINE, $args);
         $totalDecidedForSubmissionDate = $acceptedForSubmissionDate + $declinedDeskForSubmissionDate + $declinedReviewForSubmissionDate;
 
         // Never divide by 0
         if (!$totalDecidedForSubmissionDate) {
            $acceptanceRate = 0;
            $declineRate = 0;
            $declinedDeskRate = 0;
            $declinedReviewRate = 0;
         } else {
            $acceptanceRate =  $acceptedForSubmissionDate / $totalDecidedForSubmissionDate;
            $declineRate = ($declinedDeskForSubmissionDate + $declinedReviewForSubmissionDate) / $totalDecidedForSubmissionDate;
            $declinedDeskRate =  $declinedDeskForSubmissionDate / $totalDecidedForSubmissionDate;
            $declinedReviewRate =  $declinedReviewForSubmissionDate / $totalDecidedForSubmissionDate;
         }
      }
 
      // Calculate the number of days it took for most submissions to
      // receive decisions
      $firstDecisionDays = $this->getDaysToDecisions([], $args);
      $acceptDecisionDays = $this->getDaysToDecisions([SUBMISSION_EDITOR_DECISION_SEND_TO_PRODUCTION, SUBMISSION_EDITOR_DECISION_ACCEPT], $args);
      $declineDecisionDays = $this->getDaysToDecisions([SUBMISSION_EDITOR_DECISION_DECLINE, SUBMISSION_EDITOR_DECISION_INITIAL_DECLINE], $args);
      $firstDecisionDaysRate = empty($firstDecisionDays) ? 0 : $this->calculateDaysToDecisionRate($firstDecisionDays, 0.8);
      $acceptDecisionDaysRate = empty($acceptDecisionDays) ? 0 : $this->calculateDaysToDecisionRate($acceptDecisionDays, 0.8);
      $declineDecisionDaysRate = empty($declineDecisionDays) ? 0 : $this->calculateDaysToDecisionRate($declineDecisionDays, 0.8);
 
      $overview = [
         [
            'key' => 'submissionsReceived',
            'name' => 'stats.name.submissionsReceived',
            'value' => $received,
         ],
         [
            'key' => 'submissionsAccepted',
            'name' => 'stats.name.submissionsAccepted',
            'value' => $accepted,
         ],
         [
            'key' => 'submissionsDeclined',
            'name' => 'stats.name.submissionsDeclined',
            'value' => $declined,
         ],
         [
            'key' => 'submissionsDeclinedDeskReject',
            'name' => 'stats.name.submissionsDeclinedDeskReject',
            'value' => $declinedDesk,
         ],
         [
            'key' => 'submissionsDeclinedPostReview',
            'name' => 'stats.name.submissionsDeclinedPostReview',
            'value' => $declinedReview,
         ],
         [
            'key' => 'submissionsPublished',
            'name' => 'stats.name.submissionsPublished',
            'value' => $this->countSubmissionsPublished($args),
         ],
         [
            'key' => 'daysToDecision',
            'name' => 'stats.name.daysToDecision',
            'value' => $firstDecisionDaysRate,
         ],
         [
            'key' => 'daysToAccept',
            'name' => 'stats.name.daysToAccept',
            'value' => $acceptDecisionDaysRate,
         ],
         [
            'key' => 'daysToReject',
            'name' => 'stats.name.daysToReject',
            'value' => $declineDecisionDaysRate,
         ],
         [
            'key' => 'acceptanceRate',
            'name' => 'stats.name.acceptanceRate',
            'value' => round($acceptanceRate, 2),
         ],
         [
            'key' => 'declineRate',
            'name' => 'stats.name.declineRate',
            'value' => round($declineRate, 2),
         ],
         [
            'key' => 'declinedDeskRate',
            'name' => 'stats.name.declinedDeskRate',
            'value' => round($declinedDeskRate, 2),
         ],
         [
            'key' => 'declinedReviewRate',
            'name' => 'stats.name.declinedReviewRate',
            'value' => round($declinedReviewRate, 2),
         ],
      ];
 
      \HookRegistry::call('EditorialStats::overview', [&$overview, $args]);
 
      return $overview;
   }
 
   public function getAverages($args = []) {
      import('classes.workflow.EditorDecisionActionsManager');
      import('lib.pkp.classes.submission.PKPSubmission');
 
      unset($args['dateStart']);
      unset($args['dateEnd']);
 
      // Submissions received
      $received = -1;
      $receivedDates = $this->getQueryBuilder($args)->getSubmissionsReceivedDates();
      if (empty($receivedDates[0])) {
         $received = 0;
      } else {
         $yearStart = ((int) substr($receivedDates[0], 0, 4)) + 1;
         $yearEnd = (int) substr($receivedDates[1], 0, 4);
         if ($yearEnd >= date('Y')) {
            $yearEnd--;
         }
         $years = ($yearEnd - $yearStart) + 1;
         if ($years) {
            $argsReceived = array_merge(
               $args,
               [
                  'dateStart' => sprintf('%s-01-01', $yearStart),
                  'dateEnd' => sprintf('%s-12-31', $yearEnd),
               ]
            );
            $received = round($this->countSubmissionsReceived($argsReceived) / $years);
         }
      }
 
      // Editorial decisions (accepted and declined)
      $decisionsList = [
         'submissionsAccepted' => [SUBMISSION_EDITOR_DECISION_ACCEPT],
         'submissionsDeclined' => [SUBMISSION_EDITOR_DECISION_INITIAL_DECLINE, SUBMISSION_EDITOR_DECISION_DECLINE],
         'submissionsDeclinedDeskReject' => [SUBMISSION_EDITOR_DECISION_INITIAL_DECLINE],
         'submissionsDeclinedPostReview' => [SUBMISSION_EDITOR_DECISION_DECLINE],
      ];
      $yearlyDecisions = [];
      foreach ($decisionsList as $key => $decisions) {
         $yearly = -1;
         $dates = $this->getQueryBuilder($args)->getDecisionsDates($decisions);
         if (empty($dates[0])) {
            $yearly = 0;
         } else {
            $yearStart = ((int) substr($dates[0], 0, 4)) + 1;
            $yearEnd = (int) substr($dates[1], 0, 4);
            if ($yearEnd >= date('Y')) {
               $yearEnd--;
            }
            $years = ($yearEnd - $yearStart) + 1;
            if ($years) {
               $argsYearly = array_merge(
                  $args,
                  [
                     'dateStart' => sprintf('%s-01-01', $yearStart),
                     'dateEnd' => sprintf('%s-12-31', $yearEnd),
                  ]
               );
               $yearly = round($this->countByDecisions($decisions, $argsYearly) / $years);
            }
         }
         $yearlyDecisions[$key] = $yearly;
      }
 
      // Submissions published
      $published = -1;
      $publishedDates = $this->getQueryBuilder($args)->getPublishedDates();
      if (empty($publishedDates[0])) {
         $published = 0;
      } else {
         $yearStart = ((int) substr($publishedDates[0], 0, 4)) + 1;
         $yearEnd = (int) substr($publishedDates[1], 0, 4);
         if ($yearEnd >= date('Y')) {
            $yearEnd--;
         }
         $years = ($yearEnd - $yearStart) + 1;
         if ($years) {
            $argsPublished = array_merge(
               $args,
               [
                  'dateStart' => sprintf('%s-01-01', $yearStart),
                  'dateEnd' => sprintf('%s-12-31', $yearEnd),
               ]
            );
            $published = round($this->countSubmissionsPublished($argsPublished) / $years);
         }
      }
 
      $averages = array_merge(
         ['submissionsReceived' => $received],
         $yearlyDecisions,
         ['submissionsPublished' => $published]
      );
 
      \HookRegistry::call('EditorialStats::averages', [&$averages, $args]);
 
      return $averages;
   }
 
   public function countSubmissionsReceived($args = []) {
      return $this->getQueryBuilder($args)->countSubmissionsReceived();
   }
 
 
   public function countSubmissionsPublished($args = []) {
      return $this->getQueryBuilder($args)->countPublished();
   }
 
   public function countByDecisions($decisions, $args = []) {
      return $this->getQueryBuilder($args)->countByDecisions((array) $decisions);
   }
 
   public function countByDecisionsForSubmittedDate($decisions, $args = []) {
      return $this->getQueryBuilder($args)->countByDecisions((array) $decisions, true);
   }
 
   public function countByStatus($statuses, $args = []) {
      return $this->getQueryBuilder($args)->countByStatus((array) $statuses);
   }
 
   public function countActiveByStages($stages, $args = []) {
      return $this->getQueryBuilder($args)->countActiveByStages((array) $stages);
   }
 
   public function getDaysToDecisions($decisions, $args = []) {
      return $this->getQueryBuilder($args)->getDaysToDecisions((array) $decisions);
   }
 
   public function getAverageDaysToDecisions($decisions, $args = []) {
      return ceil($this->getQueryBuilder($args)->getAverageDaysToDecisions((array) $decisions));
   }
 
   public function calculateDaysToDecisionRate($days, $percentage) {
      sort($days);
      $arrayPart = array_slice($days, 0, ceil(count($days) * $percentage));
      return end($arrayPart) ?? 0;
   }
 
   protected function getQueryBuilder($args = []) {
      $qb = new \APP\Services\QueryBuilders\StatsEditorialQueryBuilder();
 
      if (!empty($args['dateStart'])) {
         $qb->after($args['dateStart']);
      }
      if (!empty($args['dateEnd'])) {
         $qb->before($args['dateEnd']);
      }
      if (!empty($args['contextIds'])) {
         $qb->filterByContexts($args['contextIds']);
      }
 
      \HookRegistry::call('Stats::editorial::queryBuilder', array($qb, $args));
 
      return $qb;
   }
}