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>')