DateLib.php

См. документацию.

<?php
 
namespace Bitrix\Bizproc\Calc\Libs;
 
use Bitrix\Main;
use Bitrix\Bizproc;
use Bitrix\Bizproc\Calc\Arguments;
use Bitrix\Main\Localization\Loc;
 
class DateLib extends BaseLib
{
    private static $weekHolidays;
    private static $yearHolidays;
    private static $startWorkDay;
    private static $endWorkDay;
    private static $yearWorkdays;
 
    private const ONE_HOUR = 3600;
    private const TWELVE_HOURS = 12 * self::ONE_HOUR;
 
    function getFunctions(): array
    {
        return [
            'date' => [
                'args' => true,
                'func' => 'callDate',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_DATE_DESCRIPTION'),
            ],
            'dateadd' => [
                'args' => true,
                'func' => 'callDateAdd',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_DATEADD_DESCRIPTION'),
            ],
            'datediff' => [
                'args' => true,
                'func' => 'callDateDiff',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_DATEDIFF_DESCRIPTION'),
            ],
            'addworkdays' => [
                'args' => true,
                'func' => 'callAddWorkDays',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_ADDWORKDAYS_DESCRIPTION'),
            ],
            'workdateadd' => [
                'args' => true,
                'func' => 'callWorkDateAdd',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_WORKDATEADD_DESCRIPTION'),
            ],
            'isworkday' => [
                'args' => true,
                'func' => 'callIsWorkDay',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_ISWORKDAY_DESCRIPTION'),
            ],
            'isworktime' => [
                'args' => true,
                'func' => 'callIsWorkTime',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_ISWORKTIME_DESCRIPTION'),
            ],
            'touserdate' => [
                'args' => true,
                'func' => 'callToUserDate',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_TOUSERDATE_DESCRIPTION'),
            ],
            'getuserdateoffset' => [
                'args' => true,
                'func' => 'callGetUserDateOffset',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_GETUSERDATEOFFSET_DESCRIPTION'),
            ],
            'strtotime' => [
                'args' => true,
                'func' => 'callStrtotime',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_STRTOTIME_DESCRIPTION'),
            ],
            'locdate' => [
                'args' => true,
                'func' => 'callLocDate',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_LOCDATE_DESCRIPTION'),
            ],
            'settime' => [
                'args' => true,
                'func' => 'callSetTime',
                'description' => Loc::getMessage('BIZPROC_CALC_FUNCTION_SETTIME_DESCRIPTION'),
            ],
        ];
    }
 
    public function callDateAdd(Arguments $args)
    {
        $date = $args->getFirstSingle();
        $offset = $this->getDateTimeOffset($date);
        $date = $this->makeTimestamp($date);
        $interval = $args->getSecondSingle();
 
        if ($date === false || ($interval && !is_scalar($interval)))
        {
            return null;
        }
 
        if (empty($interval))
        {
            return $date; // new Bizproc\BaseType\Value\DateTime($date, $offset);
        }
 
        // 1Y2M3D4H5I6S, -4 days 5 hours, 1month, 5h
 
        $interval = trim($interval);
        $bMinus = false;
        if (mb_substr($interval, 0, 1) === "-")
        {
            $interval = mb_substr($interval, 1);
            $bMinus = true;
        }
 
        static $arMap = [
            "y" => "YYYY",
            "year" => "YYYY",
            "years" => "YYYY",
            "m" => "MM",
            "month" => "MM",
            "months" => "MM",
            "d" => "DD",
            "day" => "DD",
            "days" => "DD",
            "h" => "HH",
            "hour" => "HH",
            "hours" => "HH",
            "i" => "MI",
            "min" => "MI",
            "minute" => "MI",
            "minutes" => "MI",
            "s" => "SS",
            "sec" => "SS",
            "second" => "SS",
            "seconds" => "SS",
        ];
 
        $arInterval = [];
        while (preg_match('/\s*([\d]+)\s*([a-z]+)\s*/i', $interval, $match))
        {
            $match2 = mb_strtolower($match[2]);
            if (array_key_exists($match2, $arMap))
            {
                $arInterval[$arMap[$match2]] = ($bMinus ? -intval($match[1]) : intval($match[1]));
            }
 
            $p = mb_strpos($interval, $match[0]);
            $interval = mb_substr($interval, $p + mb_strlen($match[0]));
        }
 
        $date += $offset; // to server
 
        $newDate = AddToTimeStamp($arInterval, $date);
 
        $newDate -= $offset; // to user timezone
 
        return new Bizproc\BaseType\Value\DateTime($newDate, $offset);
    }
 
