Initial xentral_oss_20.3.c9ffacf

classes/Modules/GoogleCalendar/Data/GoogleCalendarColorCollection.php

@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+use Xentral\Modules\GoogleCalendar\Exception\InvalidArgumentException;
+
+final class GoogleCalendarColorCollection
+{
+    /** @var GoogleCalendarColorValue[] $eventColors */
+    private $eventColors;
+
+    /** @var GoogleCalendarColorValue[] $eventColors */
+    private $calendarColors;
+
+    /** @var string $defaultColorId */
+    private $defaultColorId;
+
+    /**
+     * @param GoogleCalendarColorValue[] $eventColors
+     * @param GoogleCalendarColorValue[] $calendarColors
+     */
+    private function __construct(array $eventColors, array $calendarColors)
+    {
+        $this->eventColors = $eventColors;
+        $this->calendarColors = $calendarColors;
+    }
+
+    /**
+     * @param array $data
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarColorCollection
+     */
+    public static function createFromJsonArray(array $data): GoogleCalendarColorCollection
+    {
+        if (!isset($data['kind'], $data['event'], $data['calendar']) || $data['kind'] !== 'calendar#colors') {
+            throw new InvalidArgumentException('Invalid Json Format for this resource.');
+        }
+        $eventColors = [];
+        foreach ($data['event'] as $index => $ec) {
+            $eventColors[] = new GoogleCalendarColorValue((string)$index, $ec['background'], $ec['foreground']);
+        }
+        $calendarColors = [];
+        foreach ($data['calendar'] as $index => $ec) {
+            $calendarColors[] = new GoogleCalendarColorValue((string)$index, $ec['background'], $ec['foreground']);
+        }
+
+        return new self($eventColors, $calendarColors);
+    }
+
+    /**
+     * @param string $colorId
+     *
+     * @return void
+     */
+    public function setDefaultColorId(string $colorId): void
+    {
+        $this->defaultColorId = $colorId;
+    }
+
+    /**
+     * @return GoogleCalendarColorValue|null
+     */
+    public function getDefaultColor(): ?GoogleCalendarColorValue
+    {
+        if ($this->defaultColorId === null) {
+            return null;
+        }
+
+        return $this->getCalendarColorById($this->defaultColorId);
+    }
+
+    /**
+     * @param string $colorId
+     *
+     * @return GoogleCalendarColorValue|null
+     */
+    public function getEventColorById(string $colorId): ?GoogleCalendarColorValue
+    {
+        foreach ($this->eventColors as $color) {
+            if ($color->getIdentifier() === $colorId) {
+                return $color;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @return GoogleCalendarColorValue[]
+     */
+    public function getAllEventColors(): array
+    {
+        return array_values($this->eventColors);
+    }
+
+    /**
+     * @param string $colorId
+     *
+     * @return GoogleCalendarColorValue|null
+     */
+    public function getCalendarColorById(string $colorId): ?GoogleCalendarColorValue
+    {
+        foreach ($this->calendarColors as $color) {
+            if ($color->getIdentifier() === $colorId) {
+                return $color;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @return GoogleCalendarColorValue[]
+     */
+    public function getAllCalendarColors(): array
+    {
+        return array_values($this->calendarColors);
+    }
+}

classes/Modules/GoogleCalendar/Data/GoogleCalendarColorValue.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+final class GoogleCalendarColorValue
+{
+    /** @var string $identifier */
+    private $identifier;
+
+    /** @var string $background */
+    private $background;
+
+    /** @var string $foregroud */
+    private $foregroud;
+
+    /**
+     * @param string $identifier
+     * @param string $background
+     * @param string $foregroud
+     */
+    public function __construct(string $identifier, string $background, string $foregroud)
+    {
+        $this->identifier = $identifier;
+        $this->background = $background;
+        $this->foregroud = $foregroud;
+    }
+
+    /**
+     * @return string
+     */
+    public function getIdentifier(): string
+    {
+        return $this->identifier;
+    }
+
+    /**
+     * @return string color hex code
+     */
+    public function getBackground(): string
+    {
+        return $this->background;
+    }
+
+    /**
+     * @return string color hex code
+     */
+    public function getForegroud(): string
+    {
+        return $this->foregroud;
+    }
+}

classes/Modules/GoogleCalendar/Data/GoogleCalendarEventAttendeeValue.php

@@ -0,0 +1,174 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+use Xentral\Modules\GoogleCalendar\Exception\InvalidArgumentException;
+
+final class GoogleCalendarEventAttendeeValue
+{
+    /** @var string STATUS_ACCEPTED */
+    public const STATUS_ACCEPTED = 'accepted';
+
+    /** @var string STATUS_TENTATIVE */
+    public const STATUS_TENTATIVE = 'tentative';
+
+    /** @var string STATUS_NEEDSACTION */
+    public const STATUS_NEEDSACTION = 'needsAction';
+
+    /** @var string STATUS_DECLINED */
+    public const STATUS_DECLINED = 'declined';
+
+    /** @var string $email */
+    private $email;
+
+    /** @var bool $self */
+    private $self;
+
+    /** @var string $displayName */
+    private $displayName;
+
+    /** @var string $identifier */
+    private $identifier;
+
+    /** @var string $responseStatus */
+    private $responseStatus;
+
+    /** @var bool $optional */
+    private $optional;
+
+    /**
+     * @param string $email
+     * @param string $displayName
+     * @param bool   $optional
+     * @param string $identifier
+     * @param string $responseStatus
+     * @param bool   $self
+     */
+    public function __construct(
+        string $email,
+        string $displayName = '',
+        bool $optional = false,
+        string $identifier = '',
+        string $responseStatus = '',
+        bool $self = false
+    ) {
+        if ($email === '' || $email === null) {
+            throw new InvalidArgumentException('Email address is required.');
+        }
+        $this->email = $email;
+        $this->self = $self;
+        $this->identifier = $identifier;
+        $this->displayName = $displayName;
+        $this->responseStatus = $responseStatus;
+        $this->optional = $optional;
+    }
+
+    /**
+     * @param array $data
+     *
+     * @return GoogleCalendarEventAttendeeValue
+     */
+    public static function createFromJsonArray(array $data): GoogleCalendarEventAttendeeValue
+    {
+        if (!isset($data['email'])) {
+            throw new InvalidArgumentException('Invalid data format.');
+        }
+        $email = $data['email'];
+        $self = false;
+        if (isset($data['self'])) {
+            $self = (bool)$data['self'];
+        }
+        $displayName = '';
+        if (isset($data['displayName'])) {
+            $displayName = $data['displayName'];
+        }
+        $id = '';
+        if (isset($data['id'])) {
+            $id = $data['id'];
+        }
+        $responseStatus = '';
+        if (isset($data['responseStatus'])) {
+            $responseStatus = $data['responseStatus'];
+        }
+
+        return new self($email, $displayName, false, $id, $responseStatus, $self);
+    }
+
+    /**
+     * @return array
+     */
+    public function toDataArray(): array
+    {
+        $data = [];
+        $data['email'] = $this->getEmail();
+        $data['displayName'] = $this->getDisplayName();
+        $data['optional'] = $this->isOptional();
+        if ($this->getIdentifier() !== '') {
+            $data['id'] = $this->getIdentifier();
+        }
+        if ($this->responseStatus !== '') {
+            $data['responseStatus'] = $this->responseStatus;
+        }
+
+        return $data;
+    }
+
+    /**
+     * @return string
+     */
+    public function getEmail(): string
+    {
+        return $this->email;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isSelf(): bool
+    {
+        return $this->self;
+    }
+
+    /**
+     * @return string
+     */
+    public function getDisplayName(): string
+    {
+        $display = $this->displayName;
+        if ($display === '' || $display === null) {
+            $display = $this->email;
+        }
+
+        return $display;
+    }
+
+    /**
+     * @return string
+     */
+    public function getIdentifier(): string
+    {
+        return $this->identifier;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isAttending(): bool
+    {
+        return (
+            $this->responseStatus === self::STATUS_ACCEPTED
+            || $this->responseStatus === self::STATUS_TENTATIVE
+            || $this->responseStatus === self::STATUS_NEEDSACTION
+        );
+    }
+
+    /**
+     * @return bool
+     */
+    public function isOptional(): bool
+    {
+        return $this->optional;
+    }
+}

classes/Modules/GoogleCalendar/Data/GoogleCalendarEventData.php

@@ -0,0 +1,781 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+use DateTime;
+use DateTimeInterface;
+use JsonSerializable;
+use Xentral\Modules\GoogleCalendar\Exception\InvalidArgumentException;
+
+final class GoogleCalendarEventData implements JsonSerializable
+{
+    /** @var string STATUS_CONFIRMED */
+    public const STATUS_CONFIRMED = 'confirmed';
+
+    /** @var string STATUS_TENTATIVE */
+    public const STATUS_TENTATIVE = 'tentative';
+
+    /** @var string STATUS_CANCELLED */
+    public const STATUS_CANCELLED = 'cancelled';
+
+    /** @var string VISIBILITY_PUBLIC */
+    public const VISIBILITY_PUBLIC = 'public';
+
+    /** @var string VISIBILITY_PRIVATE */
+    public const VISIBILITY_PRIVATE = 'private';
+
+    /** @var string VISIBILITY_DEFAULT */
+    public const VISIBILITY_DEFAULT = 'default';
+
+    /** @var string TRANSPARENCY_OPAQUE */
+    public const TRANSPARENCY_OPAQUE = 'opaque';
+
+    /** @var string TRANSPARENCY_TRANSPARENT */
+    public const TRANSPARENCY_TRANSPARENT = 'transparent';
+
+    /** @var string $kind */
+    private static $kind = 'calendar#event';
+
+    /** @var string $id */
+    private $id;
+
+    /** @var string $etag */
+    private $etag;
+
+    /** @var string $status */
+    private $status;
+
+    /** @var GoogleCalendarEventTimeValue $time */
+    private $time;
+
+    /** @var string $iCalUid */
+    private $iCalUid;
+
+    /** @var string $summary */
+    private $summary;
+
+    /** @var string $description */
+    private $description;
+
+    /** @var string $location */
+    private $location;
+
+    /** @var string $colorId */
+    private $colorId;
+
+    /** @var DateTime $created */
+    private $created;
+
+    /** @var DateTime $updated */
+    private $updated;
+
+    /** @var GoogleCalendarEventAttendeeValue $creator */
+    private $creator;
+
+    /** @var GoogleCalendarEventAttendeeValue $organizer */
+    private $organizer;
+
+    /** @var GoogleCalendarEventAttendeeValue[] $attendees */
+    private $attendees;
+
+    /** @var string $visibility */
+    private $visibility;
+
+    /** @var string $transparency */
+    private $transparency;
+
+    /** @var GoogleCalendarEventReminderValue[] */
+    private $reminders;
+
+    /** @var int $sequence */
+    private $sequence;
+
+    /** @var string $htmlLink */
+    private $htmlLink;
+
+    /**
+     * @param string                             $id
+     * @param string                             $etag
+     * @param string                             $status
+     * @param string                             $iCalUid
+     * @param DateTimeInterface                  $created
+     * @param DateTimeInterface                  $updated
+     * @param GoogleCalendarEventAttendeeValue   $creator
+     * @param GoogleCalendarEventAttendeeValue   $organizer
+     * @param GoogleCalendarEventTimeValue       $time
+     * @param string                             $summary
+     * @param string                             $description
+     * @param string                             $location
+     * @param GoogleCalendarEventAttendeeValue[] $attendees
+     * @param GoogleCalendarEventReminderValue[] $reminders
+     * @param string                             $visibility
+     * @param string                             $transparency
+     * @param int                                $sequence
+     * @param string                             $colorId
+     * @param string                             $htmlLink
+     */
+    public function __construct(
+        string $id,
+        string $etag,
+        string $status,
+        string $iCalUid = '',
+        DateTimeInterface $created = null,
+        DateTimeInterface $updated = null,
+        GoogleCalendarEventAttendeeValue $creator = null,
+        GoogleCalendarEventAttendeeValue $organizer = null,
+        GoogleCalendarEventTimeValue $time = null,
+        string $summary = '',
+        string $description = '',
+        string $location = '',
+        array $attendees = [],
+        array $reminders = [],
+        string $visibility = self::VISIBILITY_DEFAULT,
+        string $transparency = self::TRANSPARENCY_OPAQUE,
+        int $sequence = 0,
+        string $colorId = '',
+        string $htmlLink = ''
+    ) {
+        $this->id = $id;
+        $this->etag = $etag;
+        if (
+            $status !== self::STATUS_CONFIRMED
+            && $status !== self::STATUS_TENTATIVE
+            && $status !== self::STATUS_CANCELLED
+        ) {
+            throw new InvalidArgumentException(
+                'Invalid event status; only "confirmed", "tentative" and "cancelled" are allowed'
+            );
+        }
+        $this->status = $status;
+        $this->iCalUid = $iCalUid;
+        $this->summary = $summary;
+        $this->description = $description;
+        $this->location = $location;
+        $this->colorId = $colorId;
+        $this->created = $created;
+        $this->updated = $updated;
+        $this->creator = $creator;
+        $this->organizer = $organizer;
+        $this->attendees = $attendees;
+        $this->time = $time;
+        if (
+            $visibility !== self::VISIBILITY_DEFAULT
+            && $visibility !== self::VISIBILITY_PRIVATE
+            && $visibility !== self::VISIBILITY_PUBLIC
+        ) {
+            throw new InvalidArgumentException(
+                'Invalid event visibility; only "default", "private" or "public" are allowed'
+            );
+        }
+        $this->visibility = $visibility;
+        if ($transparency !== self::TRANSPARENCY_OPAQUE && $transparency !== self::TRANSPARENCY_TRANSPARENT) {
+            throw new InvalidArgumentException(
+                'Invalid event transparency; only "opaque" or "transparent" are allowed'
+            );
+        }
+        $this->transparency = $transparency;
+        $this->reminders = $reminders;
+        $this->sequence = $sequence;
+        $this->htmlLink = $htmlLink;
+    }
+
+    /**
+     * @param array $data
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarEventData
+     */
+    public static function fromArray(array $data): GoogleCalendarEventData
+    {
+        if (!isset($data['kind']) || $data['kind'] !== self::$kind) {
+            throw new InvalidArgumentException('Invalid resource type. Expected: calendar#event');
+        }
+        if (!isset($data['id'])) {
+            throw new InvalidArgumentException('Missing required resorce field "id".');
+        }
+        if (!isset($data['etag'])) {
+            throw new InvalidArgumentException('Missing required resorce field "etag".');
+        }
+        if (!isset($data['status'])) {
+            throw new InvalidArgumentException('Missing required resorce field "etag".');
+        }
+
+        //mandatory
+        $id = $data['id'];
+        $etag = $data['etag'];
+        $status = $data['status'];
+
+        //optional
+        $iCalUid = '';
+        if (isset($data['iCalUID'])) {
+            $iCalUid = $data['iCalUID'];
+        }
+        $created = null;
+        if (isset($data['created'])) {
+            $created = DateTime::createFromFormat('Y-m-d\TH:i:s.uP', $data['created']);
+            if ($created === false) {
+                throw new InvalidArgumentException('Invalid DateTime Format in "created".');
+            }
+        }
+        $updated = null;
+        if (isset($data['updated'])) {
+            $updated = DateTime::createFromFormat('Y-m-d\TH:i:s.uP', $data['updated']);
+            if ($updated === false) {
+                throw new InvalidArgumentException('Invalid DateTime Format in "updated".');
+            }
+        }
+        $creator = null;
+        if (isset($data['creator'])) {
+            $creator = GoogleCalendarEventAttendeeValue::createFromJsonArray($data['creator']);
+        }
+        $organizer = null;
+        if (isset($data['organizer'])) {
+            $organizer = GoogleCalendarEventAttendeeValue::createFromJsonArray($data['organizer']);
+        }
+        $time = null;
+        if (isset($data['start'], $data['end'])) {
+            $time = GoogleCalendarEventTimeValue::createFromJsonArray($data);
+        }
+        $sequence = 0;
+        if (isset($data['sequence'])) {
+            $sequence = $data['sequence'];
+        }
+        $summary = '';
+        if (isset($data['summary'])) {
+            $summary = $data['summary'];
+        }
+        $description = '';
+        if (isset($data['description'])) {
+            $description = $data['description'];
+        }
+        $location = '';
+        if (isset($data['location'])) {
+            $location = $data['location'];
+        }
+        $visibility = self::VISIBILITY_DEFAULT;
+        if (isset($data['visibility'])) {
+            $visibility = $data['visibility'];
+        }
+        $transparency = self::TRANSPARENCY_OPAQUE;
+        if (isset($data['transparency'])) {
+            $transparency = $data['transparency'];
+        }
+        $colorId = '';
+        if (isset($data['colorId'])) {
+            $colorId = $data['colorId'];
+        }
+        $htmlLink = '';
+        if (isset($data['htmlLink'])) {
+            $htmlLink = $data['htmlLink'];
+        }
+        $attendees = [];
+        if (isset($data['attendees']) && is_array($data['attendees'])) {
+            foreach ($data['attendees'] as $attendee) {
+                $attendees[] = GoogleCalendarEventAttendeeValue::createFromJsonArray($attendee);
+            }
+        }
+        $reminders = [];
+        if (isset($data['reminders']['overrides']) && is_array($data['reminders']['overrides'])) {
+            foreach ($data['reminders']['overrides'] as $reminder) {
+                $reminders[] = GoogleCalendarEventReminderValue::fromArray($reminder);
+            }
+        }
+
+        return new self(
+            $id,
+            $etag,
+            $status,
+            $iCalUid,
+            $created,
+            $updated,
+            $creator,
+            $organizer,
+            $time,
+            $summary,
+            $description,
+            $location,
+            $attendees,
+            $reminders,
+            $visibility,
+            $transparency,
+            $sequence,
+            $colorId,
+            $htmlLink
+        );
+    }
+
+    /**
+     * @return array
+     */
+    public function toArray(): array
+    {
+        $data = [];
+        if ($this->getTime() !== null) {
+            $time = $this->getTime()->toDataArray();
+            $data = array_merge($data, $time);
+        }
+        if ($this->getCreator() !== null) {
+            $data['creator'] = $this->getCreator()->toDataArray();
+        }
+        if ($this->getOrganizer() !== null) {
+            $data['organizer'] = $this->getOrganizer()->toDataArray();
+        }
+        $data['attendees'] = [];
+        foreach ($this->getAttendees() as $attendee) {
+            $data['attendees'][] = $attendee->toDataArray();
+        }
+        $data['reminders']['overrides'] = [];
+        foreach ($this->getReminders() as $reminder) {
+            $data['reminders']['overrides'][] = $reminder->toArray();
+        }
+        if ($this->getColorId() !== '') {
+            $data['colorId'] = $this->getColorId();
+        }
+        //$data['id'] = $this->getId();
+        $data['status'] = $this->getStatus();
+        //$data['iCalUid'] = $this->getICalUid();
+        $data['summary'] = $this->getSummary();
+        $data['description'] = $this->getDescription();
+        $data['location'] = $this->getLocation();
+        $data['visibility'] = $this->getVisibility();
+        $data['transparency'] = $this->getTransparency();
+
+        return $data;
+    }
+
+    /**
+     * @return string
+     */
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return string
+     */
+    public function getEtag(): string
+    {
+        return $this->etag;
+    }
+
+    /**
+     * @return string
+     */
+    public function getStatus(): string
+    {
+        return $this->status;
+    }
+
+    /**
+     * @return GoogleCalendarEventTimeValue
+     */
+    public function getTime(): GoogleCalendarEventTimeValue
+    {
+        return $this->time;
+    }
+
+    /**
+     * @return string
+     */
+    public function getICalUid(): string
+    {
+        return $this->iCalUid;
+    }
+
+    /**
+     * @return string
+     */
+    public function getSummary(): string
+    {
+        return $this->summary;
+    }
+
+    /**
+     * @return string
+     */
+    public function getDescription(): string
+    {
+        return $this->description;
+    }
+
+    /**
+     * @return string
+     */
+    public function getLocation(): string
+    {
+        return $this->location;
+    }
+
+    /**
+     * @return string
+     */
+    public function getColorId(): string
+    {
+        return $this->colorId;
+    }
+
+    /**
+     * @return DateTimeInterface
+     */
+    public function getCreated(): DateTimeInterface
+    {
+        return $this->created;
+    }
+
+    /**
+     * @return DateTimeInterface
+     */
+    public function getUpdated(): DateTimeInterface
+    {
+        return $this->updated;
+    }
+
+    /**
+     * @return GoogleCalendarEventAttendeeValue|null
+     */
+    public function getCreator(): ?GoogleCalendarEventAttendeeValue
+    {
+        return $this->creator;
+    }
+
+    /**
+     * @return GoogleCalendarEventAttendeeValue|null
+     */
+    public function getOrganizer(): ?GoogleCalendarEventAttendeeValue
+    {
+        return $this->organizer;
+    }
+
+    /**
+     * @return GoogleCalendarEventAttendeeValue[]
+     */
+    public function getAttendees(): array
+    {
+        return $this->attendees;
+    }
+
+    /**
+     * @return string
+     */
+    public function getVisibility(): string
+    {
+        return $this->visibility;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTransparency(): string
+    {
+        return $this->transparency;
+    }
+
+    /**
+     * @return GoogleCalendarEventReminderValue[]
+     */
+    public function getReminders(): array
+    {
+        return $this->reminders;
+    }
+
+    /**
+     * @return int
+     */
+    public function getSequence(): int
+    {
+        return $this->sequence;
+    }
+
+    /**
+     * @return string
+     */
+    public function getHtmlLink(): string
+    {
+        return $this->htmlLink;
+    }
+
+    /**
+     * @param string $status
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setStatus(string $status): GoogleCalendarEventData
+    {
+        if (
+            $status !== self::STATUS_CONFIRMED
+            && $status !== self::STATUS_TENTATIVE
+            && $status !== self::STATUS_CANCELLED
+        ) {
+            throw new InvalidArgumentException(
+                'Invalid event status; only "confirmed", "tentative" and "cancelled" are allowed.'
+            );
+        }
+        $eventData = $this->cloneDeep();
+        $eventData->status = $status;
+
+        return $eventData;
+    }
+
+    /**
+     * @param DateTimeInterface $beginning
+     * @param DateTimeInterface $end
+     * @param bool              $wholeday
+     * @param string            $timezone
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setTime(
+        DateTimeInterface $beginning,
+        DateTimeInterface $end,
+        bool $wholeday = false,
+        string $timezone = ''
+    ): GoogleCalendarEventData {
+        $time = new GoogleCalendarEventTimeValue($beginning, $end, $wholeday, $timezone);
+        $eventData = $this->cloneDeep();
+        $eventData->time = $time;
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $summary
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setSummary(string $summary): GoogleCalendarEventData
+    {
+        $eventData = $this->cloneDeep();
+        $eventData->summary = $summary;
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $description
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setDescription(string $description): GoogleCalendarEventData
+    {
+        $eventData = $this->cloneDeep();
+        $eventData->description = $description;
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $location
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setLocation(string $location): GoogleCalendarEventData
+    {
+        $eventData = $this->cloneDeep();
+        $eventData->location = $location;
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $colorId
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setColorId(string $colorId): GoogleCalendarEventData
+    {
+        $eventData = $this->cloneDeep();
+        $eventData->colorId = $colorId;
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $visibility
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setVisibility(string $visibility): GoogleCalendarEventData
+    {
+        if (
+            $visibility !== self::VISIBILITY_DEFAULT
+            && $visibility !== self::VISIBILITY_PRIVATE
+            && $visibility !== self::VISIBILITY_PUBLIC
+        ) {
+            throw new InvalidArgumentException(
+                'Invalid event visibility; only "default", "private" or "public" are allowed'
+            );
+        }
+        $eventData = $this->cloneDeep();
+        $eventData->visibility = $visibility;
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $transparency
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setTransparency(string $transparency): GoogleCalendarEventData
+    {
+        if ($transparency !== self::TRANSPARENCY_OPAQUE && $transparency !== self::TRANSPARENCY_TRANSPARENT) {
+            throw new InvalidArgumentException(
+                'Invalid event transparency; only "opaque" or "transparent" are allowed'
+            );
+        }
+        $eventData = $this->cloneDeep();
+        $eventData->transparency = $transparency;
+
+        return $eventData;
+    }
+
+    /**
+     * @param GoogleCalendarEventAttendeeValue|null $organizer
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function setOrganizer(GoogleCalendarEventAttendeeValue $organizer = null): GoogleCalendarEventData
+    {
+        $eventData = $this->cloneDeep();
+        $eventData->organizer = $organizer;
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $email
+     * @param string $displayName
+     * @param bool   $optional
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function addAttendee(
+        string $email,
+        string $displayName = '',
+        bool $optional = false
+    ): GoogleCalendarEventData {
+        $attendee = new GoogleCalendarEventAttendeeValue($email, $displayName, $optional);
+        $attendees = array_values($this->attendees);
+        $attendees[] = $attendee;
+
+        $eventData = $this->cloneDeep();
+        $eventData->attendees = $attendees;
+
+        return $eventData;
+    }
+
+    /**
+     * @return GoogleCalendarEventData
+     */
+    public function removeAttendees(): GoogleCalendarEventData
+    {
+        $eventData = $this->cloneDeep();
+        $eventData->attendees = [];
+
+        return $eventData;
+    }
+
+    /**
+     * @param string $method
+     * @param int    $minutes
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarEventData
+     */
+    public function addReminder(string $method, int $minutes): GoogleCalendarEventData
+    {
+        $reminder = new GoogleCalendarEventReminderValue($method, $minutes);
+        $reminders = array_values($this->reminders);
+        $reminders[] = $reminder;
+
+        $eventData = $this->cloneDeep();
+        $eventData->reminders = $reminders;
+
+        return $eventData;
+    }
+
+    /**
+     * @return GoogleCalendarEventData
+     */
+    public function removeReminders(): GoogleCalendarEventData
+    {
+        $eventData = $this->cloneDeep();
+        $eventData->reminders = [];
+
+        return $eventData;
+    }
+
+    /**
+     * @return array
+     */
+    public function jsonSerialize(): array
+    {
+        return $this->toArray();
+    }
+
+    /**
+     * @return GoogleCalendarEventData
+     */
+    private function cloneDeep(): GoogleCalendarEventData
+    {
+        $time = $this->time;
+        if ($this->time !== null) {
+            $time = new GoogleCalendarEventTimeValue(
+                $this->time->getBeginning(),
+                $this->time->getEnd(),
+                $this->time->isWholeday(),
+                $this->time->getTimezone()
+            );
+        }
+
+        $created = null;
+        if ($this->created !== null) {
+            $created = clone $this->created;
+        }
+        $updated = null;
+        if ($this->updated !== null) {
+            $updated = clone $this->updated;
+        }
+        $creator = null;
+        if ($this->creator !== null) {
+            $creator = clone $this->creator;
+        }
+        $organizer = null;
+        if ($this->organizer !== null) {
+            $organizer = clone $this->organizer;
+        }
+
+        return new self(
+            $this->id,
+            $this->etag,
+            $this->status,
+            $this->iCalUid,
+            $created,
+            $updated,
+            $creator,
+            $organizer,
+            $time,
+            $this->summary,
+            $this->description,
+            $this->location,
+            $this->attendees,
+            $this->reminders,
+            $this->visibility,
+            $this->transparency,
+            $this->sequence,
+            $this->colorId,
+            $this->htmlLink
+        );
+    }
+}

classes/Modules/GoogleCalendar/Data/GoogleCalendarEventReminderValue.php

@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+use Xentral\Modules\GoogleCalendar\Exception\InvalidArgumentException;
+
+final class GoogleCalendarEventReminderValue
+{
+    /** @var string METHOD_EMAIL */
+    public const METHOD_EMAIL = 'email';
+
+    /** @var string METHOD_POPUP */
+    public const METHOD_POPUP = 'popup';
+
+    /** @var string $method */
+    private $method;
+
+    /** @var int $minutes */
+    private $minutes;
+
+    /**
+     * @param string $method
+     * @param int $minutes
+     *
+     * @throws InvalidArgumentException
+     */
+    public function __construct(string $method, int $minutes)
+    {
+        if ($method !== self::METHOD_EMAIL && $method !== self::METHOD_POPUP) {
+            throw new InvalidArgumentException(
+                'Invalid notification method; only "email" and "popup" are allowed'
+            );
+        }
+        $this->method = $method;
+        $this->minutes = $minutes;
+    }
+
+    /**
+     * @param array $data
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarEventReminderValue
+     */
+    public static function fromArray(array $data): GoogleCalendarEventReminderValue
+    {
+        if (!isset($data['method'], $data['minutes'])) {
+            throw new InvalidArgumentException('method and minutes required for notification values.');
+        }
+
+        return new self($data['method'], $data['minutes']);
+    }
+
+    /**
+     * @return array
+     */
+    public function toArray(): array
+    {
+        $data = [];
+        $data['method'] = $this->getMethod();
+        $data['minutes'] = $this->getMinutes();
+
+        return $data;
+    }
+
+    /**
+     * @return string
+     */
+    public function getMethod(): string
+    {
+        return $this->method;
+    }
+
+    /**
+     * @return int
+     */
+    public function getMinutes(): int
+    {
+        return $this->minutes;
+    }
+}

classes/Modules/GoogleCalendar/Data/GoogleCalendarEventTimeValue.php

@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+use DateInterval;
+use DateTime;
+use DateTimeInterface;
+use Xentral\Modules\GoogleCalendar\Exception\InvalidArgumentException;
+
+final class GoogleCalendarEventTimeValue
+{
+    /** @var DateTimeInterface $beginning */
+    private $beginning;
+
+    /** @var DateTimeInterface $end */
+    private $end;
+
+    /** @var bool $wholeday */
+    private $wholeday;
+
+    /** @var string $timezone */
+    private $timezone;
+
+    /**
+     * @param DateTimeInterface $beginning
+     * @param DateTimeInterface $end
+     * @param bool              $wholeday
+     * @param string            $timezone
+     */
+    public function __construct(
+        DateTimeInterface $beginning,
+        DateTimeInterface $end,
+        bool $wholeday = false,
+        string $timezone = ''
+    ) {
+        $this->beginning = $beginning;
+        $this->end = $end;
+        $this->wholeday = $wholeday;
+        $this->timezone = $timezone;
+    }
+
+    /**
+     * @param array $data
+     *
+     * @throws InvalidArgumentException
+     *
+     * @return GoogleCalendarEventTimeValue
+     */
+    public static function createFromJsonArray(array $data): GoogleCalendarEventTimeValue
+    {
+        if (!array_key_exists('start', $data) || !array_key_exists('end', $data)) {
+            throw new InvalidArgumentException('Data format invalid.');
+        }
+
+        $begin = null;
+        $end = null;
+        $wholeday = false;
+        $timeZone = '';
+
+        if (isset($data['start']['dateTime'], $data['end']['dateTime'])) {
+            $begin = DateTime::createFromFormat(DateTimeInterface::RFC3339, $data['start']['dateTime']);
+            $end = DateTime::createFromFormat(DateTimeInterface::RFC3339, $data['end']['dateTime']);
+            if (isset($data['start']['timeZone'])) {
+                $timeZone = $data['start']['timeZone'];
+            }
+        }
+
+        if (isset($data['start']['date'], $data['end']['date'])) {
+            $formatted = sprintf('%s 00:00:00', $data['start']['date']);
+            $begin = DateTime::createFromFormat('Y-m-d H:i:s', $formatted);
+            $formatted = sprintf('%s 00:00:00', $data['end']['date']);
+            $end = DateTime::createFromFormat('Y-m-d  H:i:s',$formatted);
+            $wholeday = true;
+        }
+
+        if (empty($begin) || empty($end)) {
+            throw new InvalidArgumentException('Data format invalid.');
+        }
+
+        return new GoogleCalendarEventTimeValue($begin, $end, $wholeday, $timeZone);
+    }
+
+    /**
+     * @return array
+     */
+    public function toDataArray(): array
+    {
+        $data = [];
+
+        if ($this->isWholeday()) {
+            $data['start']['date'] = $this->getBeginning()->format('Y-m-d');
+            $data['end']['date'] = $this->getEnd()->format('Y-m-d');
+        } else {
+            $data['start']['dateTime'] = $this->getBeginning()->format(DateTimeInterface::RFC3339);
+            $data['end']['dateTime'] = $this->getEnd()->format(DateTimeInterface::RFC3339);
+        }
+        if ($this->getTimezone() !== '') {
+            $data['start']['timeZone'] = $this->getTimezone();
+            $data['end']['timeZone'] = $this->getTimezone();
+        }
+
+        return $data;
+    }
+
+    /**
+     * @return DateTimeInterface
+     */
+    public function getBeginning(): DateTimeInterface
+    {
+        return $this->beginning;
+    }
+
+    /**
+     * @return DateTimeInterface
+     */
+    public function getEnd(): DateTimeInterface
+    {
+        return $this->end;
+    }
+
+    /**
+     * returns duration in seconds
+     * 
+     * @return int
+     */
+    public function getDuration(): int
+    {
+        return (int) $this->end->getTimestamp() - $this->beginning->getTimestamp();
+    }
+
+    /**
+     * @return DateInterval
+     */
+    public function getInterval(): DateInterval
+    {
+        return $this->end->diff($this->beginning, true);
+    }
+
+    /**
+     * @return bool
+     */
+    public function isWholeday(): bool
+    {
+        return $this->wholeday;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTimezone(): string
+    {
+        return $this->timezone;
+    }
+}

classes/Modules/GoogleCalendar/Data/GoogleCalendarListItem.php

@@ -0,0 +1,146 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+use Xentral\Modules\GoogleCalendar\Exception\InvalidArgumentException;
+
+final class GoogleCalendarListItem
+{
+    /** @var string ROLE_READER */
+    public const ROLE_READER = 'reader';
+
+    /** @var string ROLE_OWNER */
+    public const ROLE_OWNER = 'owner';
+
+    /** @var string ROLE_FREEBUSYREADER */
+    public const ROLE_FREEBUSYREADER = 'freeBusyReader';
+
+    /** @var string $kind */
+    private static $kind = 'calendar#calendarListEntry';
+
+    /** @var string $id */
+    private $id;
+
+    /** @var string $summary */
+    private $summary;
+
+    /** @var string $role */
+    private $role;
+
+    /** @var string $timeZone */
+    private $timeZone;
+
+    /** @var string $colorId */
+    private $colorId;
+
+    /** @var bool $selected */
+    private $selected;
+
+    /** @var bool $primary */
+    private $primary;
+
+    /**
+     * @param string $id
+     * @param string $summary
+     * @param string $role
+     * @param string $timeZone
+     * @param string $colorId
+     * @param bool   $selected
+     * @param bool   $primary
+     */
+    public function __construct($id, $summary, $role, $timeZone, $colorId, $selected = false, $primary = false)
+    {
+        $this->id = $id;
+        $this->summary = $summary;
+        if ($role !== self::ROLE_FREEBUSYREADER && $role !== self::ROLE_READER && $role !== self::ROLE_OWNER) {
+            throw  new InvalidArgumentException('Invalid calendar Role.');
+        }
+        $this->role = $role;
+        $this->timeZone = $timeZone;
+        $this->colorId = $colorId;
+        $this->selected = $selected;
+        $this->primary = $primary;
+    }
+
+    /**
+     * @param $data
+     *
+     * @return GoogleCalendarListItem
+     */
+    public static function fromArray($data)
+    {
+        if (!isset($data['kind']) || $data['kind'] !== self::$kind) {
+            throw new InvalidArgumentException('Invalid resource type. Expected: calendar#event');
+        }
+        if (!isset($data['id'])) {
+            throw new InvalidArgumentException('Missing required resorce field "id".');
+        }
+        $id = $data['id'];
+        $summary = $data['summary'];
+        $role = $data['accessRole'];
+        $timeZone = $data['timeZone'];
+        $colorId = $data['colorId'];
+        $selected = (isset($data['selected']) && $data['selected'] === true);
+        $primary = (isset($data['primary']) && $data['primary'] === true);
+
+        return new self($id, $summary, $role, $timeZone, $colorId, $selected, $primary);
+    }
+
+    /**
+     * @return string
+     */
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return string
+     */
+    public function getSummary()
+    {
+        return $this->summary;
+    }
+
+    /**
+     * @return string
+     */
+    public function getRole()
+    {
+        return $this->role;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTimeZone()
+    {
+        return $this->timeZone;
+    }
+
+    /**
+     * @return string
+     */
+    public function getColorId()
+    {
+        return $this->colorId;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isSelected()
+    {
+        return $this->selected;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isPrimary()
+    {
+        return $this->primary;
+    }
+}

classes/Modules/GoogleCalendar/Data/GoogleCalenderSyncValue.php

@@ -0,0 +1,228 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\GoogleCalendar\Data;
+
+use DateTime;
+use DateTimeInterface;
+
+final class GoogleCalenderSyncValue
+{
+    /** @var int $id */
+    private $id;
+
+    /** @var int $eventId */
+    private $eventId;
+
+    /** @var string|null $googleId */
+    private $googleId;
+
+    /** @var bool $isFromGoogle */
+    private $isFromGoogle;
+
+    /** @var DateTimeInterface|null $eventDate */
+    private $eventDate;
+
+    /** @var int $owner */
+    private $owner;
+
+    /** @var string|null $htmlLink */
+    private $htmlLink;
+
+    /**
+     * @param int                    $id
+     * @param int                    $eventId
+     * @param string|null            $googleId
+     * @param int                    $owner
+     * @param bool                   $isFromGoogle
+     * @param DateTimeInterface|null $eventDate
+     * @param string|null            $htmlLink
+     */
+    public function __construct(
+        int $id = 0,
+        int $eventId = 0,
+        string $googleId = null,
+        int $owner = 0,
+        bool $isFromGoogle = false,
+        DateTimeInterface $eventDate = null,
+        string $htmlLink = null
+    ) {
+        $this->id = $id;
+        $this->eventId = $eventId;
+        $this->googleId = $googleId;
+        $this->isFromGoogle = $isFromGoogle;
+        $this->eventDate = $eventDate;
+        $this->owner = $owner;
+        $this->htmlLink = $htmlLink;
+    }
+
+    /**
+     * @return string
+     */
+    public function getEventDateAsString(): string
+    {
+        if ($this->eventDate === null) {
+            return '';
+        }
+
+        return $this->eventDate->format('Y-m-d H:i:s');
+    }
+
+    /**
+     * @param array $data
+     *
+     * @return GoogleCalenderSyncValue
+     */
+    public static function fromDbState(array $data): GoogleCalenderSyncValue
+    {
+        $instance = new self(
+            $data['id'],
+            $data['event_id'],
+            $data['foreign_id'],
+            $data['owner'],
+            $data['from_google'] === 1,
+            null,
+            $data['html_link']
+        );
+        if ($data['event_date'] !== null) {
+            $instance->setEventDate(DateTime::createFromFormat('Y-m-d H:i:s', $data['event_date']));
+        }
+
+        return $instance;
+    }
+
+    /**
+     * @return int
+     */
+    public function getId(): int
+    {
+        return $this->id;
+    }
+
+    /**
+     * @param int $id
+     *
+     * @return void
+     */
+    public function setId(int $id): void
+    {
+        $this->id = $id;
+    }
+
+    /**
+     * @return int
+     */
+    public function getEventId(): int
+    {
+        return $this->eventId;
+    }
+
+    /**
+     * @param int $eventId
+     *
+     * @return void
+     */
+    public function setEventId(int $eventId): void
+    {
+        $this->eventId = $eventId;
+    }
+
+    /**
+     * @return string
+     */
+    public function getGoogleId(): string
+    {
+        if ($this->googleId === null) {
+            return '';
+        }
+
+        return $this->googleId;
+    }
+
+    /**
+     * @param string $googleId
+     *
+     * @return void
+     */
+    public function setGoogleId(string $googleId): void
+    {
+        $this->googleId = $googleId;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isFromGoogle(): bool
+    {
+        return $this->isFromGoogle;
+    }
+
+    /**
+     * @param bool $isFromGoogle
+     *
+     * @return void
+     */
+    public function setIsFromGoogle(bool $isFromGoogle): void
+    {
+        $this->isFromGoogle = $isFromGoogle;
+    }
+
+    /**
+     * @return DateTimeInterface|null
+     */
+    public function getEventDate(): ?DateTimeInterface
+    {
+        return $this->eventDate;
+    }
+
+    /**
+     * @param DateTimeInterface $eventDate
+     *
+     * @return void
+     */
+    public function setEventDate(DateTimeInterface $eventDate): void
+    {
+        $this->eventDate = $eventDate;
+    }
+
+    /**
+     * @return int
+     */
+    public function getOwner(): int
+    {
+        return $this->owner;
+    }
+
+    /**
+     * @param int $owner
+     *
+     * @return void
+     */
+    public function setOwner(int $owner): void
+    {
+        $this->owner = $owner;
+    }
+
+    /**
+     * @return string
+     */
+    public function getHtmlLink(): string
+    {
+        if ($this->htmlLink === null) {
+            return '';
+        }
+
+        return $this->htmlLink;
+    }
+
+    /**
+     * @param string $htmlLink
+     *
+     * @return void
+     */
+    public function setHtmlLink(string $htmlLink): void
+    {
+        $this->htmlLink = $htmlLink;
+    }
+}