1
from datetime import datetime
2
from typing import *
3

4
from ghunt.helpers.utils import get_datetime_utc
5
from ghunt.objects.apis import Parser
6

7

8
class ConferenceProperties(Parser):
9
    def __init__(self):
10
        self.allowed_conference_solution_types: List[str] = []
11

12
    def _scrape(self, conference_props_data: Dict[str, any]):
13
        if (types := conference_props_data.get("allowedConferenceSolutionTypes")):
14
            self.allowed_conference_solution_types = types
15

16
class Calendar(Parser):
17
    def __init__(self):
18
        self.id: str = ""
19
        self.summary: str = ""
20
        self.time_zone: str = ""
21
        self.conference_properties: ConferenceProperties = ConferenceProperties()
22

23
    def _scrape(self, calendar_data: Dict[str, any]):
24
        self.id = calendar_data.get("id")
25
        self.summary = calendar_data.get("summary")
26
        self.time_zone = calendar_data.get("timeZone")
27
        conference_props_data = calendar_data.get("conferenceProperties")
28
        if conference_props_data:
29
            self.conference_properties._scrape(conference_props_data)
30

31
class CalendarReminder(Parser):
32
    def __init__(self):
33
        self.method: str = ""
34
        self.minutes: int = 0
35

36
    def _scrape(self, reminder_data: Dict[str, any]):
37
        self.method = reminder_data.get("method")
38
        self.minutes = reminder_data.get("minutes")
39

40
class CalendarPerson(Parser):
41
    def __init__(self):
42
        self.email: str = ""
43
        self.display_name: str = ""
44
        self.self: bool = None
45

46
    def _scrape(self, person_data: Dict[str, any]):
47
        self.email = person_data.get("email")
48
        self.display_name = person_data.get("displayName")
49
        self.self = person_data.get("self")
50

51
class CalendarTime(Parser):
52
    def __init__(self):
53
        self.date_time: datetime = None # ISO Format
54
        self.time_zone: str = ""
55

56
    def _scrape(self, time_data: Dict[str, any]):
57
        if (date_time := time_data.get("dateTime")):
58
            try:
59
                self.date_time = get_datetime_utc(date_time)
60
            except ValueError:
61
                self.date_time = None
62
        self.time_zone = time_data.get("timeZone")
63

64
class CalendarReminders(Parser):
65
    def __init__(self):
66
        self.use_default: int = 0
67
        self.overrides: List[CalendarReminder] = []
68

69
    def _scrape(self, reminders_data: Dict[str, any]):
70
        self.use_default = reminders_data.get("useDefault")
71
        if (overrides := reminders_data.get("overrides")):
72
            for reminder_data in overrides:
73
                reminder = CalendarReminder()
74
                reminder._scrape(reminder_data)
75
                self.overrides.append(reminder)
76

77
class CalendarEvent(Parser):
78
    def __init__(self):
79
        self.id: str = ""
80
        self.status: str = ""
81
        self.html_link: str = ""
82
        self.created: datetime = "" # ISO Format
83
        self.updated: datetime = "" # ISO Format
84
        self.summary: str = ""
85
        self.description: str = ""
86
        self.location: str = ""
87
        self.creator: CalendarPerson = CalendarPerson()
88
        self.organizer: CalendarPerson = CalendarPerson()
89
        self.start: CalendarTime = CalendarTime()
90
        self.end: CalendarTime = CalendarTime()
91
        self.recurring_event_id: str = ""
92
        self.original_start_time: CalendarTime = CalendarTime()
93
        self.visibility: str = ""
94
        self.ical_uid: str = ""
95
        self.sequence: int = 0
96
        self.guest_can_invite_others: bool = None
97
        self.reminders: CalendarReminders = CalendarReminders()
98
        self.event_type: str = ""
99

100
    def _scrape(self, event_data: Dict[str, any]):
101
        self.id = event_data.get("id")
102
        self.status = event_data.get("status")
103
        self.html_link = event_data.get("htmlLink")
104
        if (date_time := event_data.get("created")):
105
            try:
106
                self.created = get_datetime_utc(date_time)
107
            except ValueError:
108
                self.created = None
109
        if (date_time := event_data.get("updated")):
110
            try:
111
                self.updated = get_datetime_utc(date_time)
112
            except ValueError:
113
                self.updated = None
114
        self.summary = event_data.get("summary")
115
        self.description = event_data.get("description")
116
        self.location = event_data.get("location")
117
        if (creator_data := event_data.get("creator")):
118
            self.creator._scrape(creator_data)
119
        if (organizer_data := event_data.get("organizer")):
120
            self.organizer._scrape(organizer_data)
121
        if (start_data := event_data.get("start")):
122
            self.start._scrape(start_data)
123
        if (end_data := event_data.get("end")):
124
            self.end._scrape(end_data)
125
        self.recurring_event_id = event_data.get("recurringEventId")
126
        if (original_start_data := event_data.get("originalStartTime")):
127
            self.original_start_time._scrape(original_start_data)
128
        self.visibility = event_data.get("visibility")
129
        self.ical_uid = event_data.get("iCalUID")
130
        self.sequence = event_data.get("sequence")
131
        self.guest_can_invite_others = event_data.get("guestsCanInviteOthers")
132
        if (reminders_data := event_data.get("reminders")):
133
            self.reminders._scrape(reminders_data)
134
        self.event_type = event_data.get("eventType")
135

136
class CalendarEvents(Parser):
137
    def __init__(self):
138
        self.summary: str = ""
139
        self.updated: datetime = "" # ISO Format
140
        self.time_zone: str = ""
141
        self.access_role: str = ""
142
        self.default_reminders: List[CalendarReminder] = []
143
        self.next_page_token: str = ""
144
        self.items: List[CalendarEvent] = []
145

146
    def _scrape(self, events_data: Dict[str, any]):
147
        self.summary = events_data.get("summary")
148
        if (date_time := events_data.get("updated")):
149
            try:
150
                self.updated = get_datetime_utc(date_time)
151
            except ValueError:
152
                self.updated = None
153
        self.time_zone = events_data.get("timeZone")
154
        self.access_role = events_data.get("accessRole")
155
        if (reminders_data := events_data.get("defaultReminders")):
156
            for reminder_data in reminders_data:
157
                reminder = CalendarReminder()
158
                reminder._scrape(reminder_data)
159
                self.default_reminders.append(reminder)
160
        self.next_page_token = events_data.get("nextPageToken")
161
        if (items_data := events_data.get("items")):
162
            for item_data in items_data:
163
                event = CalendarEvent()
164
                event._scrape(item_data)
165
                self.items.append(event)
166