    public function callWorkDateAdd(Arguments $args)
    {
        $date = $args->getFirstSingle();
        $offset = $this->getDateTimeOffset($date);
        $paramInterval = $args->getSecondSingle();
        $user = $args->getThird();
 
        if ($user)
        {
            $userArgs = clone $args;
            $userArgs->setArgs([$user, $date]);
 
            $date = $this->callToUserDate($userArgs);
            $offset = $this->getDateTimeOffset($date);
        }
 
        $date = $this->makeTimestamp($date, true);
 
        if ($date === false || ($paramInterval && !is_scalar($paramInterval)))
        {
            return null;
        }
 
        if (empty($paramInterval) || !Main\Loader::includeModule('calendar'))
        {
            return $date;
        }
 
        $paramInterval = trim($paramInterval);
        $multiplier = 1;
        if (mb_substr($paramInterval, 0, 1) === "-")
        {
            $paramInterval = mb_substr($paramInterval, 1);
            $multiplier = -1;
        }
 
        $workDayInterval = $this->getWorkDayInterval();
        $intervalMap = [
            "d" => $workDayInterval,
            "day" => $workDayInterval,
            "days" => $workDayInterval,
            "h" => 3600,
            "hour" => 3600,
            "hours" => 3600,
            "i" => 60,
            "min" => 60,
            "minute" => 60,
            "minutes" => 60,
        ];
 
        $interval = 0;
        while (preg_match('/\s*([\d]+)\s*([a-z]+)\s*/i', $paramInterval, $match))
        {
            $match2 = mb_strtolower($match[2]);
            if (array_key_exists($match2, $intervalMap))
            {
                $interval += intval($match[1]) * $intervalMap[$match2];
            }
 
            $p = mb_strpos($paramInterval, $match[0]);
            $paramInterval = mb_substr($paramInterval, $p + mb_strlen($match[0]));
        }
 
        if (date('H:i:s', $date) === '00:00:00')
        {
            //add start work day seconds
            $date += $this->getCalendarWorkTime()[0];
        }
 
        $date = $this->getNearestWorkTime($date, $multiplier);
        if ($interval)
        {
            $days = (int)floor($interval / $workDayInterval);
            $hours = $interval % $workDayInterval;
 
            $remainTimestamp = $this->getWorkDayRemainTimestamp($date, $multiplier);
 
            if ($days)
            {
                $date = $this->addWorkDay($date, $days * $multiplier);
            }
 
            if ($hours > $remainTimestamp)
            {
                $date += $multiplier < 0 ? -$remainTimestamp - 60 : $remainTimestamp + 60;
                $date = $this->getNearestWorkTime($date, $multiplier) + (($hours - $remainTimestamp) * $multiplier);
            }
            else
            {
                $date += $multiplier * $hours;
            }
        }
 
        $date -= $offset;
 
        return new Bizproc\BaseType\Value\DateTime($date, $offset);
    }
 
    public function callAddWorkDays(Arguments $args)
    {
        $date = $args->getFirstSingle();
        $offset = $this->getDateTimeOffset($date);
        $days = (int)$args->getSecond();
 
        if (($date = $this->makeTimestamp($date)) === false)
        {
            return null;
        }
 
        if ($days === 0 || !Main\Loader::includeModule('calendar'))
        {
            return $date;
        }
 
        $date = $this->addWorkDay($date, $days);
 
        return new Bizproc\BaseType\Value\DateTime($date, $offset);
    }
 
