Ubuntu

request = $request; $generalConfig = Config::getInstance()->General; $this->segmentCompareLimit = (int) $generalConfig['data_comparison_segment_limit']; $this->checkComparisonLimit($this->segmentCompareLimit, 'data_comparison_segment_limit'); $this->periodCompareLimit = (int) $generalConfig['data_comparison_period_limit']; $this->checkComparisonLimit($this->periodCompareLimit, 'data_comparison_period_limit'); $this->segmentName = $this->getSegmentNameFromReport($report); $this->compareSegments = self::getCompareSegments(); if (count($this->compareSegments) > $this->segmentCompareLimit + 1) { throw new BadRequestException(Piwik::translate('General_MaximumNumberOfSegmentsComparedIs', [$this->segmentCompareLimit])); } $this->compareDates = self::getCompareDates($request); $this->comparePeriods = self::getComparePeriods($request); if (count($this->compareDates) !== count($this->comparePeriods)) { throw new BadRequestException(Piwik::translate('General_CompareDatesParamMustMatchComparePeriods', ['compareDates', 'comparePeriods'])); } if (count($this->compareDates) > $this->periodCompareLimit + 1) { throw new BadRequestException(Piwik::translate('General_MaximumNumberOfPeriodsComparedIs', [$this->periodCompareLimit])); } if (count($this->compareSegments) == 1 && count($this->comparePeriods) == 1 ) { return; } $this->checkMultiplePeriodCompare(); // map segments/periods to their indexes in the query parameter arrays for comparisonIdSubtable matching $this->compareSegmentIndices = array_flip($this->compareSegments); foreach ($this->comparePeriods as $index => $period) { $date = $this->compareDates[$index]; $this->comparePeriodIndices[$period][$date] = $index; } $this->invertCompareChangeCompute = Common::getRequestVar('invert_compare_change_compute', $default = 0, $type = 'int', $request) == 1; if ($this->invertCompareChangeCompute && count($this->comparePeriods) != 2) { throw new \Exception("invert_compare_change_compute=1 can only be used when comparing two periods."); } $this->columnMappings = $this->getColumnMappings(); $this->comparisonRowGenerator = new ComparisonRowGenerator($this->segmentName, $this->isRequestMultiplePeriod(), $this->columnMappings); } public static function isCompareParamsPresent($request = null) { return !empty(Common::getRequestVar('compareSegments', [], $type = 'array', $request)) || !empty(Common::getRequestVar('comparePeriods', [], $type = 'array', $request)) || !empty(Common::getRequestVar('compareDates', [], $type = 'array', $request)); } /** * @param DataTable\DataTableInterface $table */ public function compare(DataTable\DataTableInterface $table) { if (empty($this->compareSegments) && empty($this->comparePeriods) ) { return; } $method = Common::getRequestVar('method', $default = null, $type = 'string', $this->request); if ($method == 'Live') { throw new \Exception("Data comparison is not enabled for the Live API."); } // optimization, if empty, single table, don't need to make extra queries if ($table->getRowsCount() == 0) { return; } $comparisonSeries = []; // fetch data first $reportsToCompare = self::getReportsToCompare($this->compareSegments, $this->comparePeriods, $this->compareDates); foreach ($reportsToCompare as $index => $modifiedParams) { $compareMetadata = $this->getMetadataFromModifiedParams($modifiedParams); $comparisonSeries[] = $compareMetadata['compareSeriesPretty']; $compareTable = $this->requestReport($method, $modifiedParams); $this->comparisonRowGenerator->compareTables($compareMetadata, $table, empty($compareTable) ? null : $compareTable); } // calculate changes (including processed metric changes) // NOTE: it doesn't make to sense to calculate these values for segments, since segments are subsets of all visits, where periods are // time periods (so things can change from one to another). if (count($this->comparePeriods) > 1) { $this->compareChangePercents($table); } // format comparison table metrics $this->formatComparisonTables($table); // add comparison parameters as metadata $table->filter(function (DataTable $singleTable) use ($comparisonSeries) { if (isset($this->compareSegments)) { $singleTable->setMetadata('compareSegments', $this->compareSegments); } if (isset($this->comparePeriods)) { $singleTable->setMetadata('comparePeriods', $this->comparePeriods); } if (isset($this->compareDates)) { $singleTable->setMetadata('compareDates', $this->compareDates); } $singleTable->setMetadata('comparisonSeries', $comparisonSeries); }); } public static function getReportsToCompare($compareSegments, $comparePeriods, $compareDates) { $permutations = []; // NOTE: the order of these loops determines the order of the rows in the comparison table. ie, // if we loop over dates then segments, then we'll see comparison rows change segments before changing // periods. this is because this loop determines in what order we fetch report data. foreach ($compareDates as $index => $date) { foreach ($compareSegments as $segment) { $period = $comparePeriods[$index]; $params = []; $params['segment'] = $segment; if (!empty($period) && !empty($date) ) { $params['date'] = $date; $params['period'] = $period; } $permutations[] = $params; } } return $permutations; } /** * @param $paramsToModify * @return DataTable */ private function requestReport($method, $paramsToModify) { $params = array_merge( [ 'filter_limit' => -1, 'filter_offset' => 0, 'filter_sort_column' => '', 'filter_truncate' => -1, 'compare' => 0, 'totals' => 1, 'disable_queued_filters' => 1, 'format_metrics' => 0, 'label' => '', 'flat' => Common::getRequestVar('flat', 0, 'int', $this->request), 'filter_add_columns_when_show_all_columns' => Common::getRequestVar('filter_add_columns_when_show_all_columns', '', 'string', $this->request), 'filter_update_columns_when_show_all_goals' => Common::getRequestVar('filter_update_columns_when_show_all_goals', '', 'string', $this->request), 'filter_show_goal_columns_process_goals' => Common::getRequestVar('filter_show_goal_columns_process_goals', '', 'string', $this->request), 'idGoal' => Common::getRequestVar('idGoal', '', 'string', $this->request), ], $paramsToModify ); $params['keep_totals_row'] = Common::getRequestVar('keep_totals_row', 0, 'int', $this->request); $params['keep_totals_row_label'] = Common::getRequestVar('keep_totals_row_label', '', 'string', $this->request); if (!isset($params['idSite'])) { $params['idSite'] = Common::getRequestVar('idSite', null, 'string', $this->request); } if (!isset($params['period'])) { $params['period'] = Common::getRequestVar('period', null, 'string', $this->request); } if (!isset($params['date'])) { $params['date'] = Common::getRequestVar('date', null, 'string', $this->request); } $idSubtable = Common::getRequestVar('idSubtable', 0, 'int', $this->request); if ($idSubtable > 0) { $comparisonIdSubtables = Common::getRequestVar('comparisonIdSubtables', $default = false, 'json', $this->request); if (empty($comparisonIdSubtables)) { throw new \Exception("Comparing segments/periods with subtables only works when the comparison idSubtables are supplied as well."); } $segmentIndex = empty($paramsToModify['segment']) ? 0 : $this->compareSegmentIndices[$paramsToModify['segment']]; $periodIndex = empty($paramsToModify['period']) ? 0 : $this->comparePeriodIndices[$paramsToModify['period']][$paramsToModify['date']]; $seriesIndex = self::getComparisonSeriesIndex(null, $periodIndex, $segmentIndex, count($this->compareSegments)); if (!isset($comparisonIdSubtables[$seriesIndex])) { throw new \Exception("Invalid comparisonIdSubtables parameter: no idSubtable found for segment $segmentIndex and period $periodIndex"); } $comparisonIdSubtable = $comparisonIdSubtables[$seriesIndex]; if ($comparisonIdSubtable === -1) { // no subtable in comparison row $table = new DataTable(); $table->setMetadata('site', new Site($params['idSite'])); $table->setMetadata('period', Period\Factory::build($params['period'], $params['date'])); return $table; } $params['idSubtable'] = $comparisonIdSubtable; } return Request::processRequest($method, $params); } private function formatComparisonTables(DataTableInterface $tableOrMap) { $tableOrMap->filter(function (DataTable $table) { $rows = $table->getRows(); $totalRow = $table->getTotalsRow(); if ($totalRow) { $rows[] = $totalRow; } foreach ($rows as $row) { /** @var DataTable $comparisonTable */ $comparisonTable = $row->getComparisons(); if (!empty($comparisonTable)) { // sanity check $columnMappings = $this->columnMappings; $comparisonTable->filter(DataTable\Filter\ReplaceColumnNames::class, [$columnMappings]); } $subtable = $row->getSubtable(); if ($subtable) { $this->formatComparisonTables($subtable); } } }); } private function checkComparisonLimit($n, $configName) { if ($n <= 1) { throw new \Exception("The [General] $configName INI config option must be greater than 1."); } } private function getMetadataFromModifiedParams($modifiedParams) { $metadata = []; $period = isset($modifiedParams['period']) ? $modifiedParams['period'] : reset($this->comparePeriods); $date = isset($modifiedParams['date']) ? $modifiedParams['date'] : reset($this->compareDates); $segment = isset($modifiedParams['segment']) ? $modifiedParams['segment'] : reset($this->compareSegments); $metadata['compareSegment'] = $segment; $segmentObj = new Segment($segment, []); $metadata['compareSegmentPretty'] = $segmentObj->getStoredSegmentName(false); $metadata['comparePeriod'] = $period; $metadata['compareDate'] = $date; $prettyPeriod = Factory::build($period, $date)->getLocalizedLongString(); $metadata['comparePeriodPretty'] = ucfirst($prettyPeriod); $metadata['compareSeriesPretty'] = self::getComparisonSeriesLabelSuffixFromParts( $metadata['comparePeriodPretty'], $metadata['compareSegmentPretty']); return $metadata; } private static function getComparisonSeriesLabelSuffixFromParts($periodPretty, $segmentPretty) { $comparisonLabels = [ $periodPretty, $segmentPretty, ]; $comparisonLabels = array_filter($comparisonLabels); return '(' . implode(') (', $comparisonLabels) . ')'; } private function getSegmentNameFromReport(Report $report = null) { if (empty($report)) { return null; } $dimension = $report->getDimension(); if (empty($dimension)) { return null; } $segments = $dimension->getSegments(); if (empty($segments)) { return null; } /** @var \Piwik\Plugin\Segment $segment */ $segment = reset($segments); $segmentName = $segment->getSegment(); return $segmentName; } private function checkMultiplePeriodCompare() { if ($this->isRequestMultiplePeriod()) { foreach ($this->comparePeriods as $index => $period) { if (!Period::isMultiplePeriod($this->compareDates[$index], $period)) { throw new \Exception("Cannot compare: original request is multiple period and cannot be compared with single periods."); } } } else { foreach ($this->comparePeriods as $index => $period) { if (Period::isMultiplePeriod($this->compareDates[$index], $period)) { throw new \Exception("Cannot compare: original request is single period and cannot be compared with multiple periods."); } } } } private function isRequestMultiplePeriod() { if ($this->isRequestMultiplePeriod === null) { $period = Common::getRequestVar('period', $default = null, 'string', $this->request); $date = Common::getRequestVar('date', $default = null, 'string', $this->request); $this->isRequestMultiplePeriod = Period::isMultiplePeriod($date, $period); } return $this->isRequestMultiplePeriod; } private function compareChangePercents(DataTableInterface $result) { $segmentCount = count($this->compareSegments); $result->filter(function (DataTable $table) use ($segmentCount) { $rows = $table->getRows(); $totalRow = $table->getTotalsRow(); if ($totalRow) { $rows[] = $totalRow; } foreach ($rows as $row) { $comparisons = $row->getComparisons(); if (empty($comparisons)) { continue; } /** @var DataTable\Row[] $rows */ $rows = array_values($comparisons->getRows()); foreach ($rows as $index => $compareRow) { [$periodIndex, $segmentIndex] = self::getIndividualComparisonRowIndices($table, $index, $segmentCount); if (!$this->invertCompareChangeCompute && $index < $segmentCount) { continue; // do not calculate for first period } else if ($this->invertCompareChangeCompute && $periodIndex != 0) { continue; // when inverting change calculation, only calculate for first period rows } if (!$this->invertCompareChangeCompute) { $otherPeriodRowIndex = $segmentIndex; $otherPeriodRow = $comparisons[$otherPeriodRowIndex]; } else { $otherPeriodIndex = 1; $otherPeriodRowIndex = self::getComparisonSeriesIndex($table, $otherPeriodIndex, $segmentIndex, $segmentCount); $otherPeriodRow = $comparisons[$otherPeriodRowIndex]; } foreach ($compareRow->getColumns() as $name => $value) { [$changeTo, $trendTo] = $this->computeChangePercent($otherPeriodRow, $compareRow, $name); $compareRow->addColumn($name . '_change', $changeTo); if ($this->shouldIncludeTrendValues()) { $compareRow->addColumn($name . '_trend', $trendTo); } [$changeFrom, $trendFrom] = $this->computeChangePercent($compareRow, $otherPeriodRow, $name); $compareRow->addColumn($name . '_change_from', $changeFrom); if ($this->shouldIncludeTrendValues()) { $compareRow->addColumn($name . '_trend_from', $trendFrom); } } } } }); } private function computeChangePercent(DataTable\Row $fromRow, DataTable\Row $toRow, $columnName) { $value = $toRow ? $toRow->getColumn($columnName) : 0; $value = $value ?: 0; $valueToCompare = $fromRow ? $fromRow->getColumn($columnName) : 0; $valueToCompare = $valueToCompare ?: 0; $change = DataTable\Filter\CalculateEvolutionFilter::calculate($value, $valueToCompare, $precision = 1, true, true); $trend = $value - $valueToCompare < 0 ? -1 : ($value - $valueToCompare > 0 ? 1 : 0); return [$change, $trend]; } /** * Returns the period and segment indices for a given comparison index. * * @param DataTable|null $table * @param $comparisonRowIndex * @param null $segmentCount * @return array */ public static function getIndividualComparisonRowIndices($table, $comparisonRowIndex, $segmentCount = null) { $segmentCount = $segmentCount ?: count($table->getMetadata('compareSegments')); $segmentIndex = $comparisonRowIndex % $segmentCount; $periodIndex = floor($comparisonRowIndex / $segmentCount); return [$periodIndex, $segmentIndex]; } /** * Returns the series index for a comparison based on the period and segment indices. * * @param DataTable|null $table * @param int $periodIndex * @param int $segmentIndex * @param int|null $segmentCount * @return int */ public static function getComparisonSeriesIndex($table, $periodIndex, $segmentIndex, $segmentCount = null) { $segmentCount = $segmentCount ?: count($table->getMetadata('compareSegments')); return $periodIndex * $segmentCount + $segmentIndex; } private static function getCompareSegments($request = null) { $segments = Common::getRequestVar('compareSegments', $default = [], $type = 'array', $request); array_unshift($segments, Common::getRequestVar('segment', '', 'string', $request)); $segments = Common::unsanitizeInputValues($segments); return $segments; } private static function getComparePeriods($request = null) { $periods = Common::getRequestVar('comparePeriods', $default = [], $type = 'array', $request); array_unshift($periods, Common::getRequestVar('period', '', 'string', $request)); return array_values($periods); } private static function getCompareDates($request = null) { $dates = Common::getRequestVar('compareDates', $default = [], $type = 'array', $request); array_unshift($dates, Common::getRequestVar('date', '', 'string', $request)); return array_values($dates); } /** * Returns whether to include trend values for all evolution columns or not * This is requested only for sparklines * * @see \Piwik\Plugins\CoreVisualizations\Visualizations\Sparklines::render() * * @return bool * @throws \Exception */ private function shouldIncludeTrendValues(): bool { return (bool) Common::getRequestVar('include_trends', 0, 'int', $this->request); } /** * Returns the pretty series label for a specific comparison based on the currently set comparison query parameters. * * @param int $labelSeriesIndex The index of the comparison. Comparison series order is determined by {@see self::getReportsToCompare()}. */ public static function getPrettyComparisonLabelFromSeriesIndex($labelSeriesIndex) { $compareSegments = self::getCompareSegments(); $comparePeriods = self::getComparePeriods(); $compareDates = self::getCompareDates(); [$periodIndex, $segmentIndex] = self::getIndividualComparisonRowIndices(null, $labelSeriesIndex, count($compareSegments)); $segmentObj = new Segment($compareSegments[$segmentIndex], []); $prettySegment = $segmentObj->getStoredSegmentName(false); $prettyPeriod = Factory::build($comparePeriods[$periodIndex], $compareDates[$periodIndex])->getLocalizedLongString(); $prettyPeriod = ucfirst($prettyPeriod); return self::getComparisonSeriesLabelSuffixFromParts($prettyPeriod, $prettySegment); } private function getColumnMappings() { $allMappings = Metrics::getMappingFromIdToName(); $mappings = []; foreach ($allMappings as $index => $name) { $mappings[$index] = $name; $mappings[$index . '_change'] = $name . '_change'; $mappings[$index . '_change_from'] = $name . '_change_from'; $mappings[$index . '_trend'] = $name . '_trend'; $mappings[$index . '_trend_from'] = $name . '_trend_from'; } return $mappings; } }