calendarfilter.php

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

<?php
 
namespace Bitrix\Calendar\Ui;
 
use Bitrix\Calendar\Core\Event\Tools\Dictionary;
use Bitrix\Calendar\Internals\EventTable;
use Bitrix\Calendar\UserSettings;
use Bitrix\Main\Application;
use Bitrix\Main\Entity\ReferenceField;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\ORM\Query\Join;
use Bitrix\Main\Text\Emoji;
 
class CalendarFilter
{
    public const PRESET_INVITED = 'filter_calendar_meeting_status_q';
    private const PRESET_HOST = 'filter_calendar_host';
    private const PRESET_ATTENDEE = 'filter_calendar_attendee';
    private const PRESET_DECLINED = 'filter_calendar_declined';
 
    protected static $filterId = '';
 
    protected static array $filters;

    protected static function getAvailableFields(): array
    {
        return [
            'CREATED_BY',
            'ATTENDEES',
            'IS_MEETING',
            'IS_RECURSIVE',
            'MEETING_STATUS',
            'MEETING_HOST',
            'DATE_FROM',
            'DATE_TO',
            'SECTION_ID',
            'FROM_LIMIT',
            'TO_LIMIT',
        ];
    }

    public static function getFilterId($type, $ownerId, $userId): string
    {
        static::$filterId = 'calendar-filter';
        if ($type === 'user' && (int)$ownerId === (int)$userId)
        {
            static::$filterId = 'calendar-filter-personal';
        }
        else if (
            $type === 'company_calendar'
            || $type === 'calendar_company'
            || $type === 'company'
        )
        {
            static::$filterId = 'calendar-filter-company';
        }
        else if ($type === 'group')
        {
            static::$filterId = 'calendar-filter-group';
        }
 
        return static::$filterId;
    }

    public static function setFilterId($filterId)
    {
        static::$filterId = $filterId;
    }

    public static function getPresets($type): array
    {
        $presets = [];
        if ($type === Dictionary::CALENDAR_TYPE['user'] || $type === Dictionary::CALENDAR_TYPE['group'])
        {
            $presets[self::PRESET_INVITED] = [
                'id' => self::PRESET_INVITED,
                'name' => Loc::getMessage('CALENDAR_PRESET_MEETING_STATUS_Q'),
                'default' => false,
                'fields' => [
                    'IS_MEETING' => 'Y',
                    'MEETING_STATUS' => 'Q',
                ]
            ];
        }
 
        $presets[self::PRESET_HOST] = [
            'id' => self::PRESET_HOST,
            'name' => Loc::getMessage('CALENDAR_PRESET_I_AM_HOST'),
            'default' => false,
            'fields' => [
                'MEETING_STATUS' => 'H',
            ]
        ];
 
        $presets[self::PRESET_ATTENDEE] = [
            'id' => self::PRESET_ATTENDEE,
            'name' => Loc::getMessage('CALENDAR_PRESET_I_AM_ATTENDEE'),
            'default' => false,
            'fields' => [
                'IS_MEETING' => 'Y',
                'MEETING_STATUS' => 'Y',
            ]
        ];
 
        $presets[self::PRESET_DECLINED] = [
            'id' => self::PRESET_DECLINED,
            'name' => Loc::getMessage('CALENDAR_PRESET_I_DECLINED'),
            'default' => false,
            'fields' => [
                'IS_MEETING' => 'Y',
                'MEETING_STATUS' => 'N',
            ]
        ];
 
        return $presets;
    }

    public static function resolveFilterFields(string $filterId): array
    {
        $filterOptions = new \Bitrix\Main\UI\Filter\Options($filterId);
        $fields = $filterOptions->getFilter();
 
        $preset = $fields['PRESET_ID'] ?? null;
        $meetingStatus = $fields['MEETING_STATUS'] ?? null;
        if ($meetingStatus === 'Q')
        {
            $preset = self::PRESET_INVITED;
        }
        if ($meetingStatus === 'Y')
        {
            $preset = self::PRESET_ATTENDEE;
        }
        if ($meetingStatus === 'N')
        {
            $preset = self::PRESET_DECLINED;
        }
 
        $result = [
            'search' => $filterOptions->getSearchString(),
            'presetId' => $preset,
            'fields' => []
        ];
        $connection = Application::getConnection();
        $sqlHelper = $connection->getSqlHelper();
 
        $fieldNames = self::getAvailableFields();
        foreach ($fields as $key => $value)
        {
            if ($key === 'DATE_from')
            {
                $result['fields']['DATE_FROM'] = $value;
            }
            else if ($key === 'DATE_to')
            {
                $result['fields']['DATE_TO'] = $value;
            }
            else if ($key === 'ATTENDEES' || $key === 'CREATED_BY' || $key === 'SECTION_ID')
            {
                $valueList = [];
                foreach ($value as $code)
                {
                    $valueList[] = (int)$code;
                }
                $result['fields'][$key] = $valueList;
            }
            else if ($key === 'MEETING_STATUS')
            {
                $result['fields']['MEETING_STATUS'] = $sqlHelper->forSql($value);
            }
            else if (in_array($key, $fieldNames, true))
            {
                $result['fields'][$key] = $value;
            }
        }
 
        return $result;
    }