    public function callIsWorkDay(Arguments $args)
    {
        if (!Main\Loader::includeModule('calendar'))
        {
            return false;
        }
 
        $date = $args->getFirstSingle();
        $user = $args->getSecond();
 
        if ($user)
        {
            $userArgs = clone $args;
            $userArgs->setArgs([$user, $date]);
 
            $date = $this->callToUserDate($userArgs);
        }
 
        if (($date = $this->makeTimestamp($date, true)) === false)
        {
            return false;
        }
 
        return !$this->isHoliday($date);
    }
 
    public function callIsWorkTime(Arguments $args)
    {
        if (!Main\Loader::includeModule('calendar'))
        {
            return false;
        }
 
        $date = $args->getFirstSingle();
        $user = $args->getSecond();
 
        if ($user)
        {
            $userArgs = clone $args;
            $userArgs->setArgs([$user, $date]);
 
            $date = $this->callToUserDate($userArgs);
        }
 
        if (($date = $this->makeTimestamp($date, true)) === false)
        {
            return false;
        }
 
        return !$this->isHoliday($date) && $this->isWorkTime($date);
    }
 
    public function callDateDiff(Arguments $args)
    {
        $date1 = $args->getFirstSingle();
        $date2 = $args->getSecondSingle();
        $format = $args->getThird();
 
        if (!$date1 || !$date2 || !is_scalar($format))
        {
            return null;
        }
 
        $date1Formatted = $this->getDateTimeObject($date1);
        $date2Formatted = $this->getDateTimeObject($date2);
 
        if ($date1Formatted === false || $date2Formatted === false)
        {
            return null;
        }
 
        $interval = $date1Formatted->diff($date2Formatted);
 
        return $interval === false ? null : $interval->format($format);
    }
 
    public function callDate(Arguments $args)
    {
        $format = $args->getFirst();
        $date = $args->getSecondSingle();
 
        if (!$format || !is_string($format))
        {
            return null;
        }
 
        $ts = $date ? $this->makeTimestamp($date, true) : time();
 
        if (!$ts)
        {
            return null;
        }
 
        return date($format, $ts);
    }
 
    public function callToUserDate(Arguments $args)
    {
        $user = $args->getFirst();
        $date = $args->getSecondSingle();
 
        if (!$user)
        {
            return null;
        }
 
        if (!$date)
        {
            $date = time();
        }
        elseif (($date = $this->makeTimestamp($date)) === false)
        {
            return null;
        }
 
        $userId = \CBPHelper::extractFirstUser($user, $args->getParser()->getActivity()->getDocumentId());
        $offset = $userId ? \CTimeZone::GetOffset($userId, true) : 0;
 
        return new Bizproc\BaseType\Value\DateTime($date, $offset);
    }
 
    public function callGetUserDateOffset(Arguments $args)
    {
        $user = $args->getFirst();
 
        if (!$user)
        {
            return null;
        }
 
        $userId = \CBPHelper::extractFirstUser($user, $args->getParser()->getActivity()->getDocumentId());
 
        if (!$userId)
        {
            return 0;
        }
 
        return \CTimeZone::GetOffset($userId, true);
    }
 
    public function callStrtotime(Arguments $args)
    {
        $datetime = $args->getFirstSingle();
        $baseDate = $args->getSecondSingle();
 
        $baseTimestamp = $baseDate ? $this->makeTimestamp($baseDate, true) : time();
 
        if (!$baseTimestamp || !is_scalar($datetime))
        {
            return null;
        }
 
        $timestamp = strtotime($datetime, (int)$baseTimestamp);
 
        if ($timestamp === false)
        {
            return null;
        }
 
        return new Bizproc\BaseType\Value\DateTime($timestamp);
    }
 
    public function callLocDate(Arguments $args)
    {
        $format = $args->getFirst();
        $date = $args->getSecondSingle();
 
        if (!$format || !is_string($format))
        {
            return null;
        }
 
        $reformFormat = $this->frameSymbolsInDateFormat($format);
        $timestamp = $date ? $this->makeTimestamp($date, true) : time();
 
        if (!$timestamp)
        {
            return null;
        }
 
        $formattedDate = date($reformFormat, $timestamp);
        // return \FormatDate($format, $timestamp); - TODO
        if ($formattedDate === false)
        {
            return null;
        }
 
        return $this->replaceDateToLocDate($formattedDate, $reformFormat);
    }
 
