class Credentials:
def __init__(self, app_token):
self.base = 'credentials'
self.api_client = ApiClient(app_token)
def widget(self):
return self.api_client.call_api('get', url=self.base)
def resource(self, resource_id):
url = self.base + '?search=resource_id:' + str(resource_id)
return self.api_client.call_api('get', url)
def log_out(access_token: str) -> bool:
"""
Revoke your access_token
:param access_token: <str>
:return:
"""
resource_path = '/oauth/access_token'
api_client = ApiClient(access_token=access_token)
api_client.call_api(resource_path=resource_path, method='DELETE')
confirm(f"Successfully logged out.")
return True
class Availability:
def __init__(self, app_token):
self.base = 'findtime'
self.api_client = ApiClient(app_token)
def query(self, resource_ids, **kwargs):
"""
Required
Note: only resource_ids or calendar_ids are required
:param resource_ids: array, resource-uuids
:param: calendar_ids: array of strings, use this for only specific calendars
Optional:
:param length: string, how much time must each avaliable timeslot contain
:param filters: array (mixed types, see filters)
:param start: string, human written time eg, 1 day, tomorrow, 2 weeks
:param future: string, defines the end of the search-space
:param sort: string, chronologica order of results, accepted values: asc, desc
:param ignore_all_day_events: boolean, ignore all day events in this query?
:param all_solutions: boolean, return overlapping timeslots?
:param emails: array of strings, check emails for mutual availability
:param buffer: string, amount of time to add to each booking
:param no_day_span: boolean, if you dont want time-slots that span span days
"""
data = kwargs
if type(resource_ids) == str:
data['resource_ids'] = [resource_ids]
return self.api_client.call_api('post', self.base, data)
class AppClient:
def __init__(self, app_token):
self.base = 'app'
self.api_client = ApiClient(app_token, self.base)
def get_current_app(self):
"""
returns the application object
"""
return self.api_client.call_api('get')
def invite_resources(self, email):
"""
required
:param email: string, email address to invite
returns: the new resource object
"""
url = self.base + '/invite'
data = {'email': email}
return self.api_client.call_api('post', url, data=data)
class Calendar:
def __init__(self, app_token):
self.base = 'calendars'
self.api_client = ApiClient(app_token, self.base)
def create(self, resource_id, name, description, **kwargs):
"""
required
:param resource_id: string, id of the resource to create the calendar for
:param name: string, name of calendar
:param description: string, description of the calendar
optional
:param backgroundcolor: string, hex color to use as background for events
:param foregroundcolor: string, hex color to use as forground for events
returns new calendar object
"""
data = kwargs
data['resource_id'] = resource_id
data['name'] = name
data['description'] = description
return self.api_client.call_api('post', data=data)
def list(self):
return self.api_client.call_api('get')
def retrieve(self, calendar_id):
"""
required
:param calendar_id: string, id of calendar
returns calendar object
"""
url = self.base + '/' + str(calendar_id)
return self.api_client.call_api('get', url)
def update(self, calendar_id, **kwargs):
"""
required
:param calendar_id: string, id of calendar
optional
:param name: string, name of the calendar
:param description: string, description of the calendar
:param foregroundcolor: string, hex color code of the forground
:param backgroundcolor: string, hex color code of the background
:param provider_sync: boolean, enable or disable syncing
:param primary: boolean, set the calendar as primary
return boolean
"""
url = self.base + '/' + str(calendar_id)
data = kwargs
return self.api_client.call_api('put', url, data)
def delete(self, calendar_id):
"""
required
:param calendar_id: string, calendar id to delete
returns boolean
"""
url = self.base + '/' + str(calendar_id)
return self.api_client.call_api('delete', url)
class Resource:
def __init__(self, app_token):
self.base = "resources"
self.api_client = ApiClient(app_token)
def list(self):
"""
returns an object of resources
"""
return self.api_client.call_api('get', self.base)
def create(self,
name,
timezone=None,
email=None,
first_name=None,
last_name=None,
password=None,
tags=[]):
"""
required
:param name: string, name of the resource
:param timezone: timezone of the resource
defaults to machine local
optional
:param email: string
:param first_name: string
:param last_name: string
:param password: string, if not set, a random password will be assigned
"""
if not timezone:
timezone = get_localzone()
data = {'name': name, 'timezone': str(timezone)}
if email:
data['email'] = email
if first_name:
data['first_name'] = first_name
if last_name:
data['last_name'] = last_name
if password:
data['password'] = password
return self.api_client.call_api('post', self.base, data)
def retrieve(self, resource_id):
"""
:param resource_id: id of resource
returns the resource object
"""
url = self.base + '/' + str(resource_id)
return self.api_client.call_api('get', url)
def update(self, resource_id, **kwargs):
"""
required
:param resource_id: id of the resource
optional
:param name: string
:param first_name: string
:param last_name: string
:param password: string, if not set, a random password will be assigned
:param timezone: timezone of the resource defaults to machine local
"""
url = self.base + '/' + str(resource_id)
data = kwargs
data['id'] = str(resource_id)
if len(data) <= 1:
return False
return self.api_client.call_api('put', url, kwargs)
def delete(self, id):
url = self.base + '/' + str(id)
return self.api_client.call_api('delete', url)
class Event:
def __init__(self, app_token):
self.base = 'events'
self.api_client = ApiClient(app_token, self.base)
def create(self, start, end, what, where, calendar_id, resource_id,
**kwargs):
"""
required
:param start: datetime, start of the event
:param end: datetime, end of the event
:param what: string, description of the event
:param where: string, location of the event
:param calendar_id: string, calendar to add the event to
:param resource_id: string, resources_id
optional
:param participants: array of strings, eamils to invite as participants
:param invite: boolean
:param description: string, description of the event
:param my_rsvp: string, allowed values: accepted, needsAction, declined, tentative
:param sync_provider: boolean, triggers a sync with the provider
:param all_day: boolean, if true, date will be sent to google as an all day event
"""
data = kwargs
data['start'] = to_rfc3339(start)
data['end'] = to_rfc3339(end)
data['what'] = what
data['where'] = where
data['calendar_id'] = calendar_id
return self.api_client.call_api('post', data=data)
def list(self, start, end, search=None):
"""
required
:param start: datetime, of start time
:param end: datetime, of end time,
optional
:param search: sring, only allowd value is resource id
returns a list meeting these critera
"""
data = {'start': to_rfc3339(start), 'end': to_rfc3339(end)}
if search:
data['search'] = "?resource_id:" + search
return self.api_client.call_api('get', data=data)
def retrieve(self, event_id):
"""
required
:param event_id: id of the event
return the event object
"""
url = self.base + '/' + str(event_id)
return self.api_client.call_api('get', url)
def update(self, event_id, **kwargs):
"""
required
:param event_id: string, id of the event
optional
:param start: datetime, start time of the event
:param end: datetime, end of the event
:param what: string, name of the event
:param where: string, where the event is taking place
:param participates: array of strings, emails to invite
:param all_day: boolean, is this an all day event?
"""
url = self.base + '/' + str(event_id)
data = kwargs
if 'start' in data:
data['start'] = to_rfc3339(data['start'])
if 'end' in data:
data['end'] = to_rfc3339(data['end'])
return self.api_client.call_api('put', url, data=data)
def delete(self, event_id):
"""
required
:param event_id: string, id of event to delete
return boolean
"""
url = self.base + '/' + str(event_id)
return self.api_client.call_api('delete', url)
