342 lines
15 KiB
Python
342 lines
15 KiB
Python
import uuid
|
|
from odoo import models, api, fields
|
|
import caldav
|
|
import logging
|
|
from datetime import datetime
|
|
from icalendar import Calendar, Event, vCalAddress, Alarm, vText
|
|
from bs4 import BeautifulSoup
|
|
from dateutil.rrule import rrulestr
|
|
from datetime import timedelta
|
|
import re
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
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('=')
|
|
params_dict.update({parts[0]: try_to_int(parts[1])})
|
|
return params_dict
|
|
|
|
|
|
class CalendarEvent(models.Model):
|
|
_inherit = 'calendar.event'
|
|
|
|
caldav_uid = fields.Char(string='CalDAV UID', readonly=True)
|
|
caldav_recurrence_id = fields.Char(string='CalDAV Recurrence ID', readonly=True)
|
|
|
|
@api.model
|
|
def create(self, vals):
|
|
if not vals.get('caldav_uid'):
|
|
vals['caldav_uid'] = str(uuid.uuid4())
|
|
event = super(CalendarEvent, self).create(vals)
|
|
if not self.env.context.get('caldav_no_sync'):
|
|
try:
|
|
_logger.debug(f"Creating event {event.name} in CalDAV")
|
|
event.sync_create_to_caldav()
|
|
except Exception as e:
|
|
_logger.error(f"Failed to create event in CalDAV server: {e}")
|
|
return event
|
|
|
|
def write(self, vals):
|
|
res = super(CalendarEvent, self).write(vals)
|
|
if not self.env.context.get('caldav_no_sync') and self.id:
|
|
try:
|
|
_logger.debug(f"Updating event {self.name} in CalDAV")
|
|
self.sync_update_to_caldav()
|
|
except Exception as e:
|
|
_logger.error(f"Failed to update event in CalDAV server: {e}")
|
|
return res
|
|
|
|
def unlink(self):
|
|
if not self.env.context.get('caldav_no_sync'):
|
|
for event in self:
|
|
try:
|
|
_logger.debug(f"Removing event {event.name} from CalDAV")
|
|
event.sync_remove_from_caldav()
|
|
except Exception as e:
|
|
_logger.error(f"Failed to delete event from CalDAV server: {e}")
|
|
return super(CalendarEvent, self).unlink()
|
|
|
|
def _is_caldav_enabled(self):
|
|
return self.env.user.is_caldav_enabled()
|
|
|
|
def _get_caldav_client(self):
|
|
user = self.env.user
|
|
return caldav.DAVClient(
|
|
url=user.caldav_calendar_url,
|
|
username=user.caldav_username,
|
|
password=user.caldav_password
|
|
)
|
|
|
|
def sync_create_to_caldav(self):
|
|
if not self._is_caldav_enabled():
|
|
return
|
|
client = self._get_caldav_client()
|
|
calendar = client.calendar(url=self.env.user.caldav_calendar_url)
|
|
for event in self:
|
|
ical_event = event._get_icalendar()
|
|
try:
|
|
_logger.debug(f"Creating new CalDAV event for {event.name}")
|
|
caldav_event = calendar.add_event(ical_event)
|
|
caldav_uid = caldav_event.vobject_instance.vevent.uid.value
|
|
_logger.debug(f"New CalDAV UID: {caldav_uid}")
|
|
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 sync_update_to_caldav(self):
|
|
if not self._is_caldav_enabled():
|
|
return
|
|
client = self._get_caldav_client()
|
|
calendar = client.calendar(url=self.env.user.caldav_calendar_url)
|
|
for event in self:
|
|
ical_event = event._get_icalendar()
|
|
try:
|
|
_logger.debug(f"Updating existing CalDAV event {event.caldav_uid}")
|
|
calendar.save_event(ical=ical_event)
|
|
except Exception as e:
|
|
_logger.error(f"Failed to sync event to CalDAV server: {e}")
|
|
|
|
def sync_remove_from_caldav(self):
|
|
if not self._is_caldav_enabled():
|
|
return
|
|
client = self._get_caldav_client()
|
|
calendar = client.calendar(url=self.env.user.caldav_calendar_url)
|
|
for event in self:
|
|
if event.caldav_uid:
|
|
try:
|
|
_logger.debug(f"Removing CalDAV event {event.caldav_uid}")
|
|
caldav_event = calendar.object_by_uid(event.caldav_uid)
|
|
caldav_event.delete()
|
|
except caldav.error.NotFoundError:
|
|
_logger.warning(f"CalDAV event {event.caldav_uid} not found on server.")
|
|
except Exception as e:
|
|
_logger.error(f"Failed to remove event from CalDAV server: {e}")
|
|
|
|
def _get_icalendar(self):
|
|
calendar = Calendar()
|
|
calendar.add('prodid', '-//Odoo//mxm.dk//')
|
|
calendar.add('version', '2.0')
|
|
|
|
for event in self:
|
|
ical_event = Event()
|
|
ical_event.add('uid', event.caldav_uid)
|
|
ical_event.add('dtstamp', event.write_date.replace(tzinfo=None))
|
|
if event.name:
|
|
ical_event.add('summary', event.name)
|
|
if event.description:
|
|
ical_event.add('description', event.description)
|
|
if event.location:
|
|
ical_event.add('location', event.location)
|
|
|
|
# Add RRULE if the event is recurrent
|
|
if event.recurrency and event.recurrence_id:
|
|
rrule = event.recurrence_id._get_rrule()
|
|
rrule_dict = _parse_rrule_string(str(rrule))
|
|
ical_event.add('rrule', rrule_dict)
|
|
|
|
# Add DTSTART and DTEND
|
|
ical_event.add('dtstart', event.start.replace(tzinfo=None))
|
|
ical_event.add('dtend', event.stop.replace(tzinfo=None))
|
|
|
|
calendar.add_component(ical_event)
|
|
|
|
return calendar.to_ical()
|
|
|
|
@api.model
|
|
def poll_caldav_server(self):
|
|
all_users = self.env['res.users'].search([]).filtered(lambda u: u.is_caldav_enabled())
|
|
for user in all_users:
|
|
self.with_user(user).poll_user_caldav_server()
|
|
|
|
@api.model
|
|
def poll_user_caldav_server(self):
|
|
if not self._is_caldav_enabled():
|
|
return
|
|
client = self._get_caldav_client()
|
|
calendar = client.calendar(url=self.env.user.caldav_calendar_url)
|
|
events = calendar.events()
|
|
caldav_uids = set()
|
|
now = datetime.now()
|
|
one_year_later = now + timedelta(days=365)
|
|
|
|
_logger.info(f"Polling CalDAV server for user {self.env.user.name}")
|
|
|
|
for caldav_event in events:
|
|
ical_event = caldav_event.icalendar_instance
|
|
self.sync_event_from_ical(ical_event)
|
|
for component in ical_event.subcomponents:
|
|
if isinstance(component, Event):
|
|
uid = str(component.get('uid'))
|
|
rrule = component.get('rrule')
|
|
if rrule:
|
|
dtstart = component.decoded('dtstart')
|
|
if dtstart.tzinfo is not None:
|
|
dtstart = dtstart.replace(tzinfo=None)
|
|
rrule_str = rrule.to_ical().decode('utf-8')
|
|
rrule = rrulestr(rrule_str, dtstart=dtstart)
|
|
instances = list(rrule.between(now, one_year_later))
|
|
for instance_start in instances:
|
|
recurrence_id = instance_start.strftime('%Y%m%dT%H%M%S')
|
|
instance_uid = f"{uid}-{recurrence_id}"
|
|
caldav_uids.add(instance_uid)
|
|
else:
|
|
caldav_uids.add(uid)
|
|
|
|
_logger.info(f"CalDAV UIDs fetched: {caldav_uids}")
|
|
|
|
# Remove Odoo events that no longer exist on the CalDAV server
|
|
odoo_events = self.search([('caldav_uid', '!=', False)])
|
|
for event in odoo_events:
|
|
if event.caldav_recurrence_id:
|
|
if event.caldav_recurrence_id not in caldav_uids:
|
|
_logger.info(f"Deleting orphan event {event.name} with Recurrence ID {event.caldav_recurrence_id}")
|
|
event.with_context(caldav_no_sync=True).unlink()
|
|
elif event.caldav_uid not in caldav_uids:
|
|
_logger.info(f"Deleting orphan event {event.name} with UID {event.caldav_uid}")
|
|
event.with_context(caldav_no_sync=True).unlink()
|
|
|
|
def sync_event_from_ical(self, ical_event):
|
|
email_regex = re.compile(r'[a-z0-9\.\-+_]+@[a-z0-9\.\-+_]+\.[a-z]+')
|
|
now = datetime.now()
|
|
one_year_later = now + timedelta(days=365)
|
|
current_user_email = self.env.user.email.lower()
|
|
|
|
for component in ical_event.subcomponents:
|
|
if isinstance(component, Event):
|
|
uid = str(component.get('uid'))
|
|
rrule = component.get('rrule')
|
|
attendees = component.get('attendee', [])
|
|
|
|
if isinstance(attendees, vCalAddress):
|
|
attendees = [attendees]
|
|
elif isinstance(attendees, str):
|
|
attendees = [vCalAddress(attendees)]
|
|
|
|
attendees_emails = [
|
|
email_regex.search(str(attendee)).group(0).lower().strip()
|
|
for attendee in attendees if email_regex.search(str(attendee))
|
|
]
|
|
|
|
_logger.info(f"Attendees emails: {attendees_emails}")
|
|
|
|
# Add current user email to attendees if not already present
|
|
if current_user_email not in attendees_emails:
|
|
attendees_emails.append(current_user_email)
|
|
|
|
attendee_ids = self.env['res.partner'].search([('email', 'in', attendees_emails)])
|
|
|
|
if rrule:
|
|
dtstart = component.decoded('dtstart')
|
|
dtend = component.decoded('dtend')
|
|
# Convert to naive datetime
|
|
if dtstart.tzinfo:
|
|
dtstart = dtstart.replace(tzinfo=None)
|
|
if dtend.tzinfo:
|
|
dtend = dtend.replace(tzinfo=None)
|
|
rrule_str = rrule.to_ical().decode('utf-8')
|
|
rrule = rrulestr(rrule_str, dtstart=dtstart)
|
|
instances = list(rrule.between(now, one_year_later))
|
|
|
|
for instance_start in instances:
|
|
instance_stop = instance_start + (dtend - dtstart)
|
|
recurrence_id = instance_start.strftime('%Y%m%dT%H%M%S')
|
|
instance_uid = f"{uid}-{recurrence_id}"
|
|
existing_instance = self.search([('caldav_recurrence_id', '=', instance_uid)], limit=1)
|
|
|
|
_logger.info(f"Processing instance UID: {instance_uid}")
|
|
_logger.info(f"Instance start: {instance_start}, stop: {instance_stop}")
|
|
|
|
if not existing_instance:
|
|
_logger.info(f"Creating new recurring event instance with UID {instance_uid}")
|
|
self.with_context({'caldav_no_sync': True}).create({
|
|
'name': str(component.get('summary')),
|
|
'start': instance_start,
|
|
'stop': instance_stop,
|
|
'description': str(component.get('description')),
|
|
'location': str(component.get('location')),
|
|
'caldav_uid': uid,
|
|
'caldav_recurrence_id': instance_uid,
|
|
'partner_ids': [(6, 0, attendee_ids.ids)],
|
|
})
|
|
else:
|
|
_logger.info(f"Updating existing recurring event instance with UID {instance_uid}")
|
|
existing_instance.with_context({'caldav_no_sync': True}).write({
|
|
'name': str(component.get('summary')),
|
|
'start': instance_start,
|
|
'stop': instance_stop,
|
|
'description': str(component.get('description')),
|
|
'location': str(component.get('location')),
|
|
'partner_ids': [(6, 0, attendee_ids.ids)],
|
|
})
|
|
else:
|
|
start = component.decoded('dtstart')
|
|
stop = component.decoded('dtend')
|
|
if isinstance(start, datetime):
|
|
start = start.replace(tzinfo=None)
|
|
if isinstance(stop, datetime):
|
|
stop = stop.replace(tzinfo=None)
|
|
event = self.search([('caldav_uid', '=', uid)], limit=1)
|
|
if not event:
|
|
_logger.info(f"Creating new event {str(component.get('summary'))} with UID {uid}")
|
|
self.with_context({'caldav_no_sync': True}).create({
|
|
'name': str(component.get('summary')),
|
|
'start': start,
|
|
'stop': stop,
|
|
'description': str(component.get('description')),
|
|
'location': str(component.get('location')),
|
|
'caldav_uid': uid,
|
|
'partner_ids': [(6, 0, attendee_ids.ids)],
|
|
})
|
|
else:
|
|
_logger.info(f"Updating existing event {event.name} with UID {uid}")
|
|
|
|
existing_partner_ids = set(event.partner_ids.ids)
|
|
new_partner_ids = set(attendee_ids.ids)
|
|
combined_partner_ids = list(existing_partner_ids.union(new_partner_ids))
|
|
|
|
event.with_context({'caldav_no_sync': True}).write({
|
|
'name': str(component.get('summary')),
|
|
'start': start,
|
|
'stop': stop,
|
|
'description': str(component.get('description')),
|
|
'location': str(component.get('location')),
|
|
'partner_ids': [(6, 0, combined_partner_ids)],
|
|
})
|
|
|
|
@staticmethod
|
|
def _html_to_text(html):
|
|
return BeautifulSoup(html, "html.parser").getText()
|
|
|
|
@staticmethod
|
|
def _map_attendee_status(state):
|
|
mapping = {
|
|
'needsAction': 'NEEDS-ACTION',
|
|
'accepted': 'ACCEPTED',
|
|
'declined': 'DECLINED',
|
|
'tentative': 'TENTATIVE',
|
|
}
|
|
return mapping.get(state, 'NEEDS-ACTION')
|
|
|
|
@staticmethod
|
|
def _map_ical_status(ical_status):
|
|
mapping = {
|
|
'NEEDS-ACTION': 'needsAction',
|
|
'ACCEPTED': 'accepted',
|
|
'DECLINED': 'declined',
|
|
'TENTATIVE': 'tentative',
|
|
}
|
|
return mapping.get(ical_status, 'needsAction')
|