    public function callSetTime(Arguments $args)
    {
        $date = $args->getFirstSingle();
        $currentOffset = $this->getDateTimeOffset($date);
 
        $hour = max(0, (int)$args->getSecondSingle());
        $minute = max(0, (int)$args->getThirdSingle());
 
        $timeOffset = $hour * self::ONE_HOUR + $minute * 60;
        $baseOffset = max(
            -1 * self::TWELVE_HOURS,
            min(self::TWELVE_HOURS, (int)$args->getArgSingle(3))
        );
 
        if ($baseOffset !== 0)
        {
            $timeOffset -= $baseOffset;
        }
 
        if (($date = $this->makeTimestamp($date, true)) === false)
        {
            return null;
        }
 
        $dateTime = Main\Type\DateTime::createFromTimestamp($date);
        $dateTime->setTime(0, 0, 0, 0);
 
        $date = $dateTime->getTimestamp() + $timeOffset;
 
        return new Bizproc\BaseType\Value\DateTime($date, $currentOffset);
    }
 
    private function makeTimestamp($date, $appendOffset = false)
    {
        if (!$date || (!is_scalar($date) && !is_object($date)))
        {
            return false;
        }
 
        //serialized date string
        if (is_string($date) && Bizproc\BaseType\Value\Date::isSerialized($date))
        {
            $date = new Bizproc\BaseType\Value\Date($date);
        }
 
        if ($date instanceof Bizproc\BaseType\Value\Date)
        {
            return $date->getTimestamp() + ($appendOffset ? $date->getOffset() : 0);
        }
 
        if (intval($date) . "!" === $date . "!")
        {
            return $date;
        }
 
        if (($result = MakeTimeStamp($date, FORMAT_DATETIME)) === false)
        {
            if (($result = MakeTimeStamp($date, FORMAT_DATE)) === false)
            {
                if (($result = MakeTimeStamp($date, "YYYY-MM-DD HH:MI:SS")) === false)
                {
                    $result = MakeTimeStamp($date, "YYYY-MM-DD");
                }
            }
        }
        return $result;
    }
 
    private function getWorkDayTimestamp($date)
    {
        return date('H', $date) * 3600 + date('i', $date) * 60;
    }
 
    private function getWorkDayRemainTimestamp($date, $multiplier = 1)
    {
        $dayTs = $this->getWorkDayTimestamp($date);
        [$startSeconds, $endSeconds] = $this->getCalendarWorkTime();
        return $multiplier < 0 ? $dayTs - $startSeconds : $endSeconds - $dayTs;
    }
 
    private function getWorkDayInterval()
    {
        [$startSeconds, $endSeconds] = $this->getCalendarWorkTime();
        return $endSeconds - $startSeconds;
    }
 
    private function isHoliday($date)
    {
        [$yearWorkdays] = $this->getCalendarWorkdays();
        [$weekHolidays, $yearHolidays] = $this->getCalendarHolidays();
 
        $dayOfYear = date('j.n', $date);
        if (in_array($dayOfYear, $yearWorkdays, true))
        {
            return false;
        }
 
        $dayOfWeek = date('w', $date);
        if (in_array($dayOfWeek, $weekHolidays))
        {
            return true;
        }
 
        $dayOfYear = date('j.n', $date);
        if (in_array($dayOfYear, $yearHolidays, true))
        {
            return true;
        }
 
        return false;
    }
 
    private function isWorkTime($date)
    {
        $dayTs = $this->getWorkDayTimestamp($date);
        [$startSeconds, $endSeconds] = $this->getCalendarWorkTime();
        return ($dayTs >= $startSeconds && $dayTs <= $endSeconds);
    }
 
