Hugging Face's logo

Spaces:
Leon4gr45
/
matomo
Paused

App Files Community
matomo / core /Period /Range.php
Leon4gr45's picture
Leon4gr45
Upload source files chunk 37
60d444f verified
Raw History Blame Contribute Delete
19.8 kB
<?php
/**
* Matomo - free/libre analytics platform
*
* @link https://matomo.org
* @license https://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
*/
namespace Piwik\Period;
use Exception;
use Piwik\Cache;
use Piwik\Common;
use Piwik\Container\StaticContainer;
use Piwik\Date;
use Piwik\Period;
/**
* Arbitrary date range representation.
*
* This class represents a period that contains a list of consecutive days as subperiods
* It is created when the **period** query parameter is set to **range** and is used
* to calculate the subperiods of multiple period requests (eg, when period=day and
* date=2007-07-24,2013-11-15).
*
* The range period differs from other periods mainly in that since it is arbitrary,
* range periods are not pre-archived by the cron core:archive command.
*
* @api
*/
class Range extends Period
{
public const PERIOD_ID = 5;
protected $label = 'range';
protected $today;
/**
* @var null|Date
*/
protected $defaultEndDate;
protected $strPeriod;
protected $strDate;
protected $timezone;
/**
* @param string $strPeriod The type of period each subperiod is. Either `'day'`, `'week'`,
* `'month'` or `'year'`.
* @param string $strDate The date range, eg, `'2007-07-24,2013-11-15'`.
* @param string $timezone The timezone to use, eg, `'UTC'`.
* @param bool|Date $today The date to use as _today_. Defaults to `Date::factory('today', $timzeone)`.
* @api
*/
public function __construct($strPeriod, $strDate, $timezone = 'UTC', $today = false)
{
$this->strPeriod = $strPeriod;
$this->strDate = $strDate;
$this->timezone = $timezone;
$this->defaultEndDate = null;
if ($today === false) {
$today = Date::factory('now', $this->timezone);
}
$this->today = $today;
$this->translator = StaticContainer::get('Piwik\Translation\Translator');
}
public function __sleep()
{
return [
'strPeriod',
'strDate',
'timezone',
'defaultEndDate',
'today',
];
}
public function __wakeup()
{
$this->translator = StaticContainer::get('Piwik\Translation\Translator');
}
private function getCache()
{
return Cache::getTransientCache();
}
private function getCacheId()
{
$end = '';
if ($this->defaultEndDate) {
$end = $this->defaultEndDate->getTimestamp();
}
$today = $this->today->getTimestamp();
return 'range' . $this->strPeriod . $this->strDate . $this->timezone . $end . $today;
}
private function loadAllFromCache()
{
$range = $this->getCache()->fetch($this->getCacheId());
if (!empty($range)) {
foreach ($range as $key => $val) {
$this->$key = $val;
}
}
}
private function cacheAll()
{
$props = get_object_vars($this);
$this->getCache()->save($this->getCacheId(), $props);
}
/**
* Returns the current period as a localized short string.
*
* @return string
*/
public function getLocalizedShortString()
{
return $this->getTranslatedRange($this->getRangeFormat(true));
}
/**
* Returns the current period as a localized long string.
*
* @return string
*/
public function getLocalizedLongString()
{
return $this->getTranslatedRange($this->getRangeFormat());
}
/**
* Returns the start date of the period.
*
* @return Date
* @throws Exception
*/
public function getDateStart()
{
/** @var Date|null $dateStart */
$dateStart = parent::getDateStart();
if (empty($dateStart)) {
throw new Exception("Specified date range is invalid.");
}
return $dateStart;
}
/**
* Returns the current period as a string.
*
* @return string
*/
public function getPrettyString()
{
$out = $this->translator->translate('General_DateRangeFromTo', array($this->getDateStart()->toString(), $this->getDateEnd()->toString()));
return $out;
}
protected function getMaxN(int $lastN): int
{
switch ($this->strPeriod) {
case 'day':
$lastN = min($lastN, 5 * 365);
break;
case 'week':
$lastN = min($lastN, 10 * 52);
break;
case 'month':
$lastN = min($lastN, 10 * 12);
break;
case 'year':
$lastN = min($lastN, 10);
break;
}
return $lastN;
}
/**
* Sets the default end date of the period.
*/
public function setDefaultEndDate(Date $oDate)
{
$this->defaultEndDate = $oDate;
}
/**
* Generates the subperiods
*
* @throws Exception
*/
protected function generate()
{
if ($this->subperiodsProcessed) {
return;
}
$this->loadAllFromCache();
if ($this->subperiodsProcessed) {
return;
}
parent::generate();
if (preg_match('/^(last|previous)([0-9]*)$/', $this->strDate, $regs)) {
$lastN = $regs[2];
$lastOrPrevious = $regs[1];
if (!is_null($this->defaultEndDate)) {
$defaultEndDate = $this->defaultEndDate;
} else {
$defaultEndDate = $this->today;
}
$period = $this->strPeriod;
if ($period == 'range') {
$period = 'day';
}
if ($lastOrPrevious == 'last') {
$endDate = $defaultEndDate;
} elseif ($lastOrPrevious == 'previous') {
if ('month' == $period) {
$endDate = $defaultEndDate->subMonth(1);
} else {
$endDate = $defaultEndDate->subPeriod(1, $period);
}
}
$lastN = $this->getMaxN((int) $lastN);
// last1 means only one result ; last2 means 2 results so we remove only 1 to the days/weeks/etc
$lastN--;
if ($lastN < 0) {
$lastN = 0;
}
$startDate = $endDate->addPeriod(-1 * $lastN, $period);
} elseif ($dateRange = Range::parseDateRange($this->strDate)) {
$strDateStart = $dateRange[1];
$strDateEnd = $dateRange[2];
$startDate = Date::factory($strDateStart);
// we set the timezone in the Date object only if the date is relative eg. 'today', 'yesterday', 'now'
$timezone = null;
if (strpos($strDateEnd, '-') === false) {
$timezone = $this->timezone;
}
$endDate = Date::factory($strDateEnd, $timezone)->setTime("00:00:00");
$maxAllowedEndDate = Date::factory(self::getMaxAllowedEndTimestamp());
if ($endDate->isLater($maxAllowedEndDate)) {
$endDate = $maxAllowedEndDate;
}
} else {
throw new Exception($this->translator->translate('General_ExceptionInvalidDateRange', array($this->strDate, ' \'lastN\', \'previousN\', \'YYYY-MM-DD,YYYY-MM-DD\'')));
}
if ($this->strPeriod != 'range') {
$this->fillArraySubPeriods($startDate, $endDate, $this->strPeriod);
$this->cacheAll();
return;
}
$this->processOptimalSubperiods($startDate, $endDate);
// When period=range, we want End Date to be the actual specified end date,
// rather than the end of the month / week / whatever is used for processing this range
$this->endDate = $endDate;
$this->cacheAll();
}
/**
* Given a date string, returns `false` if not a date range,
* or returns the array containing start and end dates.
*
* @param string $dateString
* @return mixed array(1 => dateStartString, 2 => dateEndString) or `false` if the input was not a date range.
*/
public static function parseDateRange($dateString)
{
$matched = preg_match('/^((?:[0-9]{4}-[0-9]{1,2}-[0-9]{1,2})|last[ -]?(?:week|month|year)),((?:[0-9]{4}-[0-9]{1,2}-[0-9]{1,2})|today|now|yesterday|last[ -]?(?:week|month|year))$/Di', trim($dateString), $regs);
if (empty($matched)) {
return false;
}
return $regs;
}
protected $endDate = null;
/**
* Returns the end date of the period.
*
* @return null|Date
*/
public function getDateEnd()
{
if (!is_null($this->endDate)) {
return $this->endDate;
}
return parent::getDateEnd();
}
/**
* Determine which kind of period is best to use.
* See Range.test.php
*
* @param Date $startDate
* @param Date $endDate
*/
protected function processOptimalSubperiods($startDate, $endDate)
{
while (
$startDate->isEarlier($endDate)
|| $startDate == $endDate
) {
$endOfPeriod = null;
$month = new Month($startDate);
$endOfMonth = $month->getDateEnd();
$startOfMonth = $month->getDateStart();
$year = new Year($startDate);
$endOfYear = $year->getDateEnd();
$startOfYear = $year->getDateStart();
if (
$startDate == $startOfYear
&& ($endOfYear->isEarlier($endDate)
|| $endOfYear == $endDate
|| $endOfYear->isLater($this->today)
)
// We don't use the year if
// the end day is in this year, is before today, and year not finished
&& !($endDate->isEarlier($this->today)
&& $this->today->toString('Y') == $endOfYear->toString('Y')
&& $this->today->compareYear($endOfYear) == 0)
) {
$this->addSubperiod($year);
$endOfPeriod = $endOfYear;
} elseif (
$startDate == $startOfMonth
&& ($endOfMonth->isEarlier($endDate)
|| $endOfMonth == $endDate
|| $endOfMonth->isLater($this->today)
)
// We don't use the month if
// the end day is in this month, is before today, and month not finished
&& !($endDate->isEarlier($this->today)
&& $this->today->toString('Y') == $endOfMonth->toString('Y')
&& $this->today->compareMonth($endOfMonth) == 0)
) {
$this->addSubperiod($month);
$endOfPeriod = $endOfMonth;
} else {
// From start date,
// Process end of week
$week = new Week($startDate);
$startOfWeek = $week->getDateStart();
$endOfWeek = $week->getDateEnd();
$firstDayNextMonth = $startDate->addPeriod(2, 'month')->setDay(1);
$useMonthsNextIteration = $firstDayNextMonth->isEarlier($endDate);
if (
$useMonthsNextIteration
&& $endOfWeek->isLater($endOfMonth)
) {
$this->fillArraySubPeriods($startDate, $endOfMonth, 'day');
$endOfPeriod = $endOfMonth;
} elseif (
$this->isEndOfWeekLaterThanEndDate($endDate, $endOfWeek) &&
($endOfWeek->isEarlier($this->today) ||
$startOfWeek->toString() != $startDate->toString() ||
$endDate->isEarlier($this->today))
) {
// If end of this week is later than end date, we use days
$this->fillArraySubPeriods($startDate, $endDate, 'day');
break 1;
} elseif (
$startOfWeek->isEarlier($startDate)
&& $endOfWeek->isEarlier($this->today)
) {
$this->fillArraySubPeriods($startDate, $endOfWeek, 'day');
$endOfPeriod = $endOfWeek;
} else {
$this->addSubperiod($week);
$endOfPeriod = $endOfWeek;
}
}
$startDate = $endOfPeriod->addDay(1);
}
}
/**
* Adds new subperiods
*
* @param Date $startDate
* @param Date $endDate
* @param string $period
*/
protected function fillArraySubPeriods($startDate, $endDate, $period)
{
$arrayPeriods = array();
$endSubperiod = Period\Factory::build($period, $endDate);
$arrayPeriods[] = $endSubperiod;
// set end date to start of end period since we're comparing against start date.
$endDate = $endSubperiod->getDateStart();
while ($endDate->isLater($startDate)) {
$endDate = $endDate->addPeriod(-1, $period);
$subPeriod = Period\Factory::build($period, $endDate);
$arrayPeriods[] = $subPeriod;
}
$arrayPeriods = array_reverse($arrayPeriods);
foreach ($arrayPeriods as $period) {
$this->addSubperiod($period);
}
}
/**
* Returns the date that is one period before the supplied date.
*
* @param bool|string $date The date to get the last date of.
* @param bool|string $period The period to use (either 'day', 'week', 'month', 'year');
*
* @return array An array with two elements, a string for the date before $date and
* a Period instance for the period before $date.
* @api
*/
public static function getLastDate($date = false, $period = false)
{
return self::getDateXPeriodsAgo(1, $date, $period);
}
/**
* Returns the date that is X periods before the supplied date.
*
* @param bool|string $date The date to get the last date of.
* @param bool|string $period The period to use (either 'day', 'week', 'month', 'year');
* @param int $subXPeriods How many periods in the past the date should be, for instance 1 or 7.
* If sub period is 365 days and the current year is a leap year we assume you want to get the
* day one year ago and change the value to 366 days therefore.
*
* @return array An array with two elements, a string for the date before $date and
* a Period instance for the period before $date.
* @api
*/
public static function getDateXPeriodsAgo($subXPeriods, $date = false, $period = false)
{
if ($date === false) {
$date = Common::getRequestVar('date');
}
if ($period === false) {
$period = Common::getRequestVar('period');
}
if (365 == $subXPeriods && 'day' == $period && Date::factory($date)->isLeapYear()) {
$subXPeriods = 366;
}
if ($period === 'range') {
$rangePeriod = new Range($period, $date);
$daysDifference = self::getNumDaysDifference($rangePeriod->getDateStart(), $rangePeriod->getDateEnd());
$end = $rangePeriod->getDateStart()->subDay(1);
$from = $end->subDay($daysDifference);
return array("$from,$end", false);
}
// can't get the last date for range periods & dates that use lastN/previousN
$strLastDate = false;
$lastPeriod = false;
if (!preg_match('/(last|previous)([0-9]*)/', $date, $regs)) {
if (strpos($date, ',')) {
// date in the form of 2011-01-01,2011-02-02
$rangePeriod = new Range($period, $date);
$lastStartDate = $rangePeriod->getDateStart()->subPeriod($subXPeriods, $period);
$lastEndDate = $rangePeriod->getDateEnd()->subPeriod($subXPeriods, $period);
$strLastDate = "$lastStartDate,$lastEndDate";
} else {
$lastPeriod = Date::factory($date)->subPeriod($subXPeriods, $period);
$strLastDate = $lastPeriod->toString();
}
}
return array($strLastDate, $lastPeriod);
}
/**
* Return the number of days contained in this range
*
* @return int
* @throws Exception
*/
public function getDayCount()
{
return (self::getNumDaysDifference($this->getDateStart(), $this->getDateEnd()) + 1);
}
private static function getNumDaysDifference(Date $date1, Date $date2)
{
$days = (abs($date1->getTimestamp() - $date2->getTimestamp())) / 60 / 60 / 24;
return (int) round($days);
}
/**
* Returns a date range string given a period type, end date and number of periods
* the range spans over.
*
* @param string $period The sub period type, `'day'`, `'week'`, `'month'` and `'year'`.
* @param int $lastN The number of periods of type `$period` that the result range should
* span.
* @param string $endDate The desired end date of the range.
* @param \Piwik\Site $site The site whose timezone should be used.
* @return string The date range string, eg, `'2012-01-02,2013-01-02'`.
* @api
*/
public static function getRelativeToEndDate($period, $lastN, $endDate, $site)
{
$timezone = $site->getTimezone();
$last30Relative = new Range($period, $lastN, $timezone);
if (strpos($endDate, '-') === false) {
// eg today, yesterday, ... needs the timezone
$endDate = Date::factoryInTimezone($endDate, $timezone);
} else {
$endDate = Date::factory($endDate);
}
$last30Relative->setDefaultEndDate($endDate);
$date = $last30Relative->getDateStart()->toString() . "," . $last30Relative->getDateEnd()->toString();
return $date;
}
private function isEndOfWeekLaterThanEndDate($endDate, $endOfWeek)
{
$isEndOfWeekLaterThanEndDate = $endOfWeek->isLater($endDate);
$isEndDateAlsoEndOfWeek = ($endOfWeek->toString() == $endDate->toString());
$isEndOfWeekLaterThanEndDate = ($isEndOfWeekLaterThanEndDate
|| ($isEndDateAlsoEndOfWeek
&& $endDate->isLater($this->today)));
return $isEndOfWeekLaterThanEndDate;
}
/**
* Returns the date range string comprising two dates
*
* @return string eg, `'2012-01-01,2012-01-31'`.
*/
public function getRangeString()
{
$dateStart = $this->getDateStart();
$dateEnd = $this->getDateEnd();
return $dateStart->toString("Y-m-d") . "," . $dateEnd->toString("Y-m-d");
}
public function getImmediateChildPeriodLabel()
{
$subperiods = $this->getSubperiods();
return reset($subperiods)->getImmediateChildPeriodLabel();
}
public function getParentPeriodLabel()
{
return null;
}
/**
* Returns the max allowed end timestamp for a range. If an enddate after this timestamp is provided, Matomo will
* automatically lower the end date to the date returned by this method.
* The max supported timestamp is always set to end of the current year plus 10 years.
*
* @api
*/
public static function getMaxAllowedEndTimestamp(): int
{
return strtotime(
date('Y-12-31 00:00:00', strtotime('+10 year', Date::getNowTimestamp()))
);
}
}