accessibility.php

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

<?php
 
namespace Bitrix\Calendar\Core\Managers;
 
use Bitrix\Calendar\Access\ActionDictionary;
use Bitrix\Calendar\Access\EventAccessController;
use Bitrix\Calendar\Access\Model\EventModel;
use Bitrix\Calendar\Core\Event\Tools\Dictionary;
use Bitrix\Calendar\Sharing\Helper;
use Bitrix\Calendar\Util;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Type\DateTime;
 
class Accessibility
{
    private array $canSeeNameCache = [];
    private int $skipEventId = 0;
 
    public function setSkipEventId(int $curEventId): self
    {
        $this->skipEventId = $curEventId;
 
        return $this;
    }

    public function getBusyUsersIds(array $userIds, int $timestampFrom, int $timestampTo): array
    {
        $dateFromTs = $timestampFrom - ($timestampFrom % \CCalendar::DAY_LENGTH);
        $dateToTs = $timestampTo - ($timestampTo % \CCalendar::DAY_LENGTH);
        $accessibility = $this
            ->getAccessibility($userIds, $dateFromTs, $dateToTs)
        ;
 
        $busyUsersList = [];
        $timezoneName = \CCalendar::GetUserTimezoneName(\CCalendar::GetUserId());
        $timezoneOffset = Util::getTimezoneOffsetUTC($timezoneName);
        foreach ($accessibility as $userId => $events)
        {
            foreach ($events as $accessibilityItem)
            {
                $itemFrom = \CCalendar::TimestampUTC($accessibilityItem['from']);
                $itemTo = \CCalendar::TimestampUTC($accessibilityItem['to']);
 
                if ($accessibilityItem['isFullDay'])
                {
                    $itemFrom -= $timezoneOffset;
                    $itemTo -= $timezoneOffset;
                }
 
                if (Util::doIntervalsIntersect($timestampFrom, $timestampTo, $itemFrom, $itemTo))
                {
                    $busyUsersList[] = $userId;
                    continue 2;
                }
            }
        }
 
        return $busyUsersList;
    }

    public function getAccessibility(array $userIds, int $timestampFrom, int $timestampTo): array
    {
        $accessibilityTs = $this->getAccessibilityTs($userIds, $timestampFrom, $timestampTo);
 
        return $this->formatAccessibilityTs($accessibilityTs);
    }
 
    private function formatAccessibilityTs(array $accessibilityTs): array
    {
        return array_map(
            fn(array $userAccessibility) => array_map(
                fn(array $accessibilityItem) => array_merge($accessibilityItem, [
                    'from' => $this->formatTimestamp($accessibilityItem['from'], $accessibilityItem['isFullDay']),
                    'to' => $this->formatTimestamp($accessibilityItem['to'], $accessibilityItem['isFullDay']),
                ]),
                $userAccessibility,
            ),
            $accessibilityTs,
        );
    }
 
    private function formatTimestamp(int $timestamp, bool $isFullDay): string
    {
        if ($isFullDay)
        {
            return Util::formatDateTimestampUTC($timestamp);
        }
 
        return Util::formatDateTimeTimestampUTC($timestamp);
    }

    public function getAccessibilityTs(array $userIds, int $timestampFrom, int $timestampTo): array
    {
        $accessibility = [];
 
        if (empty($userIds))
        {
            return $accessibility;
        }
 
        $events = $this->getEventsTs($userIds, $timestampFrom, $timestampTo);
        $absences = $this->getAbsencesTs($userIds, $timestampFrom, $timestampTo);
 
        foreach ($userIds as $userId)
        {
            $accessibility[$userId] = array_merge($events[$userId] ?? [], $absences[$userId] ?? []);
        }
 
        return $accessibility;
    }

    public function getEventsTs(array $userIds, int $timestampFrom, int $timestampTo): array
    {
        [$from, $to] = $this->formatLimitFromTimestamps($timestampFrom, $timestampTo);
        $events = \CCalendarEvent::GetList([
            'arFilter' => [
                'FROM_LIMIT' => $from,
                'TO_LIMIT' => $to,
                'CAL_TYPE' => [
                    Dictionary::CALENDAR_TYPE['user'],
                    Dictionary::CALENDAR_TYPE['open_event'],
                ],
                'OWNER_ID' => $userIds,
                'ACTIVE_SECTION' => 'Y'
            ],
            'arSelect' => \CCalendarEvent::$defaultSelectEvent,
            'getUserfields' => false,
            'parseRecursion' => true,
            'fetchAttendees' => false,
            'fetchSection' => true,
            'parseDescription' => false,
            'setDefaultLimit' => false,
            'checkPermissions' => false,
        ]);
 
        $accessibility = $this->initAccessibility($userIds);
        foreach ($events as $event)
        {
            if ((int)$event['ID'] === $this->skipEventId || (int)$event['PARENT_ID'] === $this->skipEventId)
            {
                continue;
            }
            if ($event['ACCESSIBILITY'] === 'free')
            {
                continue;
            }
            if ($event['IS_MEETING'] && $event['MEETING_STATUS'] === 'N')
            {
                continue;
            }
            if (\CCalendarSect::CheckGoogleVirtualSection($event['SECTION_DAV_XML_ID']))
            {
                continue;
            }
 
            $isFullDay = $event['DT_SKIP_TIME'] === 'Y';
            if ($isFullDay)
            {
                $from = \CCalendar::TimestampUTC($event['DATE_FROM']);
                $to = \CCalendar::TimestampUTC($event['DATE_TO']) + \CCalendar::GetDayLen();
            }
            else
            {
                $from = Helper::getEventTimestampUTC(new DateTime($event['DATE_FROM']), $event['TZ_FROM']);
                $to = Helper::getEventTimestampUTC(new DateTime($event['DATE_TO']), $event['TZ_TO']);
            }
            $accessibility[$event['OWNER_ID']][] = [
                'id' => (int)$event['ID'],
                'parentId' => (int)$event['PARENT_ID'],
                'name' => $this->getEventName($event),
                'from' => $from,
                'to' => $to,
                'isFullDay' => $isFullDay,
            ];
        }
 
        return $accessibility;
    }
 
