def instances(self, **kwargs):
event_id = kwargs.pop('eventId')
if event_id == 'event_id_1':
recurring_instances = [
Event(
'Recurring event 1',
start=D.today()[:] + 1 * days,
event_id='event_id_1_' +
(D.today()[:] + (i + 1) * days).isoformat() + 'Z',
_updated=D.today()[:] + 5 * days,
_recurring_event_id='event_id_1',
) for i in range(1, 10)
]
elif event_id == 'event_id_2':
recurring_instances = [
Event(
'Recurring event 2',
start=D.today()[:] + 2 * days,
event_id='event_id_2_' +
(D.today()[:] + (i + 2) * days).isoformat() + 'Z',
_updated=D.today()[:] + 5 * days,
_recurring_event_id='event_id_2',
) for i in range(1, 5)
]
else:
# shouldn't get here in tests
raise ValueError
return {'items': recurring_instances, 'nextPageToken': None}
def test_add_attachment(self):
e = Event('Good day', start=(1 / Aug / 2019), timezone=TEST_TIMEZONE)
e.add_attachment('https://file.url', 'My file',
"application/vnd.google-apps.document")
self.assertIsInstance(e.attachments[0], Attachment)
self.assertEqual(e.attachments[0].title, 'My file')
def test_to_json_attendees(self):
e = Event('Good day',
start=(1 / Jul / 2020)[11:22:33],
timezone=TEST_TIMEZONE,
attendees=[
Attendee(email='*****@*****.**',
response_status=ResponseStatus.NEEDS_ACTION),
Attendee(email='*****@*****.**',
response_status=ResponseStatus.ACCEPTED),
])
event_json = {
'summary':
'Good day',
'start': {
'dateTime': '2020-07-01T11:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2020-07-01T12:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'recurrence': [],
'visibility':
'default',
'attendees': [
{
'email': '*****@*****.**',
'responseStatus': ResponseStatus.NEEDS_ACTION
},
{
'email': '*****@*****.**',
'responseStatus': ResponseStatus.ACCEPTED
},
],
'reminders': {
'useDefault': False
},
'attachments': []
}
self.assertDictEqual(EventSerializer.to_json(e), event_json)
e = Event('Good day2', start=20 / Jul / 2020, default_reminders=True)
event_json = {
'summary': 'Good day2',
'start': {
'date': '2020-07-20'
},
'end': {
'date': '2020-07-21'
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'useDefault': True
},
'attachments': []
}
self.assertDictEqual(EventSerializer.to_json(e), event_json)
def test_init_no_end(self):
start = 1 / Jun / 2019
event = Event('Good day', start, timezone=TEST_TIMEZONE)
self.assertEqual(event.end, start + 1 * days)
start = insure_localisation((1 / Jul / 2019)[12:00], TEST_TIMEZONE)
event = Event('Lunch', start, timezone=TEST_TIMEZONE)
self.assertEqual(event.end, start + 1 * hours)
def test_to_json(self):
e = Event('Good day', start=(28 / Sept / 2019), timezone=TEST_TIMEZONE)
expected_event_json = {
'summary': 'Good day',
'start': {
'date': '2019-09-28'
},
'end': {
'date': '2019-09-29'
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'useDefault': False
},
'attachments': [],
'guestsCanInviteOthers': True,
'guestsCanModify': False,
'guestsCanSeeOtherGuests': True,
}
self.assertDictEqual(EventSerializer.to_json(e), expected_event_json)
e = Event('Good day',
start=(28 / Oct / 2019)[11:22:33],
timezone=TEST_TIMEZONE)
expected_event_json = {
'summary': 'Good day',
'start': {
'dateTime': '2019-10-28T11:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2019-10-28T12:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'useDefault': False
},
'attachments': [],
'guestsCanInviteOthers': True,
'guestsCanModify': False,
'guestsCanSeeOtherGuests': True,
}
self.assertDictEqual(EventSerializer.to_json(e), expected_event_json)
def test_to_json_reminders(self):
e = Event('Good day',
start=(1 / Jan / 2019)[11:22:33],
timezone=TEST_TIMEZONE,
minutes_before_popup_reminder=30,
minutes_before_email_reminder=120)
event_json = {
'summary': 'Good day',
'start': {
'dateTime': '2019-01-01T11:22:33+13:00',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2019-01-01T12:22:33+13:00',
'timeZone': TEST_TIMEZONE
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'overrides': [{
'method': 'popup',
'minutes': 30
}, {
'method': 'email',
'minutes': 120
}],
'useDefault':
False
},
'attachments': []
}
self.assertDictEqual(EventSerializer.to_json(e), event_json)
def test_to_json_attachments(self):
e = Event('Good day',
start=(1 / Jan / 2019)[11:22:33],
timezone=TEST_TIMEZONE,
attachments=[
Attachment('My file1', 'https://file.url1', "application/vnd.google-apps.document"),
Attachment('My file2', 'https://file.url2', "application/vnd.google-apps.document")
])
event_json = {
'summary': 'Good day',
'start': {'dateTime': '2019-01-01T11:22:33+13:00', 'timeZone': TEST_TIMEZONE},
'end': {'dateTime': '2019-01-01T12:22:33+13:00', 'timeZone': TEST_TIMEZONE},
'recurrence': [],
'visibility': 'default',
'reminders': {'useDefault': False},
'attachments': [
{
'title': 'My file1',
'fileUrl': 'https://file.url1',
'mimeType': 'application/vnd.google-apps.document'
},
{
'title': 'My file2',
'fileUrl': 'https://file.url2',
'mimeType': 'application/vnd.google-apps.document'
}
]
}
self.assertDictEqual(EventSerializer.to_json(e), event_json)
def test_to_json_recurrence(self):
e = Event('Good day',
start=(1 / Jan / 2019)[11:22:33],
end=(1 / Jan / 2020)[11:22:33],
timezone=TEST_TIMEZONE,
recurrence=[
Recurrence.rule(freq=DAILY),
Recurrence.exclude_rule(by_week_day=MONDAY),
Recurrence.exclude_dates([
19 / Apr / 2019,
22 / Apr / 2019,
12 / May / 2019
])
])
event_json = {
'summary': 'Good day',
'start': {'dateTime': '2019-01-01T11:22:33+13:00', 'timeZone': TEST_TIMEZONE},
'end': {'dateTime': '2020-01-01T11:22:33+13:00', 'timeZone': TEST_TIMEZONE},
'recurrence': [
'RRULE:FREQ=DAILY;WKST=SU',
'EXRULE:FREQ=DAILY;BYDAY=MO;WKST=SU',
'EXDATE;VALUE=DATE:20190419,20190422,20190512'
],
'visibility': 'default',
'reminders': {'useDefault': False},
'attachments': []
}
self.assertDictEqual(EventSerializer.to_json(e), event_json)
def addEvent(self, user='******'):
[start, end] = self.getTimes()
event = Event(user, start=start, end=end)
self.calendar.add_event(event) # add the event
print('Event created for ' + user + ' from ' +
start.strftime('%A, %H:%M') + ' to ' +
end.strftime('%A, %H:%M') + '!') # tell me when i can go
def test_to_json_updated(self):
e = Event('Good day',
start=(1 / Jul / 2020)[11:22:33],
timezone=TEST_TIMEZONE,
_updated=insure_localisation((25 / Nov / 2020)[11:22:33],
timezone=TEST_TIMEZONE))
expected_event_json = {
'summary': 'Good day',
'start': {
'dateTime': '2020-07-01T11:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2020-07-01T12:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'useDefault': False
},
'attachments': [],
'guestsCanInviteOthers': True,
'guestsCanModify': False,
'guestsCanSeeOtherGuests': True,
}
self.assertDictEqual(EventSerializer.to_json(e), expected_event_json)
def test_init(self):
event = Event('Breakfast',
event_id='123',
start=(1 / Feb / 2019)[9:00],
end=(31 / Dec / 2019)[23:59],
timezone=TEST_TIMEZONE,
description='Everyday breakfast',
location='Home',
recurrence=[
Recurrence.rule(freq=DAILY),
Recurrence.exclude_rule(by_week_day=[SU, SA]),
Recurrence.exclude_dates([
19 / Apr / 2019, 22 / Apr / 2019, 12 / May / 2019
])
],
visibility=Visibility.PRIVATE,
minutes_before_popup_reminder=15)
self.assertEqual(event.summary, 'Breakfast')
self.assertEqual(event.id, '123')
self.assertEqual(
event.start,
insure_localisation((1 / Feb / 2019)[9:00], TEST_TIMEZONE))
self.assertEqual(event.description, 'Everyday breakfast')
self.assertEqual(event.location, 'Home')
self.assertEqual(len(event.recurrence), 3)
self.assertEqual(event.visibility, Visibility.PRIVATE)
self.assertIsInstance(event.reminders[0], PopupReminder)
self.assertEqual(event.reminders[0].minutes_before_start, 15)
def _to_object(json_event):
start = None
timezone = None
start_data = json_event.pop('start', None)
if start_data is not None:
if 'date' in start_data:
start = EventSerializer._get_datetime_from_string(
start_data['date']).date()
else:
start = EventSerializer._get_datetime_from_string(
start_data['dateTime'])
timezone = start_data.get('timeZone', str(get_localzone()))
end = None
end_data = json_event.pop('end', None)
if end_data is not None:
if 'date' in end_data:
end = EventSerializer._get_datetime_from_string(
end_data['date']).date()
else:
end = EventSerializer._get_datetime_from_string(
end_data['dateTime'])
attendees_json = json_event.pop('attendees', [])
attendees = [AttendeeSerializer.to_object(a) for a in attendees_json]
gadget_json = json_event.pop('gadget', None)
gadget = GadgetSerializer.to_object(
gadget_json) if gadget_json else None
reminders_json = json_event.pop('reminders', {})
reminders = [
ReminderSerializer.to_object(r)
for r in reminders_json.get('overrides', [])
]
attachments_json = json_event.pop('attachments', [])
attachments = [
AttachmentSerializer.to_object(a) for a in attachments_json
]
return Event(json_event.pop('summary'),
start=start,
end=end,
timezone=timezone,
event_id=json_event.pop('id', None),
description=json_event.pop('description', None),
location=json_event.pop('location', None),
recurrence=json_event.pop('recurrence', None),
color=json_event.pop('colorId', None),
visibility=json_event.pop('visibility', None),
attendees=attendees,
gadget=gadget,
attachments=attachments,
reminders=reminders,
default_reminders=reminders_json.pop('useDefault', False),
**json_event)
def test_to_json_conference_solution(self):
e = Event('Good day',
start=(1 / Jul / 2020)[11:22:33],
timezone=TEST_TIMEZONE,
conference_solution=ConferenceSolution(
entry_points=EntryPoint(EntryPoint.VIDEO,
uri='https://video.com'),
solution_type=SolutionType.HANGOUTS_MEET,
name='Hangout',
icon_uri='https://icon.com',
conference_id='aaa-bbbb-ccc',
signature='abc4efg12345',
notes='important notes'))
expected_event_json = {
'summary': 'Good day',
'start': {
'dateTime': '2020-07-01T11:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2020-07-01T12:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'useDefault': False
},
'attachments': [],
'conferenceData': {
'entryPoints': [{
'entryPointType': 'video',
'uri': 'https://video.com',
}],
'conferenceSolution': {
'key': {
'type': 'hangoutsMeet'
},
'name': 'Hangout',
'iconUri': 'https://icon.com'
},
'conferenceId':
'aaa-bbbb-ccc',
'signature':
'abc4efg12345',
'notes':
'important notes'
},
'guestsCanInviteOthers': True,
'guestsCanModify': False,
'guestsCanSeeOtherGuests': True,
}
self.assertDictEqual(EventSerializer.to_json(e), expected_event_json)
def test_get_recurring_instances(self):
events = list(self.gc.get_instances(recurring_event='event_id_1'))
self.assertEqual(len(events), 9)
self.assertTrue(all(e.id.startswith('event_id_1') for e in events))
recurring_event = Event('recurring event',
D.today()[:],
event_id='event_id_2')
events = list(self.gc.get_instances(recurring_event=recurring_event))
self.assertEqual(len(events), 4)
self.assertTrue(all(e.id.startswith('event_id_2') for e in events))
def test_ordering(self):
e1 = Event('Good day',
start=(28 / Sept / 2020),
end=(30 / Sept / 2020),
timezone=TEST_TIMEZONE)
e2 = Event('Good day',
start=(28 / Sept / 2020),
end=(16 / Oct / 2020),
timezone=TEST_TIMEZONE)
e3 = Event('Good day',
start=(29 / Sept / 2020),
end=(30 / Sept / 2020),
timezone=TEST_TIMEZONE)
e4 = Event('Good day',
start=(29 / Sept / 2020)[22:22],
end=(30 / Sept / 2020)[15:15],
timezone=TEST_TIMEZONE)
e5 = Event('Good day',
start=(29 / Sept / 2020)[22:22],
end=(30 / Sept / 2020)[18:15],
timezone=TEST_TIMEZONE)
e6 = Event('Good day',
start=(29 / Sept / 2020)[23:22],
end=(30 / Sept / 2020)[18:15],
timezone=TEST_TIMEZONE)
self.assertEqual(list(sorted([e5, e6, e1, e3, e2, e4])),
[e1, e2, e3, e4, e5, e6])
self.assertTrue(e1 < e2)
self.assertTrue(e3 > e2)
self.assertTrue(e5 >= e2)
self.assertTrue(e2 >= e2)
self.assertTrue(e5 <= e5)
self.assertTrue(e5 <= e6)
def test_init(self):
event = Event('Breakfast',
event_id='123',
start=(1 / Feb / 2019)[9:00],
end=(31 / Dec / 2019)[23:59],
_created=insure_localisation((20 / Nov / 2020)[16:19],
TEST_TIMEZONE),
_updated=insure_localisation((25 / Nov / 2020)[16:19],
TEST_TIMEZONE),
timezone=TEST_TIMEZONE,
description='Everyday breakfast',
location='Home',
guests_can_invite_others=False,
guests_can_modify=True,
guests_can_see_other_guests=False,
recurrence=[
Recurrence.rule(freq=DAILY),
Recurrence.exclude_rule(by_week_day=[SU, SA]),
Recurrence.exclude_dates([
19 / Apr / 2019, 22 / Apr / 2019, 12 / May / 2019
])
],
visibility=Visibility.PRIVATE,
minutes_before_popup_reminder=15)
self.assertEqual(event.summary, 'Breakfast')
self.assertEqual(event.id, '123')
self.assertEqual(
event.start,
insure_localisation((1 / Feb / 2019)[9:00], TEST_TIMEZONE))
self.assertEqual(
event.end,
insure_localisation((31 / Dec / 2019)[23:59], TEST_TIMEZONE))
self.assertEqual(
event.created,
insure_localisation((20 / Nov / 2020)[16:19], TEST_TIMEZONE))
self.assertEqual(
event.updated,
insure_localisation((25 / Nov / 2020)[16:19], TEST_TIMEZONE))
self.assertEqual(event.description, 'Everyday breakfast')
self.assertEqual(event.location, 'Home')
self.assertEqual(len(event.recurrence), 3)
self.assertEqual(event.visibility, Visibility.PRIVATE)
self.assertIsInstance(event.reminders[0], PopupReminder)
self.assertEqual(event.reminders[0].minutes_before_start, 15)
self.assertFalse(event.guests_can_invite_others)
self.assertTrue(event.guests_can_modify)
self.assertFalse(event.guests_can_see_other_guests)
def sync_events(calendars, page):
event = event_from_page(page)
page_in_redis = redis_page_get(page.id)
info_the_same = event.start == page_in_redis['start'] and event.end == page_in_redis['end'] and event.summary == page_in_redis['summary']
past_assignees = [a['email'] for a in page_in_redis["added"]]
current_assignees = [user.email for user in page.assign if user.email in calendars]
if info_the_same and past_assignees == current_assignees:
yield { "action": "no_changes", "emails": current_assignees }
return
all_assignees = set(past_assignees + current_assignees)
next_added = []
for email in all_assignees:
if not email in calendars:
yield { "action": "skip_no_email", "email": email }
if not email in current_assignees:
for added in page_in_redis["added"]:
if added['email'] == email:
yield { "action": "delete_event", "email": email }
try:
calendars[email].delete_event(Event(summary = event.summary, start = event.start, event_id = added['event_id']))
except Exception as e:
print(e)
elif not email in past_assignees:
next_added += [add_event(calendars, event, email)]
yield { "action": "add_to_calendar", "email": email }
else:
for added in page_in_redis["added"]:
if added['email'] == email:
next_added += [added]
if not info_the_same:
event_with_id = event_from_page(page, event_id = added['event_id'])
yield { "action": "update_event", "email": email }
try:
calendars[email].update_event(event_with_id)
except Exception as e:
print(e)
else:
yield { "action": "no_change", "email": email }
redis_set_notion_page(page, next_added)
def test_to_json_conference_solution_create_request(self):
e = Event('Good day',
start=(1 / Jul / 2020)[11:22:33],
timezone=TEST_TIMEZONE,
conference_solution=ConferenceSolutionCreateRequest(
solution_type=SolutionType.HANGOUTS_MEET,
request_id='hello1234',
conference_id='conference-id',
signature='signature',
notes='important notes',
_status='pending'))
expected_event_json = {
'summary': 'Good day',
'start': {
'dateTime': '2020-07-01T11:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2020-07-01T12:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'useDefault': False
},
'attachments': [],
'conferenceData': {
'createRequest': {
'requestId': 'hello1234',
'conferenceSolutionKey': {
'type': 'hangoutsMeet'
},
'status': {
'statusCode': 'pending'
}
},
'conferenceId': 'conference-id',
'signature': 'signature',
'notes': 'important notes'
},
'guestsCanInviteOthers': True,
'guestsCanModify': False,
'guestsCanSeeOtherGuests': True,
}
self.assertDictEqual(EventSerializer.to_json(e), expected_event_json)
def flush_events_and_creds():
calendars = get_calendars()
notion_page_ids = redis_keys('notion-page')
for page_id in notion_page_ids:
page_in_redis = redis_page_get(page_id)
for added in page_in_redis["added"]:
email = added['email']
try:
calendars[email].delete_event(Event(summary = page_in_redis['summary'], start = page_in_redis['start'], event_id = added['event_id']))
except Exception as e:
print(e)
redis_client.delete(f'notion-page:{page_id}')
for email in redis_keys('creds'):
redis_client.delete(f'creds:{email}')
def test_add_reminders(self):
e = Event('Good day', start=(28 / Mar / 2019), timezone=TEST_TIMEZONE)
self.assertEqual(len(e.reminders), 0)
e.add_email_reminder(35)
self.assertEqual(len(e.reminders), 1)
self.assertIsInstance(e.reminders[0], EmailReminder)
self.assertEqual(e.reminders[0].minutes_before_start, 35)
e.add_popup_reminder(41)
self.assertEqual(len(e.reminders), 2)
self.assertIsInstance(e.reminders[1], PopupReminder)
self.assertEqual(e.reminders[1].minutes_before_start, 41)
def test_reminders_checks(self):
with self.assertRaises(ValueError):
Event('Too many reminders',
start=20 / Jul / 2020,
reminders=[EmailReminder()] * 6)
with self.assertRaises(ValueError):
Event('Default and overrides together',
start=20 / Jul / 2020,
reminders=EmailReminder(),
default_reminders=True)
e = Event('Almost too many reminders',
start=20 / Jul / 2020,
reminders=[EmailReminder()] * 5)
with self.assertRaises(ValueError):
e.add_email_reminder()
def create(
cls,
event_id: Optional[str] = None,
summary: Optional[str] = None,
start: Union[datetime, date, None] = None,
description: Optional[str] = None,
location: Optional[str] = None,
) -> Optional[Event]:
summary = summary if summary else DEFAULT_SUMMARY
if type(start) is not datetime and type(start) is not date:
start = create_default_start()
# by default, the Google calendar itself creates value from "event_id"
# in order to set its own value for "event_id", you need to use the "id"
new_event = Event(
id=event_id,
summary=summary,
start=start,
description=description,
location=location,
)
calendar.add_event(new_event)
event = cls.query_by_google_calendar_event_id(event_id=event_id)
return event
def test_add_attendees(self):
e = Event('Good day',
start=(17 / Jul / 2020),
timezone=TEST_TIMEZONE,
attendees=[
Attendee(email="*****@*****.**"),
"*****@*****.**",
])
self.assertEqual(len(e.attendees), 2)
e.add_attendee(Attendee("*****@*****.**"))
e.add_attendee(Attendee(email="*****@*****.**"))
self.assertEqual(len(e.attendees), 4)
self.assertEqual(e.attendees[0].email, "*****@*****.**")
self.assertEqual(e.attendees[1].email, "*****@*****.**")
self.assertEqual(e.attendees[2].email, "*****@*****.**")
self.assertEqual(e.attendees[3].email, "*****@*****.**")
def list(self, **kwargs):
"""Emulates GoogleCalendar.service.events().list().execute()"""
time_min = dateutil.parser.parse(kwargs['timeMin'])
time_max = dateutil.parser.parse(kwargs['timeMax'])
order_by = kwargs['orderBy']
single_events = kwargs['singleEvents']
page_token = kwargs['pageToken'] or 0 # page number in this case
q = kwargs['q']
test_events = [
Event('test{}'.format(i),
start=insure_localisation(D.today()[:] + i * days +
i * hours),
event_id='1',
_updated=insure_localisation(D.today()[:] + (i + 1) * days +
i * hours),
attendees=[
Attendee(email='{}@gmail.com'.format(
attendee_name.lower()),
display_name=attendee_name)
] if attendee_name else None)
for i, attendee_name in zip(range(1, 10), ['John', 'Josh'] +
[''] * 8)
]
recurring_event = Event(
'Recurring event',
start=insure_localisation(D.today()[:] + 2 * days),
event_id='recurring_id',
_updated=insure_localisation(D.today()[:] + 3 * days))
recurring_instances = [
Event(
recurring_event.summary,
start=recurring_event.start + i * days,
event_id=recurring_event.id + '_' +
(recurring_event.start + i * days).isoformat() + 'Z',
_updated=recurring_event.updated,
_recurring_event_id=recurring_event.id,
) for i in range(10)
]
if single_events:
test_events.extend(recurring_instances)
else:
test_events.append(recurring_event)
event_in_a_year = Event(
'test42',
start=insure_localisation(D.today()[:] + 1 * years + 2 * days),
event_id='42',
_updated=insure_localisation(D.today()[:] + 1 * years + 3 * days),
attendees=[
Attendee(email='*****@*****.**', display_name='Frank')
])
test_events.append(event_in_a_year)
def _filter(e):
return ((time_min <= e.start and e.end < time_max)
and (not q or q in e.summary or
(e.description and q in e.description) or
(e.attendees and any(
(a.display_name and q in a.display_name)
for a in e.attendees))))
def _sort_key(e):
if order_by is None:
return e.id
if order_by == 'startTime':
return e.start
if order_by == 'updated':
return e.updated
filtered_events = list(filter(_filter, test_events))
ordered_events = sorted(filtered_events, key=_sort_key)
serialized_events = list(map(self._serialize_event, ordered_events))
current_page_events = ordered_events[page_token *
self.EVENTS_PER_PAGE:(page_token +
1) *
self.EVENTS_PER_PAGE]
return {
'items':
current_page_events,
'nextPageToken':
page_token + 1 if
(page_token + 1) * 3 < len(serialized_events) else None
}
def test_init_different_date_types(self):
with self.assertRaises(TypeError):
Event('Good day',
start=(1 / Jan / 2019),
end=(2 / Jan / 2019)[5:55],
timezone=TEST_TIMEZONE)
def _to_object(json_event):
timezone = None
start = None
start_data = json_event.pop('start', None)
if start_data is not None:
if 'date' in start_data:
start = EventSerializer._get_datetime_from_string(
start_data['date']).date()
else:
start = EventSerializer._get_datetime_from_string(
start_data['dateTime'])
timezone = start_data.get('timeZone', str(get_localzone()))
end = None
end_data = json_event.pop('end', None)
if end_data is not None:
if 'date' in end_data:
end = EventSerializer._get_datetime_from_string(
end_data['date']).date()
else:
end = EventSerializer._get_datetime_from_string(
end_data['dateTime'])
updated = json_event.pop('updated', None)
if updated:
updated = EventSerializer._get_datetime_from_string(updated)
created = json_event.pop('created', None)
if created:
created = EventSerializer._get_datetime_from_string(created)
attendees_json = json_event.pop('attendees', [])
attendees = [AttendeeSerializer.to_object(a) for a in attendees_json]
reminders_json = json_event.pop('reminders', {})
reminders = [
ReminderSerializer.to_object(r)
for r in reminders_json.get('overrides', [])
]
attachments_json = json_event.pop('attachments', [])
attachments = [
AttachmentSerializer.to_object(a) for a in attachments_json
]
conference_data = json_event.pop('conferenceData', None)
if conference_data is not None:
create_request = conference_data.get('createRequest', {})
if create_request is None or create_request.get('status', {}).get(
'statusCode', None) in (None, 'success'):
conference_solution = ConferenceSolutionSerializer.to_object(
conference_data)
else:
conference_solution = ConferenceSolutionCreateRequestSerializer.to_object(
conference_data)
else:
conference_solution = None
return Event(
json_event.pop('summary'),
start=start,
end=end,
timezone=timezone,
event_id=json_event.pop('id', None),
description=json_event.pop('description', None),
location=json_event.pop('location', None),
recurrence=json_event.pop('recurrence', None),
color=json_event.pop('colorId', None),
visibility=json_event.pop('visibility', None),
attendees=attendees,
attachments=attachments,
reminders=reminders,
conference_solution=conference_solution,
default_reminders=reminders_json.pop('useDefault', False),
guests_can_invite_others=json_event.pop('guestsCanInviteOthers',
True),
guests_can_modify=json_event.pop('guestsCanModify', False),
guests_can_see_other_guests=json_event.pop(
'guestsCanSeeOtherGuests', True),
_created=created,
_updated=updated,
_recurring_event_id=json_event.pop('recurringEventId', None),
**json_event)
def event_from_page(page, event_id = None):
return Event(summary = page.title, description = notion_url(page.id), start = page.due.start, end = page.due.end, event_id = event_id)
# append to list
if str(next_assignment_date) >= term_start_date:
course_name.append(next_item["name"])
assignment_due_date.append(next_assignment_date)
course_ids.append(next_item["course_id"])
# print(course_name)
# print(assignment_due_date)
# google calendar credentials
user_email = "*****@*****.**"
google_cred = os.getenv("GOOGLE_CALENDAR_CRED")
gc = GoogleCalendar(credentials_path=google_cred)
calendar = GoogleCalendar(user_email)
# for loop all lists - and extract matching key values from course_ids
for name, due_date, course_id in zip(course_name, assignment_due_date,
course_ids):
for key, value in course_dict.items():
if course_id == int(key):
# print(due_date.split("-")[0])
# print(due_date.split("-")[1])
# print(due_date.split("-")[2])
final_name = name + " " + value
start = datetime.datetime(int(due_date.split("-")[0]),
int(due_date.split("-")[1]),
int(due_date.split("-")[2]))
event = Event(final_name,
start=start,
minutes_before_pop_reminder=30)
calendar.add_event(event)
# print(event)
def test_equal(self):
dp = {'summary': 'Breakfast', 'start': (1 / Feb / 2019)[9:00]}
gadget_dp = {
"type_": Gadget.ICON,
"link": 'https://gadget.com',
"icon_link": 'https://icon.com'
}
attachments_dp = {
"file_url": 'https://file.com',
"mime_type": "application/vnd.google-apps.map"
}
event1 = Event(**dp,
event_id='123',
end=(31 / Dec / 2019)[23:59],
timezone=TEST_TIMEZONE,
description='Everyday breakfast',
location='Home',
recurrence=Recurrence.rule(freq=DAILY),
color='#254433',
visibility=Visibility.PRIVATE,
attendees='*****@*****.**',
gadget=Gadget('Gadget', **gadget_dp),
attachments=Attachment('My doc', **attachments_dp),
minutes_before_popup_reminder=15,
other={"key": "value"})
self.assertEqual(event1, event1)
self.assertNotEqual(Event(**dp),
Event('Breakfast', start=(22 / Jun / 2020)[22:22]))
self.assertNotEqual(Event(**dp, event_id='123'),
Event(**dp, event_id='abc'))
self.assertNotEqual(Event(**dp, description='Desc1'),
Event(**dp, description='Desc2'))
self.assertNotEqual(Event(**dp, location='Home'),
Event(**dp, location='Work'))
self.assertNotEqual(
Event(**dp, recurrence=Recurrence.rule(freq=DAILY)),
Event(**dp, recurrence=Recurrence.rule(freq=WEEKLY)))
self.assertNotEqual(Event(**dp, color='#254433'),
Event(**dp, color='#ffffff'))
self.assertNotEqual(Event(**dp, visibility=Visibility.PRIVATE),
Event(**dp, visibility=Visibility.PUBLIC))
self.assertNotEqual(Event(**dp, attendees='*****@*****.**'),
Event(**dp, attendees='*****@*****.**'))
self.assertNotEqual(Event(**dp, gadget=Gadget('Gadget1', **gadget_dp)),
Event(**dp, gadget=Gadget('Gadget2', **gadget_dp)))
self.assertNotEqual(
Event(**dp,
attachments=Attachment('Attachment1', **attachments_dp)),
Event(**dp,
attachments=Attachment('Attachment2', **attachments_dp)))
self.assertNotEqual(Event(**dp, minutes_before_email_reminder=10),
Event(**dp, minutes_before_popup_reminder=10))
self.assertNotEqual(Event(**dp, other={"key1": "value1"}),
Event(**dp, other={"key2": "value2"}))
def test_str_repr(self):
e = Event('Good event', start=20 / Jul / 2020)
self.assertEqual(str(e), '2020-07-20 - Good event')
self.assertEqual(repr(e), '<Event 2020-07-20 - Good event>')
