event.php

<?php
 
namespace Bitrix\Calendar\Core\Mappers;
 
use Bitrix\Calendar\Core;
use Bitrix\Calendar\Internals\EO_Event;
use Bitrix\Calendar\Internals\EventTable;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Error;
use Bitrix\Main\ObjectException;
use Bitrix\Main\ObjectPropertyException;
use Bitrix\Main\ORM\Data\AddResult;
use Bitrix\Main\ORM\Query\Result;
use Bitrix\Main\ORM\Query\Query;
use Bitrix\Main\SystemException;
use CCalendar;
use CCalendarEvent;
 
class Event extends Mapper
{
    public function getCollectionByIds(array $ids, int $ownerId, array $fields = ['*']): Core\Event\EventCollection
    {
        $eventDM = EventTable::query()
            ->whereIn('ID', $ids)
            ->where('OWNER_ID', $ownerId)
            ->setSelect($fields)
            ->exec()
        ;
 
        $collection = new Core\Event\EventCollection();
 
        while ($event = $eventDM->fetch())
        {
            $collection->add((new Core\Builders\EventBuilderFromArray($event))->build());
        }
 
        return $collection;
    }
 
    protected function createEntity($entity, array $params = []): ?Core\Base\EntityInterface
    {
        $entity->setDateModified(new Core\Base\Date());
        $result = $this->save($entity, $params);
 
        if ($result->isSuccess())
        {
            // TODO: perhaps need to setup date create and date update
            return $this->getById($result->getId());
        }
 
        return null;
    }
 
    protected function updateEntity($entity, array $params = []): ?Core\Base\EntityInterface
    {
        $entity->setDateModified(new Core\Base\Date());
        $data = $this->convertToArray($entity);
 
        $params = array_merge($params, [
            'arFields' => $data,
            'originalFrom' => $params['originalFrom'] ?? null,
            'checkPermissions' => false,
            'userId' => $params['userId']
                ?? $entity->getOwner() ? $entity->getOwner()->getId() : null,
        ]);
 
        // TODO: in the future change it to call EventTable::update()
        if (($id = CCalendar::SaveEvent($params)) && is_numeric($id))
        {
            return $this->getById((int)$id);
        }
 
        return null;
    }
 
    protected function deleteEntity(Core\Base\EntityInterface $entity, array $params): ?Core\Base\EntityInterface
    {
        $params = array_merge($params,[
            'Event' => $this->prepareArrayForDelete($entity),
            'id' => $entity->getId(),
            'checkPermissions' => false,
            'bMarkDeleted' => true,
            'userId' => $params['userId']
                ?? $entity->getOwner() ? $entity->getOwner()->getId() : null,
        ]);
 
        if (CCalendar::DeleteEvent($entity->getId(), true, $params) && !empty($params['bMarkDeleted']))
        {
            $entity->setIsDeleted(true);
 
            return $entity;
        }
 
        return null;
    }
 
    private function prepareArrayForDelete(Core\Event\Event $event): ?array
    {
        try
        {
            return $this->convertToArray($event);
        }
        catch(\Throwable $e)
        {
            return null;
        }
    }
 
    private function save(Core\Event\Event $event, array $params = []): AddResult
    {
        $data = $this->convertToArray($event);
 
        $params = array_merge($params, [
            'arFields' => $data,
            'checkPermissions' => false,
            'userId' => $event->getOwner() ? $event->getOwner()->getId() : null, // todo how get userId ?
        ]);
 
        $id = CCalendar::SaveEvent($params);
 
        $result = new AddResult();
        if ($id)
        {
            $result->setPrimary($id);
        }
        else
        {
            $result->addError(new Error('Error of create event'));
        }
 
        return $result;
    }
 
    private function prepareReminders(Core\Event\Properties\RemindCollection $collection, Core\Base\Date $start): array
    {
        $result = [];
        $collection->setEventStart(clone $start);
        $collection->deDuplicate();
        foreach ($collection->getCollection() as $reminder)
        {
            $remind = [
                'before' => null,
                'count' => null,
                'time' => null,
                'value' => null,
            ];
            if ($reminder->getDaysBefore() !== null)
            {
                $remind['type'] = Core\Event\Properties\Remind::UNIT_DAY_BEFORE;
                $remind['before'] = $reminder->getDaysBefore();
                $remind['time'] = $reminder->getTimeOffset();
            }
            elseif ($reminder->isSimpleType())
            {
                $remind['type'] = str_replace('minutes', 'min', $reminder->getUnits()) ;
                $remind['count'] = $reminder->getTime();
            }
            else
            {
                $remind['type'] = Core\Event\Properties\Remind::UNIT_DATES;
                $remind['value'] = $reminder->getSpecificTime();
            }
            $result[] = $remind;
        }
 
        return $result;
    }
 
