bemade-addons/caldav_sync/models/calendar_event.py

import uuid

import icalendar.cal

from odoo import models, api, fields
from odoo.addons.calendar.models.calendar_recurrence import MAX_RECURRENT_EVENT
import caldav
import logging
from datetime import datetime
from icalendar import vCalAddress, vText, vDatetime, vRecur, Event
import re
from pytz import timezone, utc
from typing import List, Dict, TypeVar, Optional
from markdownify import markdownify as md
import markdown2 as md2

_logger = logging.getLogger(__name__)

WEEKDAY_MAP = {
    0: "MO",
    1: "TU",
    2: "WE",
    3: "TH",
    4: "FR",
    5: "SA",
    6: "SU",
}

CalendarEvent = TypeVar("calendar.event", bound=models.Model)
User = TypeVar("res.users", bound=models.Model)
Partner = TypeVar("res.partner", bound=models.Model)


def _parse_rrule_string(rrule_str):
    def try_to_int(part):
        try:
            return int(part)
        except Exception:
            return part

    regex_str = "RRULE:(.*)$"
    regex = re.compile(regex_str)
    params_match = regex.search(rrule_str)
    params_part = params_match.groups()[0]
    params = params_part.split(";")
    params_dict = {}
    for param in params:
        parts = param.split("=")
        if parts[0].upper() == "UNTIL":
            if "T" in parts[1]:
                parts[1] = datetime.strptime(parts[1], "%Y%m%dT%H%M%S")
            else:
                parts[1] = datetime.strptime(parts[1], "%Y%m%d")
        if parts[0].upper() == "BYDAY":
            parts[1] = [part for part in parts[1].split(",")]
        params_dict.update({parts[0]: try_to_int(parts[1])})
    return params_dict


def _extract_vcal_email(vcal_address):
    email_regex = re.compile(r"[a-z0-9.\-+_]+@[a-z0-9.\-+_]+\.[a-z]+")
    res = email_regex.search(str(vcal_address))
    return res.group(0).lower().strip() if res else ""