    private function getEventName(array $event): string
    {
        if (!$this->canSeeName($event))
        {
            return '[' . Loc::getMessage('EC_ACCESSIBILITY_BUSY') . ']';
        }
 
        return !empty($event['NAME']) ? $event['NAME'] : Loc::getMessage('EC_T_NEW_EVENT');
    }
 
    private function canSeeName(array $event): bool
    {
        $currentUserId = \CCalendar::GetUserId();
        $eventId = (int)$event['ID'];
        $cachedValue = $this->canSeeNameCache[$eventId] ?? null;
 
        if ($cachedValue === null)
        {
            $accessController = new EventAccessController($currentUserId);
            $eventModel = EventModel::createFromArray($event);
 
            $canViewTitle = $accessController->check(ActionDictionary::ACTION_EVENT_VIEW_TITLE, $eventModel);
            $this->canSeeNameCache[$eventId] = !$this->isPrivate($event) && $canViewTitle;
        }
 
        return $this->canSeeNameCache[$eventId];
    }
 
    private function isPrivate(array $event): bool
    {
        $curUserId = \CCalendar::GetUserId();
 
        return $event['PRIVATE_EVENT'] && $event['CAL_TYPE'] === 'user' && $event['OWNER_ID'] !== $curUserId;
    }

    public function getAbsencesTs(array $userIds, int $timestampFrom, int $timestampTo): array
    {
        if (!\CCalendar::IsIntranetEnabled())
        {
            return [];
        }
 
        [$from, $to] = $this->formatLimitFromTimestamps($timestampFrom, $timestampTo);
        $usersAbsence = \CIntranetUtils::GetAbsenceData(
            array(
                'DATE_START' => $from,
                'DATE_FINISH' => $to,
                'USERS' => $userIds,
                'PER_USER' => true,
            ),
            BX_INTRANET_ABSENCE_HR,
        );
 
        $absenceTypes = \Bitrix\Intranet\UserAbsence::getVacationTypes();
        $vacationTypes = array_filter(
            $absenceTypes,
            fn ($type) => in_array($type['ID'], ['VACATION', 'LEAVESICK', 'LEAVEMATERINITY', 'LEAVEUNPAYED'], true),
        );
        $vacationTypesIds = array_map(fn ($type) => (int)$type['ENUM_ID'], $vacationTypes);
 
        $offset = (int)date('Z') + \CCalendar::GetOffset(\CCalendar::GetUserId());
        $accessibility = $this->initAccessibility($userIds);
        foreach($usersAbsence as $userId => $absenceData)
        {
            foreach($absenceData as $event)
            {
                $from = \CCalendar::TimestampUTC($event['DATE_ACTIVE_FROM']);
                $to = \CCalendar::TimestampUTC($event['DATE_ACTIVE_TO']);
                $isFullDay = $this->isFullDay($event['DATE_ACTIVE_FROM'], $event['DATE_ACTIVE_TO']);
 
                if ($this->isDateWithoutTimeOrIsMidnight($event['DATE_ACTIVE_TO']))
                {
                    $to += \CCalendar::GetDayLen();
                }
 
                if (!$isFullDay)
                {
                    $from -= $offset;
                    $to -= $offset;
                }
 
                $accessibility[$userId][] = [
                    'from' => $from,
                    'to' => $to,
                    'isFullDay' => $isFullDay,
                    'name' => $event['PROPERTY_ABSENCE_TYPE_VALUE'] ?? null,
                    'isVacation' => in_array((int)$event['PROPERTY_ABSENCE_TYPE_ENUM_ID'], $vacationTypesIds, true),
                ];
            }
        }
 
        return $accessibility;
    }
 
    private function isFullDay(string $from, string $to): bool
    {
        return $this->isDateWithoutTimeOrIsMidnight($from) && $this->isDateWithoutTimeOrIsMidnight($to);
    }
 
    private function isDateWithoutTimeOrIsMidnight(string $date): bool
    {
        return \CCalendar::TimestampUTC(Util::formatDateTimeTimestampUTC(\CCalendar::TimestampUTC($date)))
            === \CCalendar::TimestampUTC(Util::formatDateTimestampUTC(\CCalendar::TimestampUTC($date)));
    }
 
    private function formatLimitFromTimestamps(int $timestampFrom, int $timestampTo): array
    {
        return [
            Util::formatDateTimeTimestampUTC($timestampFrom),
            Util::formatDateTimeTimestampUTC($timestampTo),
        ];
    }
 
    private function initAccessibility(array $userIds): array
    {
        $accessibility = [];
        foreach($userIds as $userId)
        {
            $accessibility[$userId] = [];
        }
 
        return $accessibility;
    }
}