    private function getNearestWorkTime($date, $multiplier = 1)
    {
        $reverse = $multiplier < 0;
        [$startSeconds, $endSeconds] = $this->getCalendarWorkTime();
        $dayTimeStamp = $this->getWorkDayTimestamp($date);
 
        if ($this->isHoliday($date))
        {
            $date -= $dayTimeStamp;
            $date += $reverse ? -86400 + $endSeconds : $startSeconds;
            $dayTimeStamp = $reverse ? $endSeconds : $startSeconds;
        }
 
        if (!$this->isWorkTime($date))
        {
            $date -= $dayTimeStamp;
 
            if ($dayTimeStamp < $startSeconds)
            {
                $date += $reverse ? -86400 + $endSeconds : $startSeconds;
            }
            else
            {
                $date += $reverse ? $endSeconds : 86400 + $startSeconds;
            }
        }
 
        if ($this->isHoliday($date))
        {
            $date = $this->addWorkDay($date, $reverse ? -1 : 1);
        }
 
        return $date;
    }
 
    private function addWorkDay($date, $days)
    {
        $delta = 86400;
        if ($days < 0)
        {
            $delta *= -1;
        }
 
        $days = abs($days);
        $iterations = 0;
 
        while ($days > 0 && $iterations < 1000)
        {
            ++$iterations;
            $date += $delta;
 
            if ($this->isHoliday($date))
            {
                continue;
            }
            --$days;
        }
 
        return $date;
    }
 
    private function getCalendarHolidays()
    {
        if (static::$yearHolidays === null)
        {
            $calendarSettings = \CCalendar::GetSettings();
            $weekHolidays = [0, 6];
            $yearHolidays = [];
 
            if (isset($calendarSettings['week_holidays']))
            {
                $weekDays = ['SU' => 0, 'MO' => 1, 'TU' => 2, 'WE' => 3, 'TH' => 4, 'FR' => 5, 'SA' => 6];
                $weekHolidays = [];
                foreach ($calendarSettings['week_holidays'] as $day)
                {
                    $weekHolidays[] = $weekDays[$day];
                }
            }
 
            if (isset($calendarSettings['year_holidays']))
            {
                foreach (explode(',', $calendarSettings['year_holidays']) as $yearHoliday)
                {
                    $date = explode('.', trim($yearHoliday));
                    if (count($date) == 2 && $date[0] && $date[1])
                    {
                        $yearHolidays[] = (int)$date[0] . '.' . (int)$date[1];
                    }
                }
            }
            static::$weekHolidays = $weekHolidays;
            static::$yearHolidays = $yearHolidays;
        }
 
        return [static::$weekHolidays, static::$yearHolidays];
    }
 
    private function getCalendarWorkTime()
    {
        if (static::$startWorkDay === null)
        {
            $startSeconds = 0;
            $endSeconds = 24 * 3600 - 1;
 
            $calendarSettings = \CCalendar::GetSettings();
            if (!empty($calendarSettings['work_time_start']))
            {
                $time = explode('.', $calendarSettings['work_time_start']);
                $startSeconds = $time[0] * 3600;
                if (!empty($time[1]))
                {
                    $startSeconds += $time[1] * 60;
                }
            }
 
            if (!empty($calendarSettings['work_time_end']))
            {
                $time = explode('.', $calendarSettings['work_time_end']);
                $endSeconds = $time[0] * 3600;
                if (!empty($time[1]))
                {
                    $endSeconds += $time[1] * 60;
                }
            }
            static::$startWorkDay = $startSeconds;
            static::$endWorkDay = $endSeconds;
        }
        return [static::$startWorkDay, static::$endWorkDay];
    }
 
    private function getCalendarWorkdays()
    {
        if (static::$yearWorkdays === null)
        {
            $yearWorkdays = [];
 
            $calendarSettings = \CCalendar::GetSettings();
            $calendarYearWorkdays = $calendarSettings['year_workdays'] ?? '';
 
            foreach (explode(',', $calendarYearWorkdays) as $yearWorkday)
            {
                $date = explode('.', trim($yearWorkday));
                if (count($date) === 2 && $date[0] && $date[1])
                {
                    $yearWorkdays[] = (int)$date[0] . '.' . (int)$date[1];
                }
            }
 
            static::$yearWorkdays = $yearWorkdays;
        }
 
        return [static::$yearWorkdays];
    }
 