    public static function getFilters(): array
    {
        if (empty(static::$filters))
        {
            static::$filters['CREATED_BY'] = [
                'id' => 'CREATED_BY',
                'name' => Loc::getMessage('CALENDAR_FILTER_CREATED_BY'),
                'type' => 'entity_selector',
                'partial' => true,
                'params' => [
                    'multiple' => 'Y',
                    'dialogOptions' => [
                        'height' => 240,
                        'context' => 'filter',
                        'entities' => [
                            [
                                'id' => 'user',
                                'options' => [
                                    'inviteEmployeeLink' => false
                                ],
                            ]
                        ]
                    ],
                ],
            ];
 
            static::$filters['ATTENDEES'] = [
                'id' => 'ATTENDEES',
                'name' => Loc::getMessage('CALENDAR_FILTER_ATTENDEES'),
                'type' => 'entity_selector',
                'partial' => true,
                'params' => [
                    'multiple' => 'Y',
                    'dialogOptions' => [
                        'height' => 270,
                        'context' => 'filter',
                        'entities' => [
                            [
                                'id' => 'user',
                                'options' => [
                                    'inviteEmployeeLink' => false
                                ],
                            ],
                        ]
                    ],
                ],
            ];
 
            static::$filters['MEETING_STATUS'] = [
                'id' => 'MEETING_STATUS',
                'name' => Loc::getMessage('CALENDAR_FILTER_MEETING_STATUS_ME'),
                'type' => 'list',
                'params' => [
                    'multiple' => 'N'
                ],
                'items' => [
                    'H' => Loc::getMessage('CALENDAR_FILTER_MEETING_STATUS_H'),
                    'Q' => Loc::getMessage('CALENDAR_FILTER_MEETING_STATUS_Q'),
                    'Y' => Loc::getMessage('CALENDAR_FILTER_MEETING_STATUS_Y'),
                    'N' => Loc::getMessage('CALENDAR_FILTER_MEETING_STATUS_N'),
                ]
            ];
 
            static::$filters['DATE'] = [
                'id' => 'DATE',
                'name' => Loc::getMessage('CALENDAR_FILTER_DATE'),
                'type' => 'date',
                'default' => true,
            ];
        }
 
        return static::$filters;
    }
 
    public static function getSectionsForFilter(string $type, ?string $preset, ?int $ownerId, ?int $userId): array
    {
        $result = [];
 
        if ($type === 'group' && $preset === self::PRESET_INVITED)
        {
            $sectionList = \CCalendar::getSectionList([
                'CAL_TYPE' => Dictionary::CALENDAR_TYPE['user'],
                'OWNER_ID' => array_unique([(int)$userId, 0]),
                'checkPermissions' => true,
                'getPermissions' => true,
            ]);
        }
        else
        {
            $sectionList = \CCalendar::getSectionList([
                'CAL_TYPE' => $type === 'user' ? ['user', 'open_event'] : $type,
                'OWNER_ID' => array_unique([(int)$ownerId, 0]),
                'checkPermissions' => true,
                'getPermissions' => true,
            ]);
        }
 
        $isPersonalCalendarContext = ($type === 'user' && $userId === $ownerId);
 
        $hiddenSections = [];
        if ($preset !== self::PRESET_INVITED)
        {
            $hiddenSections = UserSettings::getHiddenSections(
                $userId,
                [
                    'type' => $type,
                    'ownerId' => $ownerId,
                    'isPersonalCalendarContext' => $isPersonalCalendarContext,
                ]
            );
            $hiddenSections = array_map(static function($sectionId) {
                return (int)$sectionId;
            }, $hiddenSections);
        }
 
        foreach ($sectionList as $section)
        {
            if (in_array((int)$section['ID'], $hiddenSections, true))
            {
                continue;
            }
 
            $result[] = (int)$section['ID'];
        }
 
        return $result;
    }