    private function convertToArray(Core\Event\Event $event): array
    {
        return [
            'ID'                 => $event->getId(),
            'ACTIVE'             => $event->isActive() ? 'Y' : 'N',
            'DELETED'            => $event->isDeleted() ? 'Y' : 'N',
            'DT_SKIP_TIME'       => $event->isFullDayEvent() ? 'Y' : 'N',
            'DAV_XML_ID'         => $event->getUid(),
            'TZ_FROM'            => (string)$event->getStartTimeZone(),
            'TZ_TO'              => (string)$event->getEndTimeZone(),
            'NAME'               => $event->getName(),
            'DATE_FROM'          => (string)$event->getStart(),
            'DATE_TO'            => (string)$event->getEnd(),
            'ORIGINAL_DATE_FROM' => $this->prepareOriginalDateFrom($event),
            'DESCRIPTION'        => $event->getDescription(),
            'ACCESSIBILITY'      => $event->getAccessibility(),
            'PRIVATE_EVENT'      => $event->isPrivate(),
            'IMPORTANCE'         => $event->getImportance(),
            'OWNER_ID'           => $event->getOwner() ? $event->getOwner()->getId() : null,
            'CREATED_BY'         => $event->getOwner() ? $event->getOwner()->getId() : null,
            'CAL_TYPE'           => $event->getCalendarType(),
            'EVENT_TYPE'         => $event->getSpecialLabel(),
            'LOCATION'           => $event->getLocation() ? $event->getLocation()->getActualLocation() : '',
            'REMIND'             => ($event->getRemindCollection() && $event->getRemindCollection()->count())
                ? $this->prepareReminders($event->getRemindCollection(), $event->getStart())
                : null,
            'RRULE'              => $event->isRecurrence()
                ? $event->getRecurringRule()->toArray()
                : null,
            'EXDATE'             => $event->getExcludedDateCollection()
                ? $event->getExcludedDateCollection()->toString()
                : null,
            'RECURRENCE_ID'      => $event->getRecurrenceId(),
            'IS_MEETING'         => $event->isMeeting(),
            'MEETING_STATUS'     => $event->getMeetingStatus(),
            'MEETING_HOST'       => $event->getEventHost() ? $event->getEventHost()->getId() : null,
            'MEETING'            => $event->getMeetingDescription() ? $event->getMeetingDescription()->getFields() : null,
            'ATTENDEES_CODES'    => $event->getAttendeesCollection()
                ? $event->getAttendeesCollection()->getFields()['attendeesCodesCollection']
                : null,
            'SECTIONS'           => $event->getSection() ? [$event->getSection()->getId()] : null,
            'SECTION_ID'         => $event->getSection() ? $event->getSection()->getId() : null,
            'RELATIONS'          => $event->getRelations() ? $event->getRelations()->getFields() : null,
        ];
    }
 
    protected function getOneEntityByFilter(array $filter): ?object
    {
        $eventData = EventTable::query()
           ->setFilter($filter)
           ->setSelect(['*'])
           ->fetchObject();
 
        if ($eventData)
        {
            return $this->convertToObject($eventData);
        }
 
        return null;
    }
 
    protected function convertToObject($objectEO): Core\Base\EntityInterface
    {
        return (new Core\Builders\EventBuilderFromEntityObject($objectEO))->build();
    }
 
    protected function getEntityName(): string
    {
        return 'event';
    }
 
    protected function getMapClass(): string
    {
        return Core\Event\EventMap::class;
    }
 
    protected function getDataManagerResult(array $params): Result
    {
        $params['select'] = $params['select'] ?? ["*"];
        return EventTable::getList($params);
    }
    public function getMapFullChainByParentId(int $id, int $ownerId, array $fields = ['*']): Core\Event\EventMap
    {
        $eventDM = EventTable::query()
            ->where(Query::filter()
                ->logic('or')
                ->where('PARENT_ID', $id)
                ->where('RECURRENCE_ID', $id)
            )
            ->where('OWNER_ID', $ownerId)
            ->setSelect($fields)
            ->exec()
        ;
 
        $eventMap = new Core\Event\EventMap();
 
        while ($event = $eventDM->fetch())
        {
            $eventMap->add((new Core\Builders\EventBuilderFromArray($event))->build(), (int)$event['ID']);
        }
 
        return $eventMap;
    }
 
    public function getEntity(int $id, ?array $additionalParams = null): ?Core\Event\Event
    {
        $eventDM = EventTable::query()
            ->where('ID', $id)
        ;
 
        if ($additionalParams)
        {
            //filter
            if (isset($additionalParams['filter'])
                && is_iterable($additionalParams['filter'])
            )
            {
                foreach ($additionalParams['filter'] as $filter)
                {
                    $eventDM->addFilter($filter['key'], $filter['value']);
                }
            }
 
            //select
            if (isset($additionalParams['fields'])
                && is_array($additionalParams['fields'])
            )
            {
                $eventDM->setSelect($additionalParams['fields']);
            }
            else
            {
                $eventDM->setSelect(['*']);
            }
        }
        else
        {
            $eventDM->setSelect(['*']);
        }
 
        $event = $eventDM->exec()->fetchObject();
 
        return $event
                ? (new Core\Builders\EventBuilderFromEntityObject($event))->build()
                : null
        ;
    }
 
    public function patch(Core\Event\Event $event, array $fields): Core\Event\Event
    {
        $eventFields = [
            'EXDATE' => (string)$event->getExcludedDateCollection(),
        ];
 
        $result = EventTable::update(
            $event->getId(),
            array_intersect_key($eventFields, array_flip($fields))
        );
 
        if ($result->isSuccess())
        {
            return $event;
        }
 
        throw new Core\Base\BaseException('do not patch event');
    }
 
    public function getByArray(array $fields)
    {
        if ($this->getCacheMap()->has($fields['ID']))
        {
            return $this->getCacheMap()->getItem($fields['ID']);
        }
 
        $entity = $this->convertFromArray($fields);
        $this->getCacheMap()->add($entity, $entity->getId());
 
        return $entity;
    }
 
    protected function convertFromArray(array $fields): Core\Event\Event
    {
        return (new Core\Builders\EventBuilderFromArray($fields))->build();
    }
 
    protected function getEntityClass(): string
    {
        return Core\Event\Event::class;
    }
 
    private function prepareOriginalDateFrom(Core\Event\Event $event): ?string
    {
        $result = null;
        if ($event->getOriginalDateFrom())
        {
            if ($event->getStartTimeZone())
            {
                $event->getOriginalDateFrom()->setTimezone($event->getStartTimeZone()->getTimeZone());
            }
            $result = (string)$event->getOriginalDateFrom();
        }
 
        return $result;
    }
}