    private function getDateTimeObject($date)
    {
        if ($date instanceof Bizproc\BaseType\Value\Date)
        {
            return (new \DateTime())->setTimestamp($date->getTimestamp());
        }
        elseif (is_array($date))
        {
            $date = \CBPHelper::flatten($date);
        }
 
        if (!is_scalar($date))
        {
            return false;
        }
 
        $df = Main\Type\DateTime::getFormat();
        $df2 = Main\Type\Date::getFormat();
        $date1Formatted = \DateTime::createFromFormat($df, $date);
        if ($date1Formatted === false)
        {
            $date1Formatted = \DateTime::createFromFormat($df2, $date);
            if ($date1Formatted)
            {
                $date1Formatted->setTime(0, 0);
            }
        }
        return $date1Formatted;
    }
 
    private function getDateTimeOffset($date)
    {
        if ($date instanceof Bizproc\BaseType\Value\Date)
        {
            return $date->getOffset();
        }
 
        return 0;
    }
 
    private function frameSymbolsInDateFormat($format)
    {
        $complexSymbols = ['j F', 'd F', 'jS F'];
        $symbols = ['D', 'l', 'F', 'M', 'r'];
 
        $frameRule = [];
        foreach ($symbols as $symbol)
        {
            $frameRule[$symbol] = '#' . $symbol . '#';
            $frameRule['\\' . $symbol] = '\\' . $symbol;
        }
        foreach ($complexSymbols as $symbol)
        {
            $frameRule[$symbol] = substr($symbol, 0, -1) . '#' . $symbol[-1] . '_1#';
            $frameRule['\\' . $symbol] = '\\' . substr($symbol, 0, -1) . '#' . $symbol[-1] . '#';
        }
 
        return strtr($format, $frameRule);
    }
 
    private function frameNamesInFormattedDateRFC2822($formattedDate)
    {
        $matches = [];
        $pattern = "/#(\w{3}), \d{2} (\w{3}) \d{4} \d{2}:\d{2}:\d{2} [+-]\d{4}#/";
        if (preg_match_all($pattern, $formattedDate, $matches))
        {
            foreach ($matches[0] as $key => $match)
            {
                $day = $matches[1][$key];
                $month = $matches[2][$key];
 
                $reformMatch = str_replace(
                    [$day, $month],
                    ['#' . $day . '#', '#' . $month . '#'],
                    $match
                );
                $reformMatch = substr($reformMatch, 1, -1);
 
                $formattedDate = str_replace($match, $reformMatch, $formattedDate);
            }
        }
 
        return $formattedDate;
    }
 
    private function replaceDateToLocDate($formattedDate, $format)
    {
        $lenShortName = 3;
        $dayNames = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
        $monthNames = [
            'January',
            'February',
            'March',
            'April',
            'May',
            'June',
            'July',
            'August',
            'September',
            'October',
            'November',
            'December',
        ];
 
        if (strpos($format, '#r#') !== false)
        {
            $formattedDate = $this->frameNamesInFormattedDateRFC2822($formattedDate);
        }
 
        $replacementRule = [];
        foreach (array_merge($dayNames, $monthNames) as $name)
        {
            $replacementRule['#' . $name . '#'] = Loc::getMessage(
                'BIZPROC_CALC_FUNCTION_LOCDATE_' . strtoupper($name)
            );
            $shortName = substr($name, 0, $lenShortName);
            $replacementRule['#' . $shortName . '#'] = Loc::getMessage(
                'BIZPROC_CALC_FUNCTION_LOCDATE_' . strtoupper($shortName) . '_SHORT'
            );
        }
        foreach ($monthNames as $monthName)
        {
            $replacementRule['#' . $monthName . '_1' . '#'] = Loc::getMessage(
                'BIZPROC_CALC_FUNCTION_LOCDATE_' . strtoupper($monthName) . '_1'
            );
        }
 
        return strtr($formattedDate, $replacementRule);
    }
}