class CalendarEvent(models.Model):
    _inherit = "calendar.event"

    # CalDAV UID is either unique per event or the same for all events in a recurring
    # sequence. This field and caldav_recurrence_id are not calculated fields since
    # the recalculation timing is hard to control and we want to make sure we sync
    # some modifications before the UID changes with recurrence_id and other changes on
    # the record.
    caldav_uid = fields.Char(string="CalDAV UID", store=True)
    # Recurrence ID in iCalendar is the date or datetime the event would have
    # been at if it followed the sequence. It is set by calendar.recurrence
    # when applying a recurrence.
    caldav_recurrence_id = fields.Datetime(
        string="CalDAV Recurrence ID",
    )
    caldav_user_ids = fields.Many2many(
        comodel_name="res.users",
        compute="_compute_caldav_users",
    )
    is_base_event = fields.Boolean(compute="_compute_is_base_event")
    differs_from_base_event = fields.Boolean(compute="_compute_differs_from_base_event")

    ###################################
    #### Field Computation Methods ####
    ###################################

    def _recompute_caldav_ids(self):
        for event in self:
            if event.recurrence_id:
                event.caldav_uid = event.recurrence_id.caldav_uid
                time = event.recurrence_id.dtstart.time()
                date = event.start.date()
                event.caldav_recurrence_id = datetime(
                    date.year,
                    date.month,
                    date.day,
                    time.hour,
                    time.minute,
                    time.second,
                )
            else:
                if not self._context.get("caldav_keep_ids"):
                    event.caldav_uid = uuid.uuid4()
                event.caldav_recurrence_id = False

    @api.depends("name", "description", "partner_ids", "location", "videocall_location")
    def _compute_differs_from_base_event(self):
        base_events = self.filtered("is_base_event")
        non_base_events = self - base_events
        for event in base_events:
            event.differs_from_base_event = False
        fields_to_check = [
            "name",
            "description",
            "partner_ids",
            "location",
            "videocall_location",
        ]
        for event in non_base_events:
            base_event = event.recurrence_id.base_event_id
            event.differs_from_base_event = (
                any(
                    [
                        getattr(event, field) != getattr(base_event, field)
                        for field in fields_to_check
                    ]
                )
                or not event.follow_recurrence
            )

    @api.depends("is_base_event")
    def _compute_update_all_recurrence(self):
        for rec in self:
            rec.update_all_recurrence = (
                rec.recurrency
                and rec.is_base_event
                and (
                    rec.recurrence_update == "all_events"
                    or not rec.recurrence_update
                    or rec.recurrence_id.calendar_event_ids == rec
                )
            )

    @api.depends("recurrency", "recurrence_id", "recurrence_id.base_event_id")
    def _compute_is_base_event(self):
        for rec in self:
            rec.is_base_event = (
                not rec.recurrence_id or rec.recurrence_id.base_event_id == rec
            )

    @api.depends("user_id", "partner_ids", "partner_ids.user_id")
    def _compute_caldav_users(self):
        for rec in self:
            rec.caldav_user_ids = (rec.user_id | rec.partner_ids.user_ids).filtered(
                "is_caldav_enabled"
            )

    def _is_caldav_enabled(self):
        return self.user_id.is_caldav_enabled

    def _get_ical_recurrence_id(self) -> datetime:
        """Get the recurrence-id to use for identifying this event
        specifically in an iCalendar instance.

        :return: The timezone-aware datetime that uniquely identifies this
        event in the recurrence chain.
        """
        event_tz = timezone(self.event_tz)
        recurrence_id = utc.localize(self.caldav_recurrence_id).astimezone(event_tz)
        return recurrence_id

    #################################################################
    #### Local Change Methods - Sending Updates to CalDAV Server ####
    #################################################################

    @api.model_create_multi
    def create(self, vals_list):
        ctx = {"caldav_no_sync": True}
        events = super(CalendarEvent, self.with_context(**ctx)).create(vals_list)
        events.with_context(**ctx)._recompute_caldav_ids()
        if not self.env.context.get("caldav_no_sync"):
            events._to_sync()._sync_create_to_caldav()
        return events

    def _sync_create_to_caldav(self):
        for event in self:
            for user in event.caldav_user_ids:
                client = user._get_caldav_client()
                calendar = client.calendar(url=user.caldav_calendar_url)
                try:
                    caldav_events = event._create_in_icalendar(calendar)
                    for caldav_event in caldav_events:
                        caldav_uid = caldav_event.vobject_instance.vevent.uid.value
                        event.with_context(caldav_no_sync=True).write(
                            {"caldav_uid": caldav_uid}
                        )
                except Exception as e:
                    _logger.error(f"Failed to sync event to CalDAV server: {e}")

    def write(self, vals):
        res = super(CalendarEvent, self.with_context(caldav_no_sync=True)).write(vals)
        # Events sometimes get archived in Odoo in the process of updating recurrence
        # In that case, we will delete them from the CalDAV server before recreating
        if "active" in vals and not vals.get("active"):
            for event in self:
                event._sync_unlink_to_caldav()
            return res
        to_sync = self._to_sync()
        if to_sync and not self.env.context.get("caldav_no_sync"):
            for rec in to_sync:
                rec._sync_write_to_caldav()
        return res

    def _sync_write_to_caldav(self):
        ical_event_data = self._create_event_data()
        for user in self.caldav_user_ids:
            client = user._get_caldav_client()
            calendar = client.calendar(url=user.caldav_calendar_url)

            base_event = self._get_caldav_base_event_by_uid(calendar, self.caldav_uid)
            if self.recurrence_id:
                tz = timezone(self.event_tz or self.env.user.tz)
                start = utc.localize(self.start).astimezone(tz)
                # We have an event in the recurrence chain that differs from the base
                # We need to add an iCalendar VEVENT with recurrence-id or update it
                if self.is_base_event:
                    # We have a normal base event, so we just update it or create it
                    self._update_base_caldav_event(
                        calendar, base_event, ical_event_data
                    )
                elif (
                    self.differs_from_base_event
                    or start != self._get_ical_recurrence_id()
                ):
                    # We have an event that differs from the base event in some way
                    # So we need to update or create its matching subcomponent, identified
                    # by its recurrence-id
                    if not base_event:
                        _logger.warning(
                            f"Failed to find base event for {self} on CalDAV server."
                        )
                        return
                    index = self._get_subcomponent_index_for_recurrence(base_event)
                    if index:
                        ical_event = base_event.icalendar_instance.subcomponents[index]
                        self._update_ical_event_values(ical_event, ical_event_data)
                    else:
                        base_event.icalendar_instance.add_component(
                            Event(**ical_event_data)
                        )
                    base_event.save()
            else:
                self._update_base_caldav_event(calendar, base_event, ical_event_data)

    def _update_base_caldav_event(
        self,
        calendar: icalendar.cal.Calendar,
        event: caldav.Event,
        ical_event_data: dict,
    ):
        if event:
            self._update_ical_event_values(event.icalendar_component, ical_event_data)
            event.save()
        else:
            calendar.add_event(**ical_event_data)

    @api.model
    def _update_ical_event_values(
        self, ical_event: icalendar.cal.Event, event_data: dict
    ):
        sequence = (seq := ical_event.get("sequence") or 0) + 1
        event_data.update(sequence=sequence)
        for key, value in event_data.items():
            ical_event[key] = value

    def _get_caldav_base_event_by_uid(
        self, calendar: caldav.Calendar, uid: str
    ) -> Optional[CalendarEvent]:
        for event in calendar.events():
            component = event.icalendar_component
            event_uid = self._extract_component_text(component, "uid")
            if event_uid == uid and not component.get("recurrence-id"):
                return event

    def unlink(self):
        if not self.env.context.get("caldav_no_sync"):
            for rec in self._to_sync():
                try:
                    rec._sync_unlink_to_caldav()
                except Exception as e:
                    _logger.error(f"Failed to delete event from CalDAV server: {e}")
        return super(CalendarEvent, self).unlink()

    def _get_subcomponent_index_for_recurrence(
        self, caldav_event: caldav.Event
    ) -> Optional[int]:
        ical_instance = caldav_event.icalendar_instance
        for index, component in enumerate(ical_instance.subcomponents):
            if component.get("name") == "VEVENT" and (
                rec_id := component.get("recurrence-id")
                and rec_id.dt == self._get_ical_recurrence_id()
            ):
                return index

    def _sync_unlink_to_caldav(self):
        delete_all = self._context.get("caldav_delete_all", False)
        if self.caldav_uid:
            for user in self.caldav_user_ids:
                client = user._get_caldav_client()
                calendar = client.calendar(url=user.caldav_calendar_url)
                try:
                    caldav_event = calendar.event_by_uid(self.caldav_uid)
                    if not delete_all and self.recurrence_id and not self.is_base_event:
                        index = self._get_subcomponent_index_for_recurrence(
                            caldav_event
                        )
                        if index:
                            caldav_event.icalendar_instance.subcomponents.pop(index)
                        caldav_event.save()
                    else:
                        # In some cases, like when events are detached from a recurrence,
                        # they can be base events but have an old caldav_uid from when
                        # they were recurring. That's why we make sure that the start
                        # of the event matches.
                        if delete_all or self._matches_caldav_start(caldav_event):
                            caldav_event.delete()
                except caldav.error.NotFoundError:
                    # No worries - it just didn't exist so nothing to sync
                    pass
                except Exception as e:
                    _logger.error(f"Failed to remove event from CalDAV server: {e}")

    def _matches_caldav_start(self, caldav_event: caldav.Event) -> bool:
        event_start = caldav_event.icalendar_component.get("dtstart").dt
        tz = event_start.tzinfo
        self_start = utc.localize(self.start).astimezone(tz)
        return self_start == event_start

    def _update_future_events(self, values, time_values, recurrence_values):
        """When self makes a change updating future events in the recurrence, we need
        only to make sure that self is properly synchronized after the change. We also
        need to make sure that the recurrence rule on the old base event is re-synced.
        The superclass method already archives all the future events and re-creates
        them, so we implicitly delete them from the CalDAV server before writing the
        new base event (self).

        We do, however, need to get a new caldav_uid and caldav_recurrence_id for all
        the events in the new chain.
        """
        ctx = {"keep_caldav_ids": False}
        old_base = self.recurrence_id.base_event_id
        super().with_context(**ctx)._update_future_events(
            values, time_values, recurrence_values
        )
        events_to_refresh = self.recurrence_id._get_events_from(self.start)
        # Future events are archived but not this one. We need to remove the old version
        # from the calendar if it existed.
        self._sync_unlink_to_caldav()
        events_to_refresh.with_context(**ctx)._recompute_caldav_ids()
        self._sync_write_to_caldav()
        old_base._sync_write_to_caldav()

    def _break_recurrence(self, future=True):
        recurrence = self.recurrence_id
        detached_events = super()._break_recurrence(future) | self
        # detached_events are already removed from the CalDAV server in
        # calendar.recurrence._detach_events. We now need to reinitialize them.
        for event in detached_events:
            event._sync_write_to_caldav()
        if future:
            # When future=True, the base event needs to re-sync its recurrence values
            recurrence.base_event_id._sync_write_to_caldav()
        return detached_events - self

    def _rewrite_recurrence(self, values, time_values, recurrence_values):
        """
        When _rewrite_recurrence is called, it archives all the events in the
        recurrence but only after messing with the recurrence_id. This breaks our check
        on is_base_event, so we preemptively sync the deletion here.

        Because this method is usually called with caldav_no_sync=True in the context
        to avoid looping, we manually call _sync_write_to_caldav once the operation is
        completed.
        """
        for event in self.recurrence_id.calendar_event_ids:
            event.with_context(caldav_delete_all=True)._sync_unlink_to_caldav()
        res = super()._rewrite_recurrence(values, time_values, recurrence_values)
        for event in self.recurrence_id.calendar_event_ids:
            event._recompute_caldav_ids()
        self._sync_write_to_caldav()
        return res

    def _to_sync(self):
        """Determine which records in self we need to synchronize with the
        CalDAV server. In essence, we only synchronize base events and those
        differing from the base event in a recurring chain."""
        return self.filtered(
            lambda event: event.id
            and event._is_caldav_enabled()
            and (event.is_base_event or event.differs_from_base_event)
        )

    def _create_in_icalendar(self, calendar: caldav.Calendar) -> List[caldav.Event]:
        """Create an event matching self in the provided calendar.

        :param calendar: The calendar in which to create the event.
        :return: The list of created events, usually one.
        """
        ical_event_data = self._create_event_data()
        caldav_event = calendar.save_event(**ical_event_data)
        if self.recurrence_id and self.is_base_event and not self.follow_recurrence:
            ical_event_data = self._create_event_data()
            second_caldav_event = calendar.save_event(**ical_event_data)
            return [caldav_event, second_caldav_event]
        return [caldav_event]

    def _create_event_data(self) -> Dict:
        """Create a dictionary of iCalendar compatible event data."""
        event_data = {}
        self._add_event_dates(event_data)
        self._add_event_header_info(event_data)
        self._add_event_attendees(event_data)
        if self.is_base_event and self.recurrence_id:
            self._add_event_recurrence(event_data)
        elif self.recurrence_id:
            self._add_event_recurrence_id(event_data)
        return event_data

    def _add_event_header_info(self, event_data: Dict) -> None:
        """Add event header info to a dict containing event data.

        IMPORTANT: the VEVENT sequence is set to 0. It should be changed if this method
        is used to update an existing event!

        :param event_data: The dictionary of event data to be updated with header info.
        """
        event_data["uid"] = vText(self.caldav_uid)
        if self.name:
            event_data["summary"] = vText(self.name)
        # TODO: Consider using X-ALT-DESC to stick HTML into the iCal event desc.
        if self.description and self._html_to_text(self.description):
            event_data["description"] = vText(self._html_to_text(self.description))
        if self.location:
            event_data["location"] = vText(self.location)
        if self.videocall_location:
            event_data["conference"] = self.videocall_location
        event_data["sequence"] = 0

    def _add_event_dates(self, event_data: Dict) -> None:
        """Add pertinent dates to event data, based on self."""
        tz = self.event_tz or self.env.user.tz
        event_tz = timezone(tz)
        event_data["last-modified"] = vDatetime(
            utc.localize(self.write_date).astimezone(event_tz)
        )
        event_data["created"] = vDatetime(
            utc.localize(self.create_date).astimezone(event_tz)
        )
        event_data["dtstart"] = vDatetime(utc.localize(self.start).astimezone(event_tz))
        event_data["dtend"] = vDatetime(utc.localize(self.stop).astimezone(event_tz))
        return event_data

    def _add_event_recurrence_id(self, event_data: Dict) -> None:
        """Add the recurrence-id parameter to event data if self is linked
        to a calendar.recurrence record."""
        if self.recurrence_id:
            event_data["recurrence-id"] = vDatetime(self._get_ical_recurrence_id())

    def _add_event_recurrence(self, event_data: Dict) -> None:
        """Add the recurrence rule (rrule) to event data if self is
        recurrent. This should only be called for base events."""
        if self.recurrence_id:
            rrule = str(self.recurrence_id._get_rrule())
            rrule_dict = _parse_rrule_string(rrule)
            event_data["rrule"] = vRecur(**rrule_dict)

    def _add_event_attendees(self, event_data: Dict) -> None:
        """Add the attendee information to the "organizer" and "attendee"
        keys of the event data."""
        attendee_lines = []
        for partner in self.partner_ids:
            if partner == self.user_id.partner_id:
                continue
            attendee = vCalAddress(f"MAILTO:{partner.email}")
            attendee.params["cn"] = vText(partner.name)
            attendee_record = self.env["calendar.attendee"].search(
                [("event_id", "=", self.id), ("partner_id", "=", partner.id)],
                limit=1,
            )
            if attendee_record:
                attendee.params["partstat"] = vText(
                    self._map_attendee_status(attendee_record.state)
                )
            attendee_lines.append(attendee)
        organizer = vCalAddress(f"MAILTO:{self.user_id.email}")
        organizer.params["cn"] = self.user_id.name
        event_data["organizer"] = organizer
        event_data["attendee"] = attendee_lines

    @api.model
    def _html_to_text(self, html):
        return md(html, heading_style="ATX")

    @api.model
    def _map_attendee_status(self, state: str) -> str:
        """Map the state of an Odoo event attendee to its iCalendar
        equivalent.

        :param state: The state of the Odoo event attendee.
        :return: The equivalent iCalendar attendee state."""
        mapping = {
            "needsAction": "NEEDS-ACTION",
            "accepted": "ACCEPTED",
            "declined": "DECLINED",
            "tentative": "TENTATIVE",
        }
        return mapping.get(state, "NEEDS-ACTION")

    ###################################################################
    #### Methods for synchronizing changes from the server to Odoo ####
    ###################################################################

    @api.model
    def poll_caldav_server(self) -> None:
        """Poll each user's CalDAV calendar server for changes and
        synchronize them with their Odoo calendar."""
        all_users = self.env["res.users"].search([("is_caldav_enabled", "=", True)])
        for user in all_users:
            self._poll_user_caldav_server(user)

    @api.model
    def _poll_user_caldav_server(self, user) -> None:
        """Poll a single user's CalDAV calendar on the server for changes
        and synchronize them to Odoo.

        :param user: The res.user record for whom to synchronize events.
        """
        _logger.info(f"Polling CalDAV server for user {user.name}")
        calendar = user._get_caldav_client().calendar(url=user.caldav_calendar_url)
        events = calendar.events()
        synced_events = self.env["calendar.event"]
        for caldav_event in events:
            ical_event = caldav_event.icalendar_instance
            synced_events |= self._sync_event_from_ical(ical_event, user)

        # TODO: check if this fails when the user is deleting someone else's event
        # TODO: check if we should send updates to invitees
        orphaned_events = self.search(
            [
                ("caldav_uid", "!=", False),
                ("id", "not " "in", synced_events.ids),
                ("user_id", "=", user.id),
            ]
        )
        orphaned_events = orphaned_events._to_sync()
        if orphaned_events:
            base_orphans = orphaned_events.filtered(
                lambda ev: ev.recurrence_id and ev.is_base_event
            )
            for base_orphan in base_orphans:
                try:
                    if calendar.event_by_uid(base_orphan.caldav_uid):
                        # There are some events remaining in this recurrence series,
                        # so we have synchronized them individually.
                        pass
                except caldav.error.NotFoundError:
                    # There are no more events with this UID, so we need to clear
                    # out the whole recurrence chain from the Odoo side.
                    ctx = {"caldav_no_sync": True}
                    recurrence = base_orphan.recurrence_id
                    recurrence.calendar_event_ids.with_context(**ctx).with_user(
                        user
                    ).unlink()
                    recurrence.with_context(**ctx).with_user(user).unlink()
            (orphaned_events - base_orphans).with_context(
                caldav_no_sync=True
            ).with_user(user).unlink()

    @api.model
    def _sync_event_from_ical(
        self, ical_event: icalendar.cal.Event, user: User
    ) -> CalendarEvent:
        """Given an iCalendar event, compare the event with any existing
        Odoo event that it matches and synchronize the changes. If no event
        exists, create one.

        :param ical_event: The iCalendar event to synchronize with Odoo.
        :param user: The res.user record for whom to synchronize the event.
        :return: The calendar.event records that were synchronized.
        """
        synced_events = self.env["calendar.event"]
        event_components = [
            component for component in ical_event.walk() if component.name == "VEVENT"
        ]
        for component in event_components:
            uid = str(component.get("uid"))
            recurrence_id = (
                component.get("recurrence-id").dt
                if "recurrence-id" in component
                else None
            )

            existing_instance = self._get_existing_instance(uid, recurrence_id)
            outdated = self._get_outdated(component, existing_instance, synced_events)
            owned = (
                existing_instance and existing_instance.partner_id == user.partner_id
            )
            values = self._get_values_from_ical_component(component, user)
            recurrency_vals = self._get_recurrency_values_from_ical_event(component)
            if not existing_instance:
                # If we're creating an instance and it doesn't follow the recurrence,
                # just scrap the recurrency vals, they're not useful
                if not recurrency_vals.get("follow_recurrence"):
                    recurrency_vals = {}

                new_event = self.with_context(
                    caldav_no_sync=True, caldav_keep_ids=True
                ).create(values | recurrency_vals)
                self.env["calendar.event"].flush_model()
                if new_event.recurrency:
                    synced_events |= new_event.recurrence_id.calendar_event_ids
                else:
                    synced_events |= new_event
                continue
            elif outdated or not owned:
                pass
            else:
                changed_vals = existing_instance._get_recurrence_changes(
                    recurrency_vals
                ) | existing_instance._get_value_changes(values)
                if changed_vals:
                    existing_instance.with_context(
                        caldav_no_sync=True,
                        caldav_keep_ids=True,
                    ).write(changed_vals)

            if existing_instance.recurrency and existing_instance.is_base_event:
                synced_events |= existing_instance.recurrence_id.calendar_event_ids
            else:
                synced_events |= existing_instance
        return synced_events

    @api.model
    def _get_existing_instance(self, uid, recurrence_id: datetime) -> CalendarEvent:
        """Find the Odoo calendar.event record matching uid and,
        if set, recurrence_id.
        """
        if recurrence_id:
            recurrence_id = recurrence_id.astimezone(utc).replace(tzinfo=None)
            instance = self.env["calendar.event"].search(
                [
                    ("caldav_uid", "=", uid),
                    ("caldav_recurrence_id", "=", recurrence_id),
                ]
            )
        else:
            instance = self.env["calendar.event"].search(
                [
                    ("caldav_uid", "=", uid),
                    ("recurrency", "=", False),
                ]
            )
            if instance:
                return instance
            else:
                return (
                    self.env["calendar.recurrence"]
                    .search(
                        [
                            ("base_event_id.caldav_uid", "=", uid),
                        ]
                    )
                    .base_event_id
                )

        if len(instance) == 1:
            return instance
        if len(instance) > 1:
            instance = instance.recurrence_id.base_event_id

        return instance or self.env["calendar.event"].search(
            [
                ("caldav_uid", "=", "uid"),
                ("recurrence_id", "=", False),
            ]
        )

    @api.model
    def _get_recurrency_values_from_ical_event(
        self, component: icalendar.cal.Component
    ) -> Dict:
        """Match the fields from calendar.event (recurring fields) to the fields specified in RRULE at
        https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html"""
        rrule = [item[1] for item in component.property_items() if item[0] == "RRULE"]
        rrule = rrule[0] if rrule else None

        if component.get("recurrence-id"):
            # When a component has "recurrence-id" set, it is a single event
            # in a series of events. Recurrence-id is the time the event should
            # normally occur at if it follows the recurrence of the series.
            follows_recurrence = (
                component.get("recurrence-id").dt == component.get("dtstart").dt
            )
            if not follows_recurrence:
                return {
                    "follow_recurrence": False,
                    "recurrence_update": "self_only",
                }
            if not rrule:
                # This event is following the base event's recurrence rule
                return {
                    "follow_recurrence": True,
                    "recurrence_update": "self_only",
                }

        if not rrule:
            return {}
        if rrule.get("until"):
            rrule["until"] = rrule.get("until")[0].astimezone(utc)
        rrule_str = rrule.to_ical() and rrule.to_ical().decode("utf-8")
        rrule_params = self.env["calendar.recurrence"]._rrule_parse(
            "RRULE:" + rrule_str, component.get("dtstart").dt.astimezone(utc)
        )
        vals = {
            "recurrency": True,
            "follow_recurrence": True,
            "recurrence_update": "future_events",
            **rrule_params,
        }
        # Convert None to False since fields from Odoo that are not filled come back False
        vals = {
            key: value if value is not None else False for key, value in vals.items()
        }

        # Forever doesn't exist in Odoo. The calendar.recurrence model changes 'forever'
        # into 'count' with MAX_RECURRENT_EVENT as the 'count' parameter
        if vals.get("end_type") == "forever":
            vals.update(end_type="count")
            if not vals.get("count"):
                vals.update(count=MAX_RECURRENT_EVENT)
        if vals.get("until"):
            until_day = vals.get("until").date()
            vals.update(until=until_day)
            vals.pop("count", None)
        return vals

    def _get_recurrence_changes(self, recurrency_vals: Dict) -> Dict:
        """Compare a set of recurrency values with those already present on
        this event.

        :param recurrency_vals: The recurrency values from an iCalendar event
        to compare to self.

        :return: A dictionary containing only the values that are different
        from those in self."""
        if not recurrency_vals and not self.recurrence_id:
            return {}
        if not recurrency_vals and self.recurrence_id:
            return {"recurrence_update": "all_events", "recurrency": False}
        if recurrency_vals and not self.recurrence_id:
            return recurrency_vals
        changed_fields = {
            key: recurrency_vals[key]
            for key in recurrency_vals.keys()
            if hasattr(self, key) and recurrency_vals[key] != getattr(self, key)
        }
        if len(changed_fields) == 1 and "recurrence_update" in changed_fields:
            return {}
        return changed_fields

    def _get_value_changes(self, values: Dict) -> Dict:
        """Compare the values from an iCalendar event to those already
        present on self.

        :param values: The values from an iCalendar event
        :return: A dictionary containing only the values that are different
        from those in self."""
        changed_vals = {}
        # Don't update partner_ids if no change
        if "partner_ids" in values:
            partner_ids = values["partner_ids"][0][2]  # this is a SET command
            added_partner_ids = set(
                [id for id in partner_ids if id not in self.partner_ids.ids]
            )
            removed_partner_ids = set(
                [id for id in self.partner_ids.ids if id not in partner_ids]
            )
            if not (added_partner_ids or removed_partner_ids):
                values.pop("partner_ids")  # They break the equality check later
            else:
                changed_vals["partner_ids"] = values["partner_ids"]

        # Get just the list of values that have changed, leave the others alone
        for key, val in values.items():
            curr_val = getattr(self, key)
            # Can't deal with x2many fields, need ID from a record
            if isinstance(val, list):
                continue
            if curr_val and isinstance(curr_val, models.Model):
                if len(curr_val) > 1:
                    continue
                curr_val = curr_val.id
            if curr_val != val:
                changed_vals.update({key: val})
        return changed_vals

    @api.model
    def _get_outdated(
        self,
        component: icalendar.cal.Component,
        existing_instance: CalendarEvent,
        synced_events: CalendarEvent,
    ) -> bool:
        """Check whether a component from the CalDAV server (typically an
        event) is outdated when compared to its existing Odoo calendar.event
        instance.

        :param component: The iCalendar component to check.
        :param existing_instance: The calendar.event record to
        compare with.
        :param synced_events: The calendar.event record(s) that have already
        been synchronized.
        :return: True if the iCalendar component is outdated, False otherwise.
        """
        outdated = False
        last_modified = component.get("dtstamp") and component.get("dtstamp").dt
        if (
            existing_instance
            and last_modified
            and existing_instance not in synced_events
        ):
            if last_modified < utc.localize(existing_instance.write_date):
                outdated = True
        return outdated

    @api.model
    def _get_values_from_ical_component(
        self, component: icalendar.cal.Component, user: User
    ) -> Dict:
        """Get the dictionary representing calendar.event field values from
        an iCalendar event.

        :param component: The iCalendar component from which to extract
        values.
        :param user: The res.users record the event will belong to.
        :return: The dictionary of values to construct a calendar.event."""
        start = component.get("dtstart") and component.decoded("dtstart")
        if isinstance(start, datetime):
            start = start.astimezone(utc).replace(tzinfo=None)
        end = component.get("dtend") and component.decoded("dtend")
        if isinstance(end, datetime):
            end = end.astimezone(utc).replace(tzinfo=None)
        organizer = self._get_organizer_partner(component)
        attendee_ids = self._get_attendee_partners(component, user.partner_id.email)
        values = {
            "name": str(component.get("summary")),
            "start": start,
            "stop": end,
            "description": self._text_to_html(
                self._extract_component_text(component, "description")
            ),
            "location": self._extract_component_text(component, "location"),
            "videocall_location": self._extract_component_text(component, "conference"),
            "caldav_uid": str(component.get("uid")),
            "partner_ids": [(6, 0, attendee_ids.ids)],
            "partner_id": organizer.id if organizer else user.partner_id.id,
            "user_id": user.id,
        }
        return values

    @api.model
    def _get_attendee_partners(
        self, component: icalendar.cal.Component, current_user_email: str
    ) -> Partner:
        """Get the res.partner records who are attendees for a given
        iCalendar event.

        :param component: The iCalendar component from which to extract
        attendees.
        :param current_user_email: The email for the res.users record the
        matching Odoo event belongs to.
        :return: The res.partner records who are attendees for the event."""
        attendee_emails = self._get_ical_attendee_emails(component)
        if current_user_email not in attendee_emails:
            attendee_emails.append(current_user_email)
        existing_partners = self.env["res.partner"].search(
            [("email", "in", attendee_emails)]
        )
        missing_emails = [
            email
            for email in attendee_emails
            if email not in [partner.email for partner in existing_partners]
        ]
        added_partners = self.env["res.partner"].create(
            [
                {
                    "name": email,
                    "email": email,
                }
                for email in missing_emails
            ]
        )
        final_attendees = {}
        all_partners = existing_partners | added_partners
        # We do this because partners may have identical emails and we only want one
        # attending partner per email. Otherwise invitations get sent out multiple times
        # and nobody likes that.
        # Prioritize users as attendees
        for partner in all_partners.filtered(lambda partner: bool(partner.user_id)):
            if partner.email not in final_attendees:
                final_attendees[partner.email] = partner.id

        for partner in all_partners.filtered(lambda partner: not partner.user_id):
            if partner.email not in final_attendees:
                final_attendees[partner.email] = partner.id

        return all_partners.filtered(
            lambda partner: partner.id in final_attendees.values()
        )

    @api.model
    def _get_organizer_partner(self, component: icalendar.cal.Component) -> Partner:
        """Get the partner matching the organizer on an iCalendar event.

        :param component: The iCalendar component from which to extract the
        organizer.
        :return: The res.partner record matching the event organizer."""

        organizer = component.get("organizer")
        if organizer:
            partner = self.env["res.partner"].search(
                [("email", "=", _extract_vcal_email(organizer))]
            )
            # TODO: prioritize partner with a user if there is one
            return partner[0] if partner else partner  # partner[0] in case many matches
        else:
            return self.env["res.partner"]

    @api.model
    def _get_ical_attendee_emails(
        self, component: icalendar.cal.Component
    ) -> List[str]:
        """Get the email addresses for attendees from an iCalendar event.

        :param component: The iCalendar event from which to extract emails.
        :return: A list of attendee emails
        """
        attendees = component.get("attendee", [])
        if not isinstance(attendees, list):
            attendees = [attendees]
        attendee_emails = [_extract_vcal_email(attendee) for attendee in attendees]
        return attendee_emails

    @api.model
    def _extract_component_text(
        self, component: icalendar.cal.Component, subcomponent_name: str
    ) -> str:
        """Extract the text from an iCalendar subcomponent. Convenience
        method to deal with empty subcomponents.

        :param component: The iCalendar component from which to extract text.
        :param subcomponent_name: The name of the subcomponent to extract.
        :return: The extracted subcomponent text or an empty string.
        """
        val = component.get(subcomponent_name)
        text = str(val) if val else ""
        return text

    @api.model
    def _text_to_html(self, text):
        return md2.markdown(text)