958 lines
28 KiB
PHP
958 lines
28 KiB
PHP
<?php
|
|
/**
|
|
* CRON expression parser that can determine whether or not a CRON expression is
|
|
* due to run, the next run date and previous run date of a CRON expression.
|
|
* The determinations made by this class are accurate if checked run once per
|
|
* minute (seconds are dropped from date time comparisons).
|
|
*
|
|
* Schedule parts must map to:
|
|
* minute [0-59], hour [0-23], day of month, month [1-12|JAN-DEC], day of week
|
|
* [1-7|MON-SUN], and an optional year.
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
* @link http://en.wikipedia.org/wiki/Cron
|
|
*/
|
|
class CronExpression
|
|
{
|
|
const MINUTE = 0;
|
|
const HOUR = 1;
|
|
const DAY = 2;
|
|
const MONTH = 3;
|
|
const WEEKDAY = 4;
|
|
const YEAR = 5;
|
|
|
|
/**
|
|
* @var array CRON expression parts
|
|
*/
|
|
private $cronParts;
|
|
|
|
/**
|
|
* @var FieldFactory CRON field factory
|
|
*/
|
|
private $fieldFactory;
|
|
|
|
/**
|
|
* @var array Order in which to test of cron parts
|
|
*/
|
|
private static $order = array(self::YEAR, self::MONTH, self::DAY, self::WEEKDAY, self::HOUR, self::MINUTE);
|
|
|
|
/**
|
|
* Factory method to create a new CronExpression.
|
|
*
|
|
* @param string $expression The CRON expression to create. There are
|
|
* several special predefined values which can be used to substitute the
|
|
* CRON expression:
|
|
*
|
|
* @yearly, @annually) - Run once a year, midnight, Jan. 1 - 0 0 1 1 *
|
|
* @monthly - Run once a month, midnight, first of month - 0 0 1 * *
|
|
* @weekly - Run once a week, midnight on Sun - 0 0 * * 0
|
|
* @daily - Run once a day, midnight - 0 0 * * *
|
|
* @hourly - Run once an hour, first minute - 0 * * * *
|
|
* @param FieldFactory $fieldFactory (optional) Field factory to use
|
|
*
|
|
* @return CronExpression
|
|
*/
|
|
public static function factory($expression, FieldFactory $fieldFactory = null)
|
|
{
|
|
$mappings = array(
|
|
'@yearly' => '0 0 1 1 *',
|
|
'@annually' => '0 0 1 1 *',
|
|
'@monthly' => '0 0 1 * *',
|
|
'@weekly' => '0 0 * * 0',
|
|
'@daily' => '0 0 * * *',
|
|
'@hourly' => '0 * * * *'
|
|
);
|
|
|
|
if (isset($mappings[$expression])) {
|
|
$expression = $mappings[$expression];
|
|
}
|
|
|
|
return new self($expression, $fieldFactory ? $fieldFactory : new FieldFactory());
|
|
}
|
|
|
|
/**
|
|
* Parse a CRON expression
|
|
*
|
|
* @param string $expression CRON expression (e.g. '8 * * * *')
|
|
* @param FieldFactory $fieldFactory Factory to create cron fields
|
|
*/
|
|
public function __construct($expression, FieldFactory $fieldFactory)
|
|
{
|
|
$this->fieldFactory = $fieldFactory;
|
|
$this->setExpression($expression);
|
|
}
|
|
|
|
/**
|
|
* Set or change the CRON expression
|
|
*
|
|
* @param string $schedule CRON expression (e.g. 8 * * * *)
|
|
*
|
|
* @return CronExpression
|
|
* @throws InvalidArgumentException if not a valid CRON expression
|
|
*/
|
|
public function setExpression($value)
|
|
{
|
|
$this->cronParts = explode(' ', $value);
|
|
if (count($this->cronParts) < 5) {
|
|
throw new InvalidArgumentException(
|
|
$value . ' is not a valid CRON expression'
|
|
);
|
|
}
|
|
|
|
foreach ($this->cronParts as $position => $part) {
|
|
$this->setPart($position, $part);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set part of the CRON expression
|
|
*
|
|
* @param int $position The position of the CRON expression to set
|
|
* @param string $value The value to set
|
|
*
|
|
* @return CronExpression
|
|
* @throws InvalidArgumentException if the value is not valid for the part
|
|
*/
|
|
public function setPart($position, $value)
|
|
{
|
|
if (!$this->fieldFactory->getField($position)->validate($value)) {
|
|
throw new InvalidArgumentException(
|
|
'Invalid CRON field value ' . $value . ' as position ' . $position
|
|
);
|
|
}
|
|
|
|
$this->cronParts[$position] = $value;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get a next run date relative to the current date or a specific date
|
|
*
|
|
* @param string|DateTime $currentTime (optional) Relative calculation date
|
|
* @param int $nth (optional) Number of matches to skip before returning a
|
|
* matching next run date. 0, the default, will return the current
|
|
* date and time if the next run date falls on the current date and
|
|
* time. Setting this value to 1 will skip the first match and go to
|
|
* the second match. Setting this value to 2 will skip the first 2
|
|
* matches and so on.
|
|
* @param bool $allowCurrentDate (optional) Set to TRUE to return the
|
|
* current date if it matches the cron expression
|
|
*
|
|
* @return DateTime
|
|
* @throws RuntimeExpression on too many iterations
|
|
*/
|
|
public function getNextRunDate($currentTime = 'now', $nth = 0, $allowCurrentDate = false)
|
|
{
|
|
return $this->getRunDate($currentTime, $nth, false, $allowCurrentDate);
|
|
}
|
|
|
|
/**
|
|
* Get a previous run date relative to the current date or a specific date
|
|
*
|
|
* @param string|DateTime $currentTime (optional) Relative calculation date
|
|
* @param int $nth (optional) Number of matches to skip before returning
|
|
* @param bool $allowCurrentDate (optional) Set to TRUE to return the
|
|
* current date if it matches the cron expression
|
|
*
|
|
* @return DateTime
|
|
* @throws RuntimeExpression on too many iterations
|
|
* @see Cron\CronExpression::getNextRunDate
|
|
*/
|
|
public function getPreviousRunDate($currentTime = 'now', $nth = 0, $allowCurrentDate = false)
|
|
{
|
|
return $this->getRunDate($currentTime, $nth, true, $allowCurrentDate);
|
|
}
|
|
|
|
/**
|
|
* Get multiple run dates starting at the current date or a specific date
|
|
*
|
|
* @param int $total Set the total number of dates to calculate
|
|
* @param string|DateTime $currentTime (optional) Relative calculation date
|
|
* @param bool $invert (optional) Set to TRUE to retrieve previous dates
|
|
* @param bool $allowCurrentDate (optional) Set to TRUE to return the
|
|
* current date if it matches the cron expression
|
|
*
|
|
* @return array Returns an array of run dates
|
|
*/
|
|
public function getMultipleRunDates($total, $currentTime = 'now', $invert = false, $allowCurrentDate = false)
|
|
{
|
|
$matches = array();
|
|
for ($i = 0; $i < max(0, $total); $i++) {
|
|
$matches[] = $this->getRunDate($currentTime, $i, $invert, $allowCurrentDate);
|
|
}
|
|
|
|
return $matches;
|
|
}
|
|
|
|
/**
|
|
* Get all or part of the CRON expression
|
|
*
|
|
* @param string $part (optional) Specify the part to retrieve or NULL to
|
|
* get the full cron schedule string.
|
|
*
|
|
* @return string|null Returns the CRON expression, a part of the
|
|
* CRON expression, or NULL if the part was specified but not found
|
|
*/
|
|
public function getExpression($part = null)
|
|
{
|
|
if (null === $part) {
|
|
return implode(' ', $this->cronParts);
|
|
} else if (array_key_exists($part, $this->cronParts)) {
|
|
return $this->cronParts[$part];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Helper method to output the full expression.
|
|
*
|
|
* @return string Full CRON expression
|
|
*/
|
|
public function __toString()
|
|
{
|
|
return $this->getExpression();
|
|
}
|
|
|
|
/**
|
|
* Deterime if the cron is due to run based on the current date or a
|
|
* specific date. This method assumes that the current number of
|
|
* seconds are irrelevant, and should be called once per minute.
|
|
*
|
|
* @param string|DateTime $currentTime (optional) Relative calculation date
|
|
*
|
|
* @return bool Returns TRUE if the cron is due to run or FALSE if not
|
|
*/
|
|
public function isDue($currentTime = null)
|
|
{
|
|
if (null === $currentTime || 'now' === $currentTime) {
|
|
$currentDate = date('Y-m-d H:i');
|
|
$currentTime = strtotime($currentDate);
|
|
} else if ($currentTime instanceof DateTime) {
|
|
$currentDate = $currentTime->format('Y-m-d H:i');
|
|
$currentTime = strtotime($currentDate);
|
|
} else {
|
|
$currentTime = new DateTime($currentTime);
|
|
$currentTime->setTime($currentTime->format('H'), $currentTime->format('i'), 0);
|
|
$currentDate = $currentTime->format('Y-m-d H:i');
|
|
$currentTime = $currentTime->getTimeStamp();
|
|
}
|
|
|
|
return $this->getNextRunDate($currentDate, 0, true)->getTimestamp() == $currentTime;
|
|
}
|
|
|
|
/**
|
|
* Get the next or previous run date of the expression relative to a date
|
|
*
|
|
* @param string|DateTime $currentTime (optional) Relative calculation date
|
|
* @param int $nth (optional) Number of matches to skip before returning
|
|
* @param bool $invert (optional) Set to TRUE to go backwards in time
|
|
* @param bool $allowCurrentDate (optional) Set to TRUE to return the
|
|
* current date if it matches the cron expression
|
|
*
|
|
* @return DateTime
|
|
* @throws RuntimeExpression on too many iterations
|
|
*/
|
|
protected function getRunDate($currentTime = null, $nth = 0, $invert = false, $allowCurrentDate = false)
|
|
{
|
|
$currentDate = $currentTime instanceof DateTime
|
|
? $currentTime
|
|
: new DateTime($currentTime ? $currentTime : 'now');
|
|
|
|
// set the timezone
|
|
$currentDate->setTimezone(new DateTimeZone(date_default_timezone_get()));
|
|
|
|
$currentDate->setTime($currentDate->format('H'), $currentDate->format('i'), 0);
|
|
$nextRun = clone $currentDate;
|
|
$nth = (int) $nth;
|
|
|
|
// Set a hard limit to bail on an impossible date
|
|
for ($i = 0; $i < 1000; $i++) {
|
|
|
|
foreach (self::$order as $position) {
|
|
$part = $this->getExpression($position);
|
|
if (null === $part) {
|
|
continue;
|
|
}
|
|
|
|
$satisfied = false;
|
|
// Get the field object used to validate this part
|
|
$field = $this->fieldFactory->getField($position);
|
|
// Check if this is singular or a list
|
|
if (strpos($part, ',') === false) {
|
|
$satisfied = $field->isSatisfiedBy($nextRun, $part);
|
|
} else {
|
|
foreach (array_map('trim', explode(',', $part)) as $listPart) {
|
|
if ($field->isSatisfiedBy($nextRun, $listPart)) {
|
|
$satisfied = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the field is not satisfied, then start over
|
|
if (!$satisfied) {
|
|
$field->increment($nextRun, $invert);
|
|
continue 2;
|
|
}
|
|
}
|
|
|
|
// Skip this match if needed
|
|
if ((!$allowCurrentDate && $nextRun == $currentDate) || --$nth > -1) {
|
|
$this->fieldFactory->getField(0)->increment($nextRun, $invert);
|
|
continue;
|
|
}
|
|
|
|
return $nextRun;
|
|
}
|
|
|
|
// @codeCoverageIgnoreStart
|
|
throw new RuntimeException('Impossible CRON expression');
|
|
// @codeCoverageIgnoreEnd
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Abstract CRON expression field
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
abstract class AbstractField implements FieldInterface
|
|
{
|
|
/**
|
|
* Check to see if a field is satisfied by a value
|
|
*
|
|
* @param string $dateValue Date value to check
|
|
* @param string $value Value to test
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isSatisfied($dateValue, $value)
|
|
{
|
|
if ($this->isIncrementsOfRanges($value)) {
|
|
return $this->isInIncrementsOfRanges($dateValue, $value);
|
|
} else if ($this->isRange($value)) {
|
|
return $this->isInRange($dateValue, $value);
|
|
}
|
|
|
|
return $value == '*' || $dateValue == $value;
|
|
}
|
|
|
|
/**
|
|
* Check if a value is a range
|
|
*
|
|
* @param string $value Value to test
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isRange($value)
|
|
{
|
|
return strpos($value, '-') !== false;
|
|
}
|
|
|
|
/**
|
|
* Check if a value is an increments of ranges
|
|
*
|
|
* @param string $value Value to test
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isIncrementsOfRanges($value)
|
|
{
|
|
return strpos($value, '/') !== false;
|
|
}
|
|
|
|
/**
|
|
* Test if a value is within a range
|
|
*
|
|
* @param string $dateValue Set date value
|
|
* @param string $value Value to test
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isInRange($dateValue, $value)
|
|
{
|
|
$parts = array_map('trim', explode('-', $value, 2));
|
|
|
|
return $dateValue >= $parts[0] && $dateValue <= $parts[1];
|
|
}
|
|
|
|
/**
|
|
* Test if a value is within an increments of ranges (offset[-to]/step size)
|
|
*
|
|
* @param string $dateValue Set date value
|
|
* @param string $value Value to test
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isInIncrementsOfRanges($dateValue, $value)
|
|
{
|
|
$parts = array_map('trim', explode('/', $value, 2));
|
|
$stepSize = isset($parts[1]) ? $parts[1] : 0;
|
|
if ($parts[0] == '*' || $parts[0] == 0) {
|
|
return (int) $dateValue % $stepSize == 0;
|
|
}
|
|
|
|
$range = explode('-', $parts[0], 2);
|
|
$offset = $range[0];
|
|
$to = isset($range[1]) ? $range[1] : $dateValue;
|
|
// Ensure that the date value is within the range
|
|
if ($dateValue < $offset || $dateValue > $to) {
|
|
return false;
|
|
}
|
|
|
|
for ($i = $offset; $i <= $to; $i+= $stepSize) {
|
|
if ($i == $dateValue) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* CRON field interface
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
interface FieldInterface
|
|
{
|
|
/**
|
|
* Check if the respective value of a DateTime field satisfies a CRON exp
|
|
*
|
|
* @param DateTime $date DateTime object to check
|
|
* @param string $value CRON expression to test against
|
|
*
|
|
* @return bool Returns TRUE if satisfied, FALSE otherwise
|
|
*/
|
|
function isSatisfiedBy(DateTime $date, $value);
|
|
|
|
/**
|
|
* When a CRON expression is not satisfied, this method is used to increment
|
|
* or decrement a DateTime object by the unit of the cron field
|
|
*
|
|
* @param DateTime $date DateTime object to change
|
|
* @param bool $invert (optional) Set to TRUE to decrement
|
|
*
|
|
* @return FieldInterface
|
|
*/
|
|
function increment(DateTime $date, $invert = false);
|
|
|
|
/**
|
|
* Validates a CRON expression for a given field
|
|
*
|
|
* @param string $value CRON expression value to validate
|
|
*
|
|
* @return bool Returns TRUE if valid, FALSE otherwise
|
|
*/
|
|
function validate($value);
|
|
}
|
|
|
|
/**
|
|
* CRON field factory implementating a flyweight factory
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
* @link http://en.wikipedia.org/wiki/Cron
|
|
*/
|
|
class FieldFactory
|
|
{
|
|
/**
|
|
* @var array Cache of instantiated fields
|
|
*/
|
|
private $fields = array();
|
|
|
|
/**
|
|
* Get an instance of a field object for a cron expression position
|
|
*
|
|
* @param int $position CRON expression position value to retrieve
|
|
*
|
|
* @return FieldInterface
|
|
* @throws InvalidArgumentException if a position is not valide
|
|
*/
|
|
public function getField($position)
|
|
{
|
|
if (!isset($this->fields[$position])) {
|
|
switch ($position) {
|
|
case 0:
|
|
$this->fields[$position] = new MinutesField();
|
|
break;
|
|
case 1:
|
|
$this->fields[$position] = new HoursField();
|
|
break;
|
|
case 2:
|
|
$this->fields[$position] = new DayOfMonthField();
|
|
break;
|
|
case 3:
|
|
$this->fields[$position] = new MonthField();
|
|
break;
|
|
case 4:
|
|
$this->fields[$position] = new DayOfWeekField();
|
|
break;
|
|
case 5:
|
|
$this->fields[$position] = new YearField();
|
|
break;
|
|
default:
|
|
throw new InvalidArgumentException(
|
|
$position . ' is not a valid position'
|
|
);
|
|
}
|
|
}
|
|
|
|
return $this->fields[$position];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Day of month field. Allows: * , / - ? L W
|
|
*
|
|
* 'L' stands for "last" and specifies the last day of the month.
|
|
*
|
|
* The 'W' character is used to specify the weekday (Monday-Friday) nearest the
|
|
* given day. As an example, if you were to specify "15W" as the value for the
|
|
* day-of-month field, the meaning is: "the nearest weekday to the 15th of the
|
|
* month". So if the 15th is a Saturday, the trigger will fire on Friday the
|
|
* 14th. If the 15th is a Sunday, the trigger will fire on Monday the 16th. If
|
|
* the 15th is a Tuesday, then it will fire on Tuesday the 15th. However if you
|
|
* specify "1W" as the value for day-of-month, and the 1st is a Saturday, the
|
|
* trigger will fire on Monday the 3rd, as it will not 'jump' over the boundary
|
|
* of a month's days. The 'W' character can only be specified when the
|
|
* day-of-month is a single day, not a range or list of days.
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
class DayOfMonthField extends AbstractField
|
|
{
|
|
/**
|
|
* Get the last day of the month
|
|
*
|
|
* @param DateTime $date Date object to check
|
|
*
|
|
* @param return int returns the last day of the month
|
|
*/
|
|
public static function getLastDayOfMonth(DateTime $date)
|
|
{
|
|
$month = $date->format('n');
|
|
if ($month == 2) {
|
|
return (bool) $date->format('L') ? 29 : 28;
|
|
} else {
|
|
$dates = array(
|
|
1 => 31,
|
|
3 => 31,
|
|
4 => 30,
|
|
5 => 31,
|
|
6 => 30,
|
|
7 => 31,
|
|
8 => 31,
|
|
9 => 30,
|
|
10 => 31,
|
|
11 => 30,
|
|
12 => 31
|
|
);
|
|
|
|
return $dates[$month];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the nearest day of the week for a given day in a month
|
|
*
|
|
* @param int $currentYear Current year
|
|
* @param int $currentYear Current month
|
|
* @param int $targetDay Target day of the month
|
|
*
|
|
* @return DateTime Returns the nearest date
|
|
*/
|
|
private static function getNearestWeekday($currentYear, $currentMonth, $targetDay)
|
|
{
|
|
$tday = str_pad($targetDay, 2, '0', STR_PAD_LEFT);
|
|
$target = DateTime::createFromFormat('Y-m-d', "$currentYear-$currentMonth-$tday");
|
|
$currentWeekday = (int) $target->format('N');
|
|
|
|
if ($currentWeekday < 6) {
|
|
return $target;
|
|
}
|
|
|
|
$lastDayOfMonth = self::getLastDayOfMonth($target);
|
|
|
|
foreach (array(-1, 1, -2, 2) as $i) {
|
|
$adjusted = $targetDay + $i;
|
|
if ($adjusted > 0 && $adjusted <= $lastDayOfMonth) {
|
|
$target->setDate($currentYear, $currentMonth, $adjusted);
|
|
if ($target->format('N') < 6 && $target->format('m') == $currentMonth) {
|
|
return $target;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isSatisfiedBy(DateTime $date, $value)
|
|
{
|
|
// ? states that the field value is to be skipped
|
|
if ($value == '?') {
|
|
return true;
|
|
}
|
|
|
|
$fieldValue = $date->format('d');
|
|
|
|
// Check to see if this is the last day of the month
|
|
if ($value == 'L') {
|
|
return $fieldValue == self::getLastDayOfMonth($date);
|
|
}
|
|
|
|
// Check to see if this is the nearest weekday to a particular value
|
|
if (strpos($value, 'W')) {
|
|
// Parse the target day
|
|
$targetDay = substr($value, 0, strpos($value, 'W'));
|
|
// Find out if the current day is the nearest day of the week
|
|
return $date->format('j') == self::getNearestWeekday($date->format('Y'), $date->format('m'), $targetDay)->format('j');
|
|
}
|
|
|
|
return $this->isSatisfied($date->format('d'), $value);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function increment(DateTime $date, $invert = false)
|
|
{
|
|
if ($invert) {
|
|
$date->modify('-1 day');
|
|
$date->setTime(23, 59, 0);
|
|
} else {
|
|
$date->modify('+1 day');
|
|
$date->setTime(0, 0, 0);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function validate($value)
|
|
{
|
|
return (bool) preg_match('/[\*,\/\-\?LW0-9A-Za-z]+/', $value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Day of week field. Allows: * / , - ? L #
|
|
*
|
|
* Days of the week can be represented as a number 0-7 (0|7 = Sunday)
|
|
* or as a three letter string: SUN, MON, TUE, WED, THU, FRI, SAT.
|
|
*
|
|
* 'L' stands for "last". It allows you to specify constructs such as
|
|
* "the last Friday" of a given month.
|
|
*
|
|
* '#' is allowed for the day-of-week field, and must be followed by a
|
|
* number between one and five. It allows you to specify constructs such as
|
|
* "the second Friday" of a given month.
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
class DayOfWeekField extends AbstractField
|
|
{
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isSatisfiedBy(DateTime $date, $value)
|
|
{
|
|
if ($value == '?') {
|
|
return true;
|
|
}
|
|
|
|
// Convert text day of the week values to integers
|
|
$value = strtr($value, array(
|
|
'SUN' => 0,
|
|
'MON' => 1,
|
|
'TUE' => 2,
|
|
'WED' => 3,
|
|
'THU' => 4,
|
|
'FRI' => 5,
|
|
'SAT' => 6
|
|
));
|
|
|
|
$currentYear = $date->format('Y');
|
|
$currentMonth = $date->format('m');
|
|
$lastDayOfMonth = DayOfMonthField::getLastDayOfMonth($date);
|
|
|
|
// Find out if this is the last specific weekday of the month
|
|
if (strpos($value, 'L')) {
|
|
$weekday = str_replace('7', '0', substr($value, 0, strpos($value, 'L')));
|
|
$tdate = clone $date;
|
|
$tdate->setDate($currentYear, $currentMonth, $lastDayOfMonth);
|
|
while ($tdate->format('w') != $weekday) {
|
|
$tdate->setDate($currentYear, $currentMonth, --$lastDayOfMonth);
|
|
}
|
|
|
|
return $date->format('j') == $lastDayOfMonth;
|
|
}
|
|
|
|
// Handle # hash tokens
|
|
if (strpos($value, '#')) {
|
|
list($weekday, $nth) = explode('#', $value);
|
|
// Validate the hash fields
|
|
if ($weekday < 1 || $weekday > 5) {
|
|
throw new InvalidArgumentException("Weekday must be a value between 1 and 5. {$weekday} given");
|
|
}
|
|
if ($nth > 5) {
|
|
throw new InvalidArgumentException('There are never more than 5 of a given weekday in a month');
|
|
}
|
|
// The current weekday must match the targeted weekday to proceed
|
|
if ($date->format('N') != $weekday) {
|
|
return false;
|
|
}
|
|
|
|
$tdate = clone $date;
|
|
$tdate->setDate($currentYear, $currentMonth, 1);
|
|
$dayCount = 0;
|
|
$currentDay = 1;
|
|
while ($currentDay < $lastDayOfMonth + 1) {
|
|
if ($tdate->format('N') == $weekday) {
|
|
if (++$dayCount >= $nth) {
|
|
break;
|
|
}
|
|
}
|
|
$tdate->setDate($currentYear, $currentMonth, ++$currentDay);
|
|
}
|
|
|
|
return $date->format('j') == $currentDay;
|
|
}
|
|
|
|
// Handle day of the week values
|
|
if (strpos($value, '-')) {
|
|
$parts = explode('-', $value);
|
|
if ($parts[0] == '7') {
|
|
$parts[0] = '0';
|
|
} else if ($parts[1] == '0') {
|
|
$parts[1] = '7';
|
|
}
|
|
$value = implode('-', $parts);
|
|
}
|
|
|
|
// Test to see which Sunday to use -- 0 == 7 == Sunday
|
|
$format = in_array(7, str_split($value)) ? 'N' : 'w';
|
|
$fieldValue = $date->format($format);
|
|
|
|
return $this->isSatisfied($fieldValue, $value);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function increment(DateTime $date, $invert = false)
|
|
{
|
|
if ($invert) {
|
|
$date->modify('-1 day');
|
|
$date->setTime(23, 59, 0);
|
|
} else {
|
|
$date->modify('+1 day');
|
|
$date->setTime(0, 0, 0);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function validate($value)
|
|
{
|
|
return (bool) preg_match('/[\*,\/\-0-9A-Z]+/', $value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hours field. Allows: * , / -
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
class HoursField extends AbstractField
|
|
{
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isSatisfiedBy(DateTime $date, $value)
|
|
{
|
|
return $this->isSatisfied($date->format('H'), $value);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function increment(DateTime $date, $invert = false)
|
|
{
|
|
if ($invert) {
|
|
$date->modify('-1 hour');
|
|
$date->setTime($date->format('H'), 59, 0);
|
|
} else {
|
|
$date->modify('+1 hour');
|
|
$date->setTime($date->format('H'), 0, 0);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function validate($value)
|
|
{
|
|
return (bool) preg_match('/[\*,\/\-0-9]+/', $value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Minutes field. Allows: * , / -
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
class MinutesField extends AbstractField
|
|
{
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isSatisfiedBy(DateTime $date, $value)
|
|
{
|
|
return $this->isSatisfied($date->format('i'), $value);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function increment(DateTime $date, $invert = false)
|
|
{
|
|
if ($invert) {
|
|
$date->modify('-1 minute');
|
|
} else {
|
|
$date->modify('+1 minute');
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function validate($value)
|
|
{
|
|
return (bool) preg_match('/[\*,\/\-0-9]+/', $value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Month field. Allows: * , / -
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
class MonthField extends AbstractField
|
|
{
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isSatisfiedBy(DateTime $date, $value)
|
|
{
|
|
// Convert text month values to integers
|
|
$value = strtr($value, array(
|
|
'JAN' => 1,
|
|
'FEB' => 2,
|
|
'MAR' => 3,
|
|
'APR' => 4,
|
|
'MAY' => 5,
|
|
'JUN' => 6,
|
|
'JUL' => 7,
|
|
'AUG' => 8,
|
|
'SEP' => 9,
|
|
'OCT' => 10,
|
|
'NOV' => 11,
|
|
'DEC' => 12
|
|
));
|
|
|
|
return $this->isSatisfied($date->format('m'), $value);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function increment(DateTime $date, $invert = false)
|
|
{
|
|
$year = $date->format('Y');
|
|
if ($invert) {
|
|
$month = $date->format('m') - 1;
|
|
if ($month < 1) {
|
|
$month = 12;
|
|
$year--;
|
|
}
|
|
$date->setDate($year, $month, 1);
|
|
$date->setDate($year, $month, DayOfMonthField::getLastDayOfMonth($date));
|
|
$date->setTime(23, 59, 0);
|
|
} else {
|
|
$month = $date->format('m') + 1;
|
|
if ($month > 12) {
|
|
$month = 1;
|
|
$year++;
|
|
}
|
|
$date->setDate($year, $month, 1);
|
|
$date->setTime(0, 0, 0);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function validate($value)
|
|
{
|
|
return (bool) preg_match('/[\*,\/\-0-9A-Z]+/', $value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Year field. Allows: * , / -
|
|
*
|
|
* @author Michael Dowling <mtdowling@gmail.com>
|
|
*/
|
|
class YearField extends AbstractField
|
|
{
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isSatisfiedBy(DateTime $date, $value)
|
|
{
|
|
return $this->isSatisfied($date->format('Y'), $value);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function increment(DateTime $date, $invert = false)
|
|
{
|
|
if ($invert) {
|
|
$date->modify('-1 year');
|
|
$date->setDate($date->format('Y'), 12, 31);
|
|
$date->setTime(23, 59, 0);
|
|
} else {
|
|
$date->modify('+1 year');
|
|
$date->setDate($date->format('Y'), 1, 1);
|
|
$date->setTime(0, 0, 0);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function validate($value)
|
|
{
|
|
return (bool) preg_match('/[\*,\/\-0-9]+/', $value);
|
|
}
|
|
}
|