PKPStatsService.inc.php

<?php
 
namespace PKP\Services;
 
class PKPStatsService {
 
   public function getRecords($args = []) {
 
      // Get the stats constants
      import('classes.statistics.StatisticsHelper');
 
      $defaultArgs = [
         'dateStart' => STATISTICS_EARLIEST_DATE,
         'dateEnd' => date('Y-m-d', strtotime('yesterday')),
 
         // Require a context to be specified to prevent unwanted data leakage
         // if someone forgets to specify the context.
         'contextIds' => [CONTEXT_ID_NONE],
      ];
 
      $args = array_merge($defaultArgs, $args);
      $statsQB = $this->getQueryBuilder($args);
 
      \HookRegistry::call('Stats::getRecords::queryBuilder', array($statsQB, $args));
 
      $statsQO = $statsQB->getRecords();
 
      $result = \DAORegistry::getDAO('MetricsDAO')
         ->retrieve($statsQO->toSql(), $statsQO->getBindings());
 
      $records = [];
      while (!$result->EOF) {
         $records[] = [
            'loadId' => $result->fields['load_id'],
            'contextId' => (int) $result->fields['context_id'],
            'submissionId' => (int) $result->fields['submission_id'],
            'assocType' => (int) $result->fields['assoc_type'],
            'assocId' => (int) $result->fields['assoc_id'],
            'day' => (int) $result->fields['day'],
            'month' => (int) $result->fields['month'],
            'fileType' => (int) $result->fields['file_type'],
            'countryId' => $result->fields['country_id'],
            'region' => $result->fields['region'],
            'city' => $result->fields['city'],
            'metric' => (int) $result->fields['metric'],
            'metricType' => $result->fields['metric_type'],
            'pkpSectionId' => (int) $result->fields['pkp_section_id'],
            'assocObjectType' => (int) $result->fields['assoc_object_type'],
            'assocObjectTId' => (int) $result->fields['assoc_object_id'],
            'representation_id' => (int) $result->fields['representation_id'],
         ];
         $result->MoveNext();
      }
 
      return $records;
   }
 
   public function getTimeline($timelineInterval, $args = []) {
 
      $defaultArgs = [
         'dateStart' => STATISTICS_EARLIEST_DATE,
         'dateEnd' => date('Y-m-d', strtotime('yesterday')),
 
         // Require a context to be specified to prevent unwanted data leakage
         // if someone forgets to specify the context. If you really want to
         // get data across all contexts, pass an empty `contextId` arg.
         'contextIds' => [CONTEXT_ID_NONE],
      ];
 
      $args = array_merge($defaultArgs, $args);
      $timelineQB = $this->getQueryBuilder($args);
 
      \HookRegistry::call('Stats::getTimeline::queryBuilder', array($timelineQB, $args));
 
      $timelineQO = $timelineQB
         ->getSum([$timelineInterval])
         ->orderBy($timelineInterval);
 
      $result = \DAORegistry::getDAO('MetricsDAO')
         ->retrieve($timelineQO->toSql(), $timelineQO->getBindings());
 
      $dateValues = [];
      while (!$result->EOF) {
         $date = substr($result->fields[$timelineInterval], 0, 4) . '-' . substr($result->fields[$timelineInterval], 4, 2);
         if ($timelineInterval === STATISTICS_DIMENSION_DAY) {
            $date = substr($date, 0, 7) . '-' . substr($result->fields[$timelineInterval], 6, 2);
         }
         $dateValues[$date] = (int) $result->fields['metric'];
         $result->MoveNext();
      }
 
      $timeline = $this->getEmptyTimelineIntervals($args['dateStart'], $args['dateEnd'], $timelineInterval);
 
      $timeline = array_map(function($entry) use ($dateValues) {
         foreach ($dateValues as $date => $value) {
            if ($entry['date'] === $date) {
               $entry['value'] = $value;
               break;
            }
         }
         return $entry;
      }, $timeline);
 
      return $timeline;
   }
 