    public static function getFilterData(array $params): array
    {
        $connection = Application::getConnection();
        $sqlHelper = $connection->getSqlHelper();
        $userId = (int)$params['userId'];
        $ownerId = (int)$params['ownerId'];
        $type = $sqlHelper->forSql($params['type']);
 
        $fields = self::resolveFilterFields(
            self::getFilterId($type, $ownerId, $userId)
        );
        $fields['fields']['SECTION_ID'] = self::getSectionsForFilter(
            $params['type'],
            $fields['presetId'],
            $params['ownerId'],
            $params['userId'],
        );
 
        if (
            $type === 'company_calendar'
            || $type === 'calendar_company'
            || $type === 'company'
            || $type === 'group'
        )
        {
            return self::getFilterCompanyData($type, $userId, $ownerId, $fields);
        }
 
        return self::getFilterUserData($type, $userId, $ownerId, $fields);
    }

    public static function getFilterUserData(string $type, int $userId, int $ownerId, $fields): array
    {
        $counters = false;
        $entries = [];
        $filter = [
            'OWNER_ID' => $ownerId,
            'CAL_TYPE' => $type === 'user' ? ['user', 'open_event'] : $type,
            'ACTIVE_SECTION' => 'Y',
        ];
 
        if (isset($fields['fields']['IS_MEETING']))
        {
            $filter['IS_MEETING'] = $fields['fields']['IS_MEETING'] === 'Y';
        }
 
        if (isset($fields['fields']['MEETING_STATUS']))
        {
            $filter['MEETING_STATUS'] = $fields['fields']['MEETING_STATUS'];
            if ($filter['MEETING_STATUS'] === 'H')
            {
                unset($filter['MEETING_STATUS']);
                $filter['MEETING_HOST'] = $userId;
            }
            else
            {
                $filter['IS_MEETING'] = true;
            }
 
            if ($fields['presetId'] === self::PRESET_INVITED)
            {
                $filter['FROM_LIMIT'] = \CCalendar::Date(time(), false);
                $filter['TO_LIMIT'] = \CCalendar::Date(time() + \CCalendar::DAY_LENGTH * 90, false);
 
                \CCalendar::UpdateCounter(
                    users: [$userId],
                    groupIds: $type === Dictionary::CALENDAR_TYPE['group'] ? [$ownerId] : [],
                );
 
                $counters = CountersManager::getValues((int)$filter['OWNER_ID']);
            }
        }
 
        if (isset($fields['fields']['CREATED_BY']))
        {
            unset($filter['OWNER_ID'], $filter['CAL_TYPE']);
            $filter['MEETING_HOST'] = $fields['fields']['CREATED_BY'];
            // mantis: 93743
            $filter['OWNER_ID'] = $userId;
        }
 
        if (!empty($fields['fields']['SECTION_ID']))
        {
            $filter['SECTION'] = $fields['fields']['SECTION_ID'];
        }
        else
        {
            return [
                'result' => true,
                'entries' => $entries,
                'counters' => $counters
            ];
        }
 
        if (isset($fields['fields']['ATTENDEES']))
        {
            $query = EventTable::query()
                ->setSelect(['ID'])
                ->registerRuntimeField(
                    'EVENT_SECOND',
                    new ReferenceField(
                        'EVENT_SECOND',
                        EventTable::getEntity(),
                        Join::on('ref.PARENT_ID', 'this.PARENT_ID'),
                        ['join_type' => Join::TYPE_LEFT]
                    )
                )
                ->where('DELETED', 'N')
                ->where('EVENT_SECOND.DELETED', 'N')
                ->where('CAL_TYPE', $type)
                ->where('OWNER_ID', $userId)
                ->whereIn('EVENT_SECOND.OWNER_ID', $fields['fields']['ATTENDEES'])
                ->exec()
            ;
 
            while ($event = $query->fetch())
            {
                $filter['ID'][] = (int)$event['ID'];
            }
 
            if (!empty($filter['ID']))
            {
                $filter['ID'] = array_unique($filter['ID']);
            }
            else
            {
                $filter['ID'] = [0];
            }
 
            $filter['IS_MEETING'] = true;
        }
 
        if ($type === Dictionary::CALENDAR_TYPE['group'] && $fields['presetId'] === self::PRESET_INVITED)
        {
            $filter['OWNER_ID'] = $userId;
            $filter['CAL_TYPE'] = ['user', 'open_event'];
 
            $query = EventTable::query()
                ->setSelect(['ID'])
                ->registerRuntimeField(
                    'EVENT_SECOND',
                    new ReferenceField(
                        'EVENT_SECOND',
                        EventTable::getEntity(),
                        Join::on('ref.ID', 'this.PARENT_ID'),
                        ['join_type' => Join::TYPE_LEFT]
                    )
                )
                ->where('DELETED', 'N')
                ->where('EVENT_SECOND.DELETED', 'N')
                ->where('CAL_TYPE', Dictionary::CALENDAR_TYPE['user'])
                ->where('EVENT_SECOND.CAL_TYPE', $type)
                ->where('OWNER_ID', $userId)
                ->where('EVENT_SECOND.OWNER_ID', $ownerId)
                ->where('MEETING_STATUS', Dictionary::MEETING_STATUS['Question'])
                ->exec()
            ;
 
            while ($event = $query->fetch())
            {
                $filter['ID'][] = (int)$event['ID'];
            }
 
            if (!empty($filter['ID']))
            {
                $filter['ID'] = array_unique($filter['ID']);
            }
            else
            {
                $filter['ID'] = [0];
            }
        }
 
        [$filter, $parseRecursion] = self::filterByDate($fields, $filter);
 
        if (isset($fields['search']) && $fields['search'])
        {
            $filter[(\CCalendarEvent::isFullTextIndexEnabled() ? '*' : '*%').'SEARCHABLE_CONTENT'] = \CCalendarEvent::prepareToken(Emoji::encode($fields['search']));
        }
 
        $entries = \CCalendarEvent::GetList(
            [
                'arFilter' => $filter,
                'fetchAttendees' => true,
                'parseRecursion' => $parseRecursion,
                'maxInstanceCount' => 50,
                'preciseLimits' => $parseRecursion,
                'userId' => $userId,
                'fetchMeetings' => true,
                'fetchSection' => true,
                'setDefaultLimit' => false
            ]
        );
        if ($fields['presetId'] !== self::PRESET_DECLINED)
        {
            $entries = self::filterByShowDeclined($entries);
        }
 
        return [
            'result' => true,
            'entries' => $entries,
            'counters' => $counters
        ];
    }

