Lucas Lefèvre
a27afdb543
TL;DR A bit of magic and ... Pouf ... all virtual events are now real records. Purpose ======= The current implementation of recurring events uses "virtual events" to represents all events in the recurrence. Only one event is stored in the database. All other events are dynamically built and sent to the web client which sees them as real records. This implementation is old, difficult to read (6 years of changes and bug fixes) and has become more and more difficult to maintain. A fresh start would be welcome. Specification ============= When creating a recurring event, a `calendar.recurrence.rule` record should be created. This model holds the rrule configuration and is responsible to manage events that result from the rrule. When a new recurrence is created, all resulting events are also created (stored in the database). No more virtual events. To avoid an explosion of events, a maximum of 720 events is created. With 720 events, a daily recurrence lasts for 2 years and a weekly recurrence lasts for 15 years. This strategy is used by Google Calendar and seems acceptable in most cases. A cron job could eventually be introduced to generated more events as the end comes. This allows to introduce an new rrule end type: 'Forever'. This is actually a shortcut to create a recurrence running for 720 events. Inspired by Google Calendar, new possibilities are introduced when modifying a recurring event (e.g. change the name, add an attendee): - Modify only this particular event (the event is still part of the recurrence) - Modify this and following events (events are still in the same recurrence) - Modify all events In a similar way, when updating the rrule of an event (e.g. from every Monday to every Tuesday), the user can choose to: - Modify this and following events: the recurrence is split. The first part remains unchanged but now ends when the second recurrence begins. The second parts is the updated rrule. - Modify only this particular event. - Modify all events: Forbidden (same as Google Calendar) Note: when events are "moved" because the rrule changed, the events are not actually moved. They are unlinked and new events are created (See "Some design choices explained" section). Some design choices explained ============================= Where to store the rrule? ------------------------- Two options were considered. 1) Store the rrule on an event, each event of the recurrence having a Many2one to the parent_id, aka the Master Event of the recurrence. 2) Store the rrule on another model: `calendar.recurrence.rule`. Each event in the recurrence having a Many2one to the recurrence record. Both options have pros & cons. But there is no clear winner. However the actual business logic of handling the recurrence creation/update would be the same. Where the rrule configuration is stored is the only main difference between both options. And this is probably the easiest part of implementing recurring events. With that in mind, option 2) is chosen. It allows to clearly separate recurrence logic from the events themselves. It is also the "correct" way of modeling data to avoid many empty columns for most records. Reusing events on rrule update ------------------------------ When an rrule is modified, events should also be updated. In most cases, current events are unlinked and new events are created from scratch. Only events exactly at the same time before and after the rrule update are kept. Trying to reuse other events would require an obscure and arbitrary heuristic. (Imagine an rrule every Monday that is changed to every Tuesday and every Friday. What would you do?). This implies that any change to a specific event (name change, attendee added, chatter messages) is lost. This tradeoff seems acceptable as updating an rrule should not be that frequent. Moreover, Google Calendar also works that way so why not Odoo? Reusing events on events shifts ------------------------------- On the calendar view, drag and drop an event to shift the entire recurrence. One way to handle the recurrence shift is to apply the same timedelta to all events. Now events are correctly positioned... except for events that were specifically moved. Those outliers needs special handling. This also introduces some behavior inconsistencies: when an rrule is directly modified, events are not reused, but when the rrule is modified by drag & dropping an event, events are reused. This option needs more code to handle the shift and the behaviors are not consistent. The chosen option is to find the rrule configuration from the dragged event (this is easy) and update the recurrence with those new rrule values. This brings us back to an rrule update (see above): code reusability yeah; one behavior to rule them all yeah. One downside is that outliers are lost (but Google Calendar also works that way). Task 2126717 PR #42031 PR Enterprise odoo/enterprise#8006
643 lines
26 KiB
Python
643 lines
26 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo.exceptions import UserError
|
|
import pytz
|
|
from datetime import datetime, date
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from odoo.tests.common import SavepointCase
|
|
|
|
|
|
class TestRecurrentEvents(SavepointCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
lang = cls.env['res.lang']._lang_get(cls.env.user.lang)
|
|
lang.week_start = '1' # Monday
|
|
|
|
def assertEventDates(self, events, dates):
|
|
events = events.sorted('start')
|
|
self.assertEqual(len(events), len(dates), "Wrong number of events in the recurrence")
|
|
self.assertTrue(all(events.mapped('active')), "All events should be active")
|
|
for event, dates in zip(events, dates):
|
|
start, stop = dates
|
|
self.assertEqual(event.start, start)
|
|
self.assertEqual(event.stop, stop)
|
|
|
|
|
|
class TestCreateRecurrentEvents(TestRecurrentEvents):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
cls.event = cls.env['calendar.event'].create({
|
|
'name': 'Recurrent Event',
|
|
'start': datetime(2019, 10, 25, 8, 0),
|
|
'stop': datetime(2019, 10, 27, 18, 0),
|
|
'recurrency': True,
|
|
})
|
|
|
|
def test_weekly_count(self):
|
|
""" Every week, on Tuesdays, for 3 occurences """
|
|
detached_events = self.event._apply_recurrence_values({
|
|
'rrule_type': 'weekly',
|
|
'tu': True,
|
|
'interval': 1,
|
|
'count': 3,
|
|
'event_tz': 'UTC',
|
|
})
|
|
self.assertEqual(detached_events, self.event, "It should be detached from the recurrence")
|
|
self.assertFalse(self.event.recurrence_id, "It should be detached from the recurrence")
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
events = recurrence.calendar_event_ids
|
|
self.assertEqual(len(events), 3, "It should have 3 events in the recurrence")
|
|
self.assertEventDates(events, [
|
|
(datetime(2019, 10, 22, 8, 0), datetime(2019, 10, 24, 18, 0)),
|
|
(datetime(2019, 10, 29, 8, 0), datetime(2019, 10, 31, 18, 0)),
|
|
(datetime(2019, 11, 5, 8, 0), datetime(2019, 11, 7, 18, 0)),
|
|
])
|
|
|
|
def test_weekly_interval_2(self):
|
|
self.event._apply_recurrence_values({
|
|
'interval': 2,
|
|
'rrule_type': 'weekly',
|
|
'tu': True,
|
|
'count': 2,
|
|
'event_tz': 'UTC',
|
|
})
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
events = recurrence.calendar_event_ids
|
|
self.assertEventDates(events, [
|
|
(datetime(2019, 10, 22, 8, 0), datetime(2019, 10, 24, 18, 0)),
|
|
(datetime(2019, 11, 5, 8, 0), datetime(2019, 11, 7, 18, 0)),
|
|
])
|
|
|
|
def test_weekly_until(self):
|
|
self.event._apply_recurrence_values({
|
|
'rrule_type': 'weekly',
|
|
'tu': True,
|
|
'interval': 2,
|
|
'end_type': 'end_date',
|
|
'until': datetime(2019, 11, 15),
|
|
'event_tz': 'UTC',
|
|
})
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
events = recurrence.calendar_event_ids
|
|
self.assertEqual(len(events), 2, "It should have 2 events in the recurrence")
|
|
self.assertEventDates(events, [
|
|
(datetime(2019, 10, 22, 8, 0), datetime(2019, 10, 24, 18, 0)),
|
|
(datetime(2019, 11, 5, 8, 0), datetime(2019, 11, 7, 18, 0)),
|
|
])
|
|
|
|
def test_monthly_count_by_date(self):
|
|
self.event._apply_recurrence_values({
|
|
'rrule_type': 'monthly',
|
|
'interval': 2,
|
|
'month_by': 'date',
|
|
'day': 15,
|
|
'end_type': 'count',
|
|
'count': 3,
|
|
'event_tz': 'UTC',
|
|
})
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
events = recurrence.calendar_event_ids
|
|
self.assertEqual(len(events), 3, "It should have 3 events in the recurrence")
|
|
self.assertEventDates(events, [
|
|
(datetime(2019, 10, 15, 8, 0), datetime(2019, 10, 17, 18, 0)),
|
|
(datetime(2019, 12, 15, 8, 0), datetime(2019, 12, 17, 18, 0)),
|
|
(datetime(2020, 2, 15, 8, 0), datetime(2020, 2, 17, 18, 0)),
|
|
])
|
|
|
|
def test_monthly_count_by_date_31(self):
|
|
self.event._apply_recurrence_values({
|
|
'rrule_type': 'monthly',
|
|
'interval': 1,
|
|
'month_by': 'date',
|
|
'day': 31,
|
|
'end_type': 'count',
|
|
'count': 3,
|
|
'event_tz': 'UTC',
|
|
})
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
events = recurrence.calendar_event_ids
|
|
self.assertEqual(len(events), 3, "It should have 3 events in the recurrence")
|
|
self.assertEventDates(events, [
|
|
(datetime(2019, 10, 31, 8, 0), datetime(2019, 11, 2, 18, 0)),
|
|
# Missing 31th in November
|
|
(datetime(2019, 12, 31, 8, 0), datetime(2020, 1, 2, 18, 0)),
|
|
(datetime(2020, 1, 31, 8, 0), datetime(2020, 2, 2, 18, 0)),
|
|
])
|
|
|
|
def test_monthly_until_by_day(self):
|
|
""" Every 2 months, on the third Tuesday, until 15th March 2020 """
|
|
self.event._apply_recurrence_values({
|
|
'rrule_type': 'monthly',
|
|
'interval': 2,
|
|
'month_by': 'day',
|
|
'byday': '3',
|
|
'weekday': 'TU',
|
|
'end_type': 'end_date',
|
|
'until': date(2020, 3, 15),
|
|
'event_tz': 'UTC',
|
|
})
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
events = recurrence.calendar_event_ids
|
|
self.assertEqual(len(events), 3, "It should have 3 events in the recurrence")
|
|
self.assertEventDates(events, [
|
|
(datetime(2019, 10, 15, 8, 0), datetime(2019, 10, 17, 18, 0)),
|
|
(datetime(2019, 12, 17, 8, 0), datetime(2019, 12, 19, 18, 0)),
|
|
(datetime(2020, 2, 18, 8, 0), datetime(2020, 2, 20, 18, 0)),
|
|
])
|
|
|
|
def test_monthly_until_by_day_last(self):
|
|
""" Every 2 months, on the last Wednesday, until 15th January 2020 """
|
|
self.event._apply_recurrence_values({
|
|
'interval': 2,
|
|
'rrule_type': 'monthly',
|
|
'month_by': 'day',
|
|
'weekday': 'WE',
|
|
'byday': '-1',
|
|
'end_type': 'end_date',
|
|
'until': date(2020, 1, 15),
|
|
'event_tz': 'UTC',
|
|
})
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
events = recurrence.calendar_event_ids
|
|
self.assertEqual(len(events), 2, "It should have 3 events in the recurrence")
|
|
self.assertEventDates(events, [
|
|
(datetime(2019, 10, 30, 8, 0), datetime(2019, 11, 1, 18, 0)),
|
|
(datetime(2019, 12, 25, 8, 0), datetime(2019, 12, 27, 18, 0)),
|
|
])
|
|
|
|
def test_yearly_count(self):
|
|
self.event._apply_recurrence_values({
|
|
'interval': 2,
|
|
'rrule_type': 'yearly',
|
|
'count': 2,
|
|
'event_tz': 'UTC',
|
|
})
|
|
events = self.event.recurrence_id.calendar_event_ids
|
|
self.assertEqual(len(events), 2, "It should have 3 events in the recurrence")
|
|
self.assertEventDates(events, [
|
|
(self.event.start, self.event.stop),
|
|
(self.event.start + relativedelta(years=2), self.event.stop + relativedelta(years=2)),
|
|
])
|
|
|
|
def test_dst_timezone(self):
|
|
""" Test hours stays the same, regardless of DST changes """
|
|
self.event.start = datetime(2002, 10, 26, 10, 0)
|
|
self.event.stop = datetime(2002, 10, 26, 12, 0)
|
|
self.event._apply_recurrence_values({
|
|
'interval': 2,
|
|
'rrule_type': 'weekly',
|
|
'mo': True,
|
|
'count': '2',
|
|
'event_tz': 'US/Eastern', # DST change on 2002/10/27
|
|
})
|
|
recurrence = self.env['calendar.recurrence'].search([('base_event_id', '=', self.event.id)])
|
|
self.assertEventDates(recurrence.calendar_event_ids, [
|
|
(datetime(2002, 10, 21, 10, 0), datetime(2002, 10, 21, 12, 0)),
|
|
(datetime(2002, 11, 4, 11, 0), datetime(2002, 11, 4, 13, 0)),
|
|
])
|
|
|
|
def test_ambiguous_dst_time_winter(self):
|
|
""" Test hours stays the same, regardless of DST changes """
|
|
eastern = pytz.timezone('US/Eastern')
|
|
dt = eastern.localize(datetime(2002, 10, 20, 1, 30, 00)).astimezone(pytz.utc).replace(tzinfo=None)
|
|
# Next occurence happens at 1:30am on 27th Oct 2002 which happened twice in the US/Eastern
|
|
# timezone when the clocks where put back at the end of Daylight Saving Time
|
|
self.event.start = dt
|
|
self.event.stop = dt + relativedelta(hours=1)
|
|
self.event._apply_recurrence_values({
|
|
'interval': 1,
|
|
'rrule_type': 'weekly',
|
|
'su': True,
|
|
'count': '2',
|
|
'event_tz': 'US/Eastern' # DST change on 2002/4/7
|
|
})
|
|
events = self.event.recurrence_id.calendar_event_ids
|
|
self.assertEqual(events.mapped('duration'), [1, 1])
|
|
self.assertEventDates(events, [
|
|
(datetime(2002, 10, 20, 5, 30), datetime(2002, 10, 20, 6, 30)),
|
|
(datetime(2002, 10, 27, 6, 30), datetime(2002, 10, 27, 7, 30)),
|
|
])
|
|
|
|
def test_ambiguous_dst_time_spring(self):
|
|
""" Test hours stays the same, regardless of DST changes """
|
|
eastern = pytz.timezone('US/Eastern')
|
|
dt = eastern.localize(datetime(2002, 3, 31, 2, 30, 00)).astimezone(pytz.utc).replace(tzinfo=None)
|
|
# Next occurence happens 2:30am on 7th April 2002 which never happened at all in the
|
|
# US/Eastern timezone, as the clocks where put forward at 2:00am skipping the entire hour
|
|
self.event.start = dt
|
|
self.event.stop = dt + relativedelta(hours=1)
|
|
self.event._apply_recurrence_values({
|
|
'interval': 1,
|
|
'rrule_type': 'weekly',
|
|
'su': True,
|
|
'count': '2',
|
|
'event_tz': 'US/Eastern' # DST change on 2002/4/7
|
|
})
|
|
events = self.event.recurrence_id.calendar_event_ids
|
|
self.assertEqual(events.mapped('duration'), [1, 1])
|
|
# The event begins at "the same time" (i.e. 2h30 after midnight), but that day, 2h30 after midnight happens to be at 3:30 am
|
|
self.assertEventDates(events, [
|
|
(datetime(2002, 3, 31, 7, 30), datetime(2002, 3, 31, 8, 30)),
|
|
(datetime(2002, 4, 7, 7, 30), datetime(2002, 4, 7, 8, 30)),
|
|
])
|
|
|
|
def test_ambiguous_full_day(self):
|
|
""" Test date stays the same, regardless of DST changes """
|
|
self.event.start = datetime(2020, 3, 23, 0, 0)
|
|
self.event.stop = datetime(2020, 3, 23, 23, 59)
|
|
self.event.allday = True
|
|
self.event._apply_recurrence_values({
|
|
'interval': 1,
|
|
'rrule_type': 'weekly',
|
|
'mo': True,
|
|
'count': 2,
|
|
'event_tz': 'Europe/Brussels' # DST change on 2020/3/23
|
|
})
|
|
events = self.event.recurrence_id.calendar_event_ids
|
|
self.assertEventDates(events, [
|
|
(datetime(2020, 3, 23, 0, 0), datetime(2020, 3, 23, 23, 59)),
|
|
(datetime(2020, 3, 30, 0, 0), datetime(2020, 3, 30, 23, 59)),
|
|
])
|
|
|
|
|
|
class TestUpdateRecurrentEvents(TestRecurrentEvents):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
event = cls.env['calendar.event'].create({
|
|
'name': 'Recurrent Event',
|
|
'start': datetime(2019, 10, 22, 1, 0),
|
|
'stop': datetime(2019, 10, 24, 18, 0),
|
|
'recurrency': True,
|
|
'rrule_type': 'weekly',
|
|
'tu': True,
|
|
'interval': 1,
|
|
'count': 3,
|
|
'event_tz': 'Etc/GMT-4',
|
|
})
|
|
cls.recurrence = event.recurrence_id
|
|
cls.events = event.recurrence_id.calendar_event_ids.sorted('start')
|
|
|
|
def test_shift_future(self):
|
|
event = self.events[1]
|
|
self.events[1].write({
|
|
'recurrence_update': 'future_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
self.assertEqual(self.recurrence.end_type, 'end_date')
|
|
self.assertEqual(self.recurrence.until, date(2019, 10, 27))
|
|
self.assertEventDates(self.recurrence.calendar_event_ids, [
|
|
(datetime(2019, 10, 22, 1, 0), datetime(2019, 10, 24, 18, 0)),
|
|
])
|
|
new_recurrence = event.recurrence_id
|
|
self.assertNotEqual(self.recurrence, new_recurrence)
|
|
self.assertEqual(new_recurrence.count, 2)
|
|
self.assertEqual(new_recurrence.dtstart, datetime(2019, 11, 2, 1, 0))
|
|
self.assertFalse(new_recurrence.tu)
|
|
self.assertTrue(new_recurrence.sa)
|
|
self.assertEventDates(new_recurrence.calendar_event_ids, [
|
|
(datetime(2019, 11, 2, 1, 0), datetime(2019, 11, 5, 18, 0)),
|
|
(datetime(2019, 11, 9, 1, 0), datetime(2019, 11, 12, 18, 0)),
|
|
])
|
|
|
|
def test_shift_future_first(self):
|
|
event = self.events[0]
|
|
self.events[0].write({
|
|
'recurrence_update': 'future_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
new_recurrence = event.recurrence_id
|
|
self.assertFalse(self.recurrence.exists())
|
|
self.assertEqual(new_recurrence.count, 3)
|
|
self.assertEqual(new_recurrence.dtstart, datetime(2019, 10, 26, 1, 0))
|
|
self.assertFalse(new_recurrence.tu)
|
|
self.assertTrue(new_recurrence.sa)
|
|
self.assertEventDates(new_recurrence.calendar_event_ids, [
|
|
(datetime(2019, 10, 26, 1, 0), datetime(2019, 10, 29, 18, 0)),
|
|
(datetime(2019, 11, 2, 1, 0), datetime(2019, 11, 5, 18, 0)),
|
|
(datetime(2019, 11, 9, 1, 0), datetime(2019, 11, 12, 18, 0)),
|
|
])
|
|
|
|
def test_shift_reapply(self):
|
|
event = self.events[2]
|
|
self.events[2].write({
|
|
'recurrence_update': 'future_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
# re-Applying the first recurrence should be idempotent
|
|
self.recurrence._apply_recurrence()
|
|
self.assertEventDates(self.recurrence.calendar_event_ids, [
|
|
(datetime(2019, 10, 22, 1, 0), datetime(2019, 10, 24, 18, 0)),
|
|
(datetime(2019, 10, 29, 1, 0), datetime(2019, 10, 31, 18, 0)),
|
|
])
|
|
|
|
def test_shift_all(self):
|
|
event = self.events[1]
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
|
|
def test_change_week_day_rrule(self):
|
|
recurrence = self.events.recurrence_id
|
|
recurrence.rrule = 'FREQ=WEEKLY;COUNT=3;BYDAY=WE' # from TU to WE
|
|
self.assertFalse(self.recurrence.tu)
|
|
self.assertTrue(self.recurrence.we)
|
|
|
|
def test_shift_all_base_inactive(self):
|
|
self.recurrence.base_event_id.active = False
|
|
event = self.events[1]
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
|
|
def test_shift_all_with_outlier(self):
|
|
outlier = self.events[1]
|
|
outlier.write({
|
|
'recurrence_update': 'self_only',
|
|
'start': datetime(2019, 9, 26, 1, 0), # Thursday
|
|
'stop': datetime(2019, 9, 26, 18, 0),
|
|
})
|
|
event = self.events[0]
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
|
|
def test_update_recurrence_future(self):
|
|
event = self.events[1]
|
|
event.write({
|
|
'recurrence_update': 'future_events',
|
|
'fr': True, # recurrence is now Tuesday AND Friday
|
|
'count': 4,
|
|
})
|
|
self.assertEventDates(self.recurrence.calendar_event_ids, [
|
|
(datetime(2019, 10, 22, 1, 0), datetime(2019, 10, 24, 18, 0)), # Tu
|
|
])
|
|
|
|
self.assertEventDates(event.recurrence_id.calendar_event_ids, [
|
|
(datetime(2019, 10, 29, 1, 0), datetime(2019, 10, 31, 18, 0)), # Tu
|
|
(datetime(2019, 11, 1, 1, 0), datetime(2019, 11, 3, 18, 0)), # Fr
|
|
(datetime(2019, 11, 5, 1, 0), datetime(2019, 11, 7, 18, 0)), # Tu
|
|
(datetime(2019, 11, 8, 1, 0), datetime(2019, 11, 10, 18, 0)), # Fr
|
|
])
|
|
|
|
events = event.recurrence_id.calendar_event_ids.sorted('start')
|
|
self.assertEqual(events[0], self.events[1], "Events on Tuesdays should not have changed")
|
|
self.assertEqual(events[2], self.events[2], "Events on Tuesdays should not have changed")
|
|
self.assertNotEqual(events.recurrence_id, self.recurrence, "Events should no longer be linked to the original recurrence")
|
|
self.assertEqual(events.recurrence_id.count, 4, "The new recurrence should have 4")
|
|
self.assertTrue(event.recurrence_id.tu)
|
|
self.assertTrue(event.recurrence_id.fr)
|
|
|
|
def test_update_recurrence_all(self):
|
|
with self.assertRaises(UserError):
|
|
self.events[1].write({
|
|
'recurrence_update': 'all_events',
|
|
'mo': True, # recurrence is now Tuesday AND Monday
|
|
})
|
|
|
|
def test_shift_single(self):
|
|
event = self.events[1]
|
|
event.write({
|
|
'recurrence_update': 'self_only',
|
|
'name': "Updated event",
|
|
'start': event.start - relativedelta(hours=2)
|
|
})
|
|
self.events[0].write({
|
|
'recurrence_update': 'future_events',
|
|
'start': event.start + relativedelta(hours=4),
|
|
'stop': event.stop + relativedelta(hours=5),
|
|
})
|
|
|
|
def test_break_recurrence_future(self):
|
|
event = self.events[1]
|
|
event.write({
|
|
'recurrence_update': 'future_events',
|
|
'recurrency': False,
|
|
})
|
|
self.assertFalse(event.recurrence_id)
|
|
self.assertTrue(self.events[0].active)
|
|
self.assertTrue(self.events[1].active)
|
|
self.assertFalse(self.events[2].exists())
|
|
self.assertEqual(self.recurrence.until, date(2019, 10, 27))
|
|
self.assertEqual(self.recurrence.end_type, 'end_date')
|
|
self.assertEventDates(self.recurrence.calendar_event_ids, [
|
|
(datetime(2019, 10, 22, 1, 0), datetime(2019, 10, 24, 18, 0)),
|
|
])
|
|
|
|
def test_break_recurrence_all(self):
|
|
event = self.events[1]
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'recurrency': False,
|
|
'count': 0, # In practice, JS framework sends updated recurrency fields, since they have been recomputed, triggered by the `recurrency` change
|
|
})
|
|
self.assertFalse(self.events[0].exists())
|
|
self.assertTrue(event.active)
|
|
self.assertFalse(self.events[2].exists())
|
|
self.assertFalse(event.recurrence_id)
|
|
self.assertFalse(self.recurrence.exists())
|
|
|
|
def test_all_day_shift(self):
|
|
recurrence = self.env['calendar.event'].create({
|
|
'name': 'Recurrent Event',
|
|
'start_date': datetime(2019, 10, 22),
|
|
'stop_date': datetime(2019, 10, 24),
|
|
'recurrency': True,
|
|
'rrule_type': 'weekly',
|
|
'tu': True,
|
|
'interval': 1,
|
|
'count': 3,
|
|
'event_tz': 'Etc/GMT-4',
|
|
'allday': True,
|
|
}).recurrence_id
|
|
events = recurrence.calendar_event_ids.sorted('start')
|
|
event = events[1]
|
|
event.write({
|
|
'recurrence_update': 'future_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
self.assertEqual(recurrence.end_type, 'end_date')
|
|
self.assertEqual(recurrence.until, date(2019, 10, 27))
|
|
self.assertEventDates(recurrence.calendar_event_ids, [
|
|
(datetime(2019, 10, 22, 8, 0), datetime(2019, 10, 24, 18, 0)),
|
|
])
|
|
new_recurrence = event.recurrence_id
|
|
self.assertNotEqual(recurrence, new_recurrence)
|
|
self.assertEqual(new_recurrence.count, 2)
|
|
self.assertEqual(new_recurrence.dtstart, datetime(2019, 11, 2, 8, 0))
|
|
self.assertFalse(new_recurrence.tu)
|
|
self.assertTrue(new_recurrence.sa)
|
|
self.assertEventDates(new_recurrence.calendar_event_ids, [
|
|
(datetime(2019, 11, 2, 8, 0), datetime(2019, 11, 5, 18, 0)),
|
|
(datetime(2019, 11, 9, 8, 0), datetime(2019, 11, 12, 18, 0)),
|
|
])
|
|
|
|
# TODO test followers, and alarms are copied
|
|
|
|
|
|
class TestUpdateMultiDayWeeklyRecurrentEvents(TestRecurrentEvents):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
event = cls.env['calendar.event'].create({
|
|
'name': 'Recurrent Event',
|
|
'start': datetime(2019, 10, 22, 1, 0),
|
|
'stop': datetime(2019, 10, 24, 18, 0),
|
|
'recurrency': True,
|
|
'rrule_type': 'weekly',
|
|
'tu': True,
|
|
'fr': True,
|
|
'interval': 1,
|
|
'count': 3,
|
|
'event_tz': 'Etc/GMT-4',
|
|
})
|
|
cls.recurrence = event.recurrence_id
|
|
cls.events = event.recurrence_id.calendar_event_ids.sorted('start')
|
|
# Tuesday datetime(2019, 10, 22, 1, 0)
|
|
# Friday datetime(2019, 10, 25, 1, 0)
|
|
# Tuesday datetime(2019, 10, 29, 1, 0)
|
|
|
|
def test_shift_all_multiple_weekdays(self):
|
|
event = self.events[0] # Tuesday
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'start': event.start + relativedelta(days=2),
|
|
'stop': event.stop + relativedelta(days=2),
|
|
})
|
|
|
|
def test_shift_all_multiple_weekdays_duration(self):
|
|
event = self.events[0] # Tuesday
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'start': event.start + relativedelta(days=2),
|
|
'stop': event.stop + relativedelta(days=3),
|
|
})
|
|
|
|
def test_shift_future_multiple_weekdays(self):
|
|
event = self.events[1] # Friday
|
|
event.write({
|
|
'recurrence_update': 'future_events',
|
|
'start': event.start + relativedelta(days=3),
|
|
'stop': event.stop + relativedelta(days=3),
|
|
})
|
|
self.assertTrue(self.recurrence.fr)
|
|
self.assertTrue(self.recurrence.tu)
|
|
self.assertTrue(event.recurrence_id.tu)
|
|
self.assertTrue(event.recurrence_id.mo)
|
|
self.assertFalse(event.recurrence_id.fr)
|
|
self.assertEqual(event.recurrence_id.count, 2)
|
|
|
|
|
|
class TestUpdateMonthlyByDay(TestRecurrentEvents):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
event = cls.env['calendar.event'].create({
|
|
'name': 'Recurrent Event',
|
|
'start': datetime(2019, 10, 15, 1, 0),
|
|
'stop': datetime(2019, 10, 16, 18, 0),
|
|
'recurrency': True,
|
|
'rrule_type': 'monthly',
|
|
'interval': 1,
|
|
'count': 3,
|
|
'month_by': 'day',
|
|
'weekday': 'TU',
|
|
'byday': '3',
|
|
'event_tz': 'Etc/GMT-4',
|
|
})
|
|
cls.recurrence = event.recurrence_id
|
|
cls.events = event.recurrence_id.calendar_event_ids.sorted('start')
|
|
# datetime(2019, 10, 15, 1, 0)
|
|
# datetime(2019, 11, 19, 1, 0)
|
|
# datetime(2019, 12, 17, 1, 0)
|
|
|
|
def test_shift_all(self):
|
|
event = self.events[1]
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'start': event.start - relativedelta(days=5),
|
|
'stop': event.stop - relativedelta(days=4),
|
|
})
|
|
|
|
# LUL TODO test shift future
|
|
|
|
class TestUpdateMonthlyByDate(TestRecurrentEvents):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
event = cls.env['calendar.event'].create({
|
|
'name': 'Recurrent Event',
|
|
'start': datetime(2019, 10, 22, 1, 0),
|
|
'stop': datetime(2019, 10, 24, 18, 0),
|
|
'recurrency': True,
|
|
'rrule_type': 'monthly',
|
|
'interval': 1,
|
|
'count': 3,
|
|
'month_by': 'date',
|
|
'day': 22,
|
|
'event_tz': 'Etc/GMT-4',
|
|
})
|
|
cls.recurrence = event.recurrence_id
|
|
cls.events = event.recurrence_id.calendar_event_ids.sorted('start')
|
|
# datetime(2019, 10, 22, 1, 0)
|
|
# datetime(2019, 11, 22, 1, 0)
|
|
# datetime(2019, 12, 22, 1, 0)
|
|
|
|
def test_shift_future(self):
|
|
event = self.events[1]
|
|
event.write({
|
|
'recurrence_update': 'future_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
self.assertEventDates(self.recurrence.calendar_event_ids, [
|
|
(datetime(2019, 10, 22, 1, 0), datetime(2019, 10, 24, 18, 0)),
|
|
])
|
|
self.assertEventDates(event.recurrence_id.calendar_event_ids, [
|
|
(datetime(2019, 11, 26, 1, 0), datetime(2019, 11, 29, 18, 0)),
|
|
(datetime(2019, 12, 26, 1, 0), datetime(2019, 12, 29, 18, 0)),
|
|
])
|
|
|
|
def test_shift_all(self):
|
|
event = self.events[1]
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'start': event.start + relativedelta(days=4),
|
|
'stop': event.stop + relativedelta(days=5),
|
|
})
|
|
|
|
def test_update_all(self):
|
|
event = self.events[1]
|
|
with self.assertRaises(UserError):
|
|
event.write({
|
|
'recurrence_update': 'all_events',
|
|
'day': 25,
|
|
})
|