   public function getOrderedObjects($groupBy, $orderDirection, $args = []) {
 
      $defaultArgs = [
         'dateStart' => STATISTICS_EARLIEST_DATE,
         'dateEnd' => date('Y-m-d', strtotime('yesterday')),
 
         // Require a context to be specified to prevent unwanted data leakage
         // if someone forgets to specify the context. If you really want to
         // get data across all contexts, pass an empty `contextId` arg.
         'contextIds' => [CONTEXT_ID_NONE],
      ];
 
      $args = array_merge($defaultArgs, $args);
      $orderedQB = $this->getQueryBuilder($args);
 
      \HookRegistry::call('Stats::getOrderedObjects::queryBuilder', array($orderedQB, $args));
 
      $orderedQO = $orderedQB
         ->getSum([$groupBy])
         ->orderBy('metric', $orderDirection === STATISTICS_ORDER_ASC ? 'asc' : 'desc');
 
      $range = null;
      if (isset($args['count'])) {
         import('lib.pkp.classes.db.DBResultRange');
         $range = new \DBResultRange($args['count'], null, isset($args['offset']) ? $args['offset'] : 0);
      }
 
      $result = \DAORegistry::getDAO('MetricsDAO')
         ->retrieveRange($orderedQO->toSql(), $orderedQO->getBindings(), $range);
 
      $objects = [];
      while (!$result->EOF) {
         $objects[] = [
            'id' => (int) $result->fields[$groupBy],
            'total' => (int) $result->fields['metric'],
         ];
         $result->MoveNext();
      }
 
      return $objects;
   }
 
   public function sumMetric($total, $record) {
      $total += $record['metric'];
      return $total;
   }
 
   public function filterRecordFile($record) {
      return !empty($record['fileType']);
   }
 
   public function filterRecordPdf($record) {
      return $record['fileType'] === STATISTICS_FILE_TYPE_PDF;
   }
 
   public function filterRecordHtml($record) {
      return $record['fileType'] === STATISTICS_FILE_TYPE_HTML;
   }
 
   public function filterRecordOther($record) {
      return $record['fileType'] === STATISTICS_FILE_TYPE_OTHER;
   }
 
   public function getEmptyTimelineIntervals($startDate, $endDate, $timelineInterval) {
 
      if ($timelineInterval === STATISTICS_DIMENSION_MONTH) {
         $dateFormat = 'Y-m';
         $labelFormat = '%B %Y';
         $interval = 'P1M';
      } elseif ($timelineInterval === STATISTICS_DIMENSION_DAY) {
         $dateFormat = 'Y-m-d';
         $labelFormat = \Application::get()->getRequest()->getContext()->getLocalizedDateFormatLong();
         $interval = 'P1D';
      }
 
      $startDate = new \DateTime($startDate);
      $endDate = new \DateTime($endDate);
 
      $timelineIntervals = [];
      while ($startDate->format($dateFormat) <= $endDate->format($dateFormat)) {
         $timelineIntervals[] = [
            'date' => $startDate->format($dateFormat),
            'label' => strftime($labelFormat, $startDate->getTimestamp()),
            'value' => 0,
         ];
         $startDate->add(new \DateInterval($interval));
      }
 
      return $timelineIntervals;
   }
 
   protected function getQueryBuilder($args = []) {
      $statsQB = new \PKP\Services\QueryBuilders\PKPStatsQueryBuilder();
      $statsQB
         ->filterByContexts($args['contextIds'])
         ->before($args['dateEnd'])
         ->after($args['dateStart']);
 
      if (!empty(($args['submissionIds']))) {
         $statsQB->filterBySubmissions($args['submissionIds']);
      }
 
      if (!empty($args['assocTypes'])) {
         $statsQB->filterByAssocTypes($args['assocTypes']);
         if (!empty($args['assocIds'])) {
            $statsQB->filterByAssocIds($args['assocIds']);
         }
      }
 
      if (!empty($args['fileTypes'])) {
         $statsQB->filterByFileTypes(($args['fileTypes']));
      }
 
      \HookRegistry::call('Stats::queryBuilder', array($statsQB, $args));
 
      return $statsQB;
   }
}