    public static function getFilterCompanyData(string $type, int $userId, int $ownerId, $fields): array
    {
        $entries = [];
 
        if ($type === Dictionary::CALENDAR_TYPE['group'] && $fields['presetId'] === self::PRESET_INVITED)
        {
            return self::getFilterUserData($type, $userId, $ownerId, $fields);
        }
 
        $filter = [
            'CAL_TYPE' => $type,
            'ACTIVE_SECTION' => 'Y',
        ];
 
        $query = EventTable::query()
            ->setSelect(['PARENT_ID'])
            ->registerRuntimeField(
                'EVENT_SECOND',
                new ReferenceField(
                    'EVENT_SECOND',
                    EventTable::getEntity(),
                    Join::on('ref.PARENT_ID', 'this.ID'),
                    ['join_type' => Join::TYPE_LEFT]
                )
            )
            ->where('CAL_TYPE', $type)
            ->where('DELETED', 'N')
            ->where('EVENT_SECOND.DELETED', 'N')
        ;
 
        if (isset($fields['fields']['IS_MEETING']) && $fields['fields']['IS_MEETING'])
        {
            $filter['IS_MEETING'] = $fields['fields']['IS_MEETING'] === 'Y';
        }
 
        if (isset($fields['fields']['MEETING_STATUS']) && $fields['fields']['MEETING_STATUS'])
        {
            $query->where('EVENT_SECOND.OWNER_ID', $userId);
            if (
                $fields['fields']['MEETING_STATUS'] === 'H'
                && !isset($fields['fields']['CREATED_BY'])
            )
            {
                unset($filter['IS_MEETING']);
                $query->where('EVENT_SECOND.MEETING_HOST', $userId);
            }
            else
            {
                $query->where('EVENT_SECOND.MEETING_STATUS', $fields['fields']['MEETING_STATUS']);
                $filter['IS_MEETING'] = true;
            }
        }
 
        if (isset($fields['fields']['CREATED_BY']) && is_array($fields['fields']['CREATED_BY']))
        {
            $query->whereIn('EVENT_SECOND.MEETING_HOST', $fields['fields']['CREATED_BY']);
        }
 
        if (isset($fields['fields']['SECTION_ID']) && is_array($fields['fields']['SECTION_ID']))
        {
            $query->whereIn('SECTION_ID',  $fields['fields']['SECTION_ID']);
        }
 
        if (isset($fields['fields']['ATTENDEES']) && is_array($fields['fields']['ATTENDEES']))
        {
            if (isset($fields['fields']['MEETING_STATUS']))
            {
                $query
                    ->registerRuntimeField(
                    'EVENT_THIRD',
                    new ReferenceField(
                        'EVENT_THIRD',
                        EventTable::getEntity(),
                        Join::on('ref.PARENT_ID', 'this.ID'),
                        ['join_type' => Join::TYPE_LEFT]
                    )
                )
                    ->whereIn('EVENT_THIRD.OWNER_ID', $fields['fields']['ATTENDEES'])
                ;
            }
            else
            {
                $query->whereIn('EVENT_SECOND.OWNER_ID', $fields['fields']['ATTENDEES']);
            }
            $filter['IS_MEETING'] = true;
        }
 
        if (isset($fields['search']) && $fields['search'])
        {
            $filter[(\CCalendarEvent::isFullTextIndexEnabled() ? '*' : '*%').'SEARCHABLE_CONTENT'] = \CCalendarEvent::prepareToken($fields['search']);
        }
 
        [$filter, $parseRecursion] = self::filterByDate($fields, $filter);
 
        $eventsFromQuery = $query->exec();
 
        while ($event = $eventsFromQuery->Fetch())
        {
            $filter['ID'][] = (int)$event['PARENT_ID'];
        }
 
        if (isset($filter['ID']))
        {
            $filter['ID'] = array_unique($filter['ID']);
 
            $entries = \CCalendarEvent::GetList(
                [
                    'arFilter' => $filter,
                    'fetchAttendees' => true,
                    'parseRecursion' => $parseRecursion,
                    'maxInstanceCount' => 50,
                    'preciseLimits' => $parseRecursion,
                    'userId' => $userId,
                    'fetchMeetings' => true,
                    'fetchSection' => true,
                    'setDefaultLimit' => false
                ]
            );
        }
        $entries = self::applyAccessRestrictions($entries);
        $entries = self::filterByShowDeclined($entries);
 
        return [
            'result' => true,
            'entries' => $entries,
            'counters' => false
        ];
    }

    private static function filterByDate($fields, array $filter): array
    {
        $parseRecursion = false;
        $fromTs = 0;
        $toTs = 0;
        if (isset($fields['fields']['DATE_FROM']))
        {
            $fromTs = \CCalendar::Timestamp($fields['fields']['DATE_FROM'], true, false);
            $filter['FROM_LIMIT'] = \CCalendar::Date($fromTs, false);
        }
        else if (!($filter['FROM_LIMIT'] ?? null))
        {
            $filter['FROM_LIMIT'] = \CCalendar::Date(time() - 31 * 12 * 24 * 3600, false);
        }
 
        if (isset($fields['fields']['DATE_TO']))
        {
            $toTs = \CCalendar::Timestamp($fields['fields']['DATE_TO'], true, false);
            $filter['TO_LIMIT'] = \CCalendar::Date($toTs, false);
            if ($fromTs && $toTs < $fromTs)
            {
                $filter['TO_LIMIT'] = $filter['FROM_LIMIT'];
            }
        }
 
        if ($fromTs && $toTs && $fromTs <= $toTs)
        {
            $parseRecursion = true;
        }
 
        return [
            $filter,
            $parseRecursion
        ];
    }

    private static function applyAccessRestrictions(array $events): array
    {
        foreach ($events as $i => $event)
        {
            if (
                isset($event['IS_ACCESSIBLE_TO_USER'])
                && $event['IS_ACCESSIBLE_TO_USER'] === false
            )
            {
                unset($events[$i]);
            }
        }
 
        return array_values($events);
    }
 
    public static function filterByShowDeclined(array $entries): array
    {
        $settings = UserSettings::get();
        $optionShowDeclined = $settings['showDeclined'];
 
        return array_values(array_filter($entries, static function($entry) use ($optionShowDeclined) {
            $hideDeclinedEntry = (!$optionShowDeclined || (int)$entry['OWNER_ID'] !== \CCalendar::GetUserId());
            return !($hideDeclinedEntry && $entry['MEETING_STATUS'] === 'N');
        }));
    }
}