def create(self, start_date, end_date, include_subaccounts=values.unset,
status_callback=values.unset, status_callback_method=values.unset):
"""
Create a new FeedbackSummaryInstance
:param date start_date: The start_date
:param date end_date: The end_date
:param bool include_subaccounts: The include_subaccounts
:param unicode status_callback: The status_callback
:param unicode status_callback_method: The status_callback_method
:returns: Newly created FeedbackSummaryInstance
:rtype: FeedbackSummaryInstance
"""
data = values.of({
'StartDate': serialize.iso8601_date(start_date),
'EndDate': serialize.iso8601_date(end_date),
'IncludeSubaccounts': include_subaccounts,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return FeedbackSummaryInstance(
self._version,
payload,
account_sid=self._solution['account_sid'],
)
def page(self, date_created_before=values.unset, date_created=values.unset,
date_created_after=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of RecordingInstance records from the API.
Request is executed immediately
:param date date_created_before: The date_created
:param date date_created: The date_created
:param date date_created_after: The date_created
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of RecordingInstance
:rtype: Page
"""
params = values.of({
'DateCreated<': serialize.iso8601_date(date_created_before),
'DateCreated': serialize.iso8601_date(date_created),
'DateCreated>': serialize.iso8601_date(date_created_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return RecordingPage(self._version, response, self._solution)
def page(self,
to=values.unset,
from_=values.unset,
date_sent_before=values.unset,
date_sent=values.unset,
date_sent_after=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of MessageInstance records from the API.
Request is executed immediately
:param unicode to: Filter by messages to this number
:param unicode from_: Filter by from number
:param date date_sent_before: Filter by date sent
:param date date_sent: Filter by date sent
:param date date_sent_after: Filter by date sent
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of MessageInstance
:rtype: Page
"""
params = values.of({
'To':
to,
'From':
from_,
'DateSent<':
serialize.iso8601_date(date_sent_before),
'DateSent':
serialize.iso8601_date(date_sent),
'DateSent>':
serialize.iso8601_date(date_sent_after),
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return MessagePage(self._version, response, self._solution)
def page(self,
log=values.unset,
message_date_before=values.unset,
message_date=values.unset,
message_date_after=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of NotificationInstance records from the API.
Request is executed immediately
:param unicode log: The log
:param date message_date_before: The message_date
:param date message_date: The message_date
:param date message_date_after: The message_date
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of NotificationInstance
:rtype: Page
"""
params = values.of({
'Log':
log,
'MessageDate<':
serialize.iso8601_date(message_date_before),
'MessageDate':
serialize.iso8601_date(message_date),
'MessageDate>':
serialize.iso8601_date(message_date_after),
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return NotificationPage(self._version, response, self._solution)
def test_create_request(self):
self.holodeck.mock(Response(500, ''))
with self.assertRaises(TwilioException):
self.client.api.v2010.accounts(sid="ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
.calls \
.feedback_summaries.create(start_date=date(2008, 1, 2), end_date=date(2008, 1, 2))
values = {
'StartDate': serialize.iso8601_date(date(2008, 1, 2)),
'EndDate': serialize.iso8601_date(date(2008, 1, 2)),
}
self.holodeck.assert_has_request(Request(
'post',
'https://api.twilio.com/2010-04-01/Accounts/ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Calls/FeedbackSummary.json',
data=values,
))
def page(self, to=values.unset, from_=values.unset,
date_sent_before=values.unset, date_sent=values.unset,
date_sent_after=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of MessageInstance records from the API.
Request is executed immediately
:param unicode to: Filter by messages to this number
:param unicode from_: Filter by from number
:param date date_sent_before: Filter by date sent
:param date date_sent: Filter by date sent
:param date date_sent_after: Filter by date sent
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of MessageInstance
:rtype: Page
"""
params = values.of({
'To': to,
'From': from_,
'DateSent<': serialize.iso8601_date(date_sent_before),
'DateSent': serialize.iso8601_date(date_sent),
'DateSent>': serialize.iso8601_date(date_sent_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return MessagePage(
self._version,
response,
account_sid=self._solution['account_sid'],
)
def page(self, log=values.unset, message_date_before=values.unset,
message_date=values.unset, message_date_after=values.unset,
page_token=values.unset, page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of NotificationInstance records from the API.
Request is executed immediately
:param unicode log: Filter by log level
:param date message_date_before: Filter by date
:param date message_date: Filter by date
:param date message_date_after: Filter by date
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of NotificationInstance
:rtype: Page
"""
params = values.of({
'Log': log,
'MessageDate<': serialize.iso8601_date(message_date_before),
'MessageDate': serialize.iso8601_date(message_date),
'MessageDate>': serialize.iso8601_date(message_date_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return NotificationPage(
self._version,
response,
account_sid=self._solution['account_sid'],
)
def page(self,
category=values.unset,
start_date_before=values.unset,
start_date=values.unset,
start_date_after=values.unset,
end_date_before=values.unset,
end_date=values.unset,
end_date_after=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of AllTimeInstance records from the API.
Request is executed immediately
:param all_time.category category: The category
:param date start_date_before: The start_date
:param date start_date: The start_date
:param date start_date_after: The start_date
:param date end_date_before: The end_date
:param date end_date: The end_date
:param date end_date_after: The end_date
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of AllTimeInstance
:rtype: Page
"""
params = values.of({
'Category':
category,
'StartDate<':
serialize.iso8601_date(start_date_before),
'StartDate':
serialize.iso8601_date(start_date),
'StartDate>':
serialize.iso8601_date(start_date_after),
'EndDate<':
serialize.iso8601_date(end_date_before),
'EndDate':
serialize.iso8601_date(end_date),
'EndDate>':
serialize.iso8601_date(end_date_after),
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return AllTimePage(self._version, response, self._solution)
def page(self, date_created_before=values.unset, date_created=values.unset,
date_created_after=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of MediaInstance records from the API.
Request is executed immediately
:param date date_created_before: Filter by date created
:param date date_created: Filter by date created
:param date date_created_after: Filter by date created
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of MediaInstance
:rtype: Page
"""
params = values.of({
'DateCreated<': serialize.iso8601_date(date_created_before),
'DateCreated': serialize.iso8601_date(date_created),
'DateCreated>': serialize.iso8601_date(date_created_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return MediaPage(
self._version,
response,
account_sid=self._solution['account_sid'],
message_sid=self._solution['message_sid'],
)
def create(self,
start_date,
end_date,
include_subaccounts=values.unset,
status_callback=values.unset,
status_callback_method=values.unset):
"""
Create a new FeedbackSummaryInstance
:param date start_date: The start_date
:param date end_date: The end_date
:param bool include_subaccounts: The include_subaccounts
:param unicode status_callback: The status_callback
:param unicode status_callback_method: The status_callback_method
:returns: Newly created FeedbackSummaryInstance
:rtype: FeedbackSummaryInstance
"""
data = values.of({
'StartDate': serialize.iso8601_date(start_date),
'EndDate': serialize.iso8601_date(end_date),
'IncludeSubaccounts': include_subaccounts,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return FeedbackSummaryInstance(
self._version,
payload,
account_sid=self._solution['account_sid'],
)
def page(self, actor_sid=values.unset, end_date_before=values.unset,
end_date=values.unset, end_date_after=values.unset,
event_type=values.unset, resource_sid=values.unset,
source_ip_address=values.unset, start_date_before=values.unset,
start_date=values.unset, start_date_after=values.unset,
page_token=values.unset, page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of EventInstance records from the API.
Request is executed immediately
:param unicode actor_sid: The actor_sid
:param date end_date_before: The end_date
:param date end_date: The end_date
:param date end_date_after: The end_date
:param unicode event_type: The event_type
:param unicode resource_sid: The resource_sid
:param unicode source_ip_address: The source_ip_address
:param date start_date_before: The start_date
:param date start_date: The start_date
:param date start_date_after: The start_date
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of EventInstance
:rtype: Page
"""
params = values.of({
'ActorSid': actor_sid,
'EndDate<': serialize.iso8601_date(end_date_before),
'EndDate': serialize.iso8601_date(end_date),
'EndDate>': serialize.iso8601_date(end_date_after),
'EventType': event_type,
'ResourceSid': resource_sid,
'SourceIpAddress': source_ip_address,
'StartDate<': serialize.iso8601_date(start_date_before),
'StartDate': serialize.iso8601_date(start_date),
'StartDate>': serialize.iso8601_date(start_date_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return EventPage(
self._version,
response,
)
def page(self, to=values.unset, from_=values.unset,
parent_call_sid=values.unset, status=values.unset,
start_time_before=values.unset, start_time=values.unset,
start_time_after=values.unset, end_time_before=values.unset,
end_time=values.unset, end_time_after=values.unset,
page_token=values.unset, page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of CallInstance records from the API.
Request is executed immediately
:param unicode to: Phone number or Client identifier to filter `to` on
:param unicode from_: Phone number or Client identifier to filter `from` on
:param unicode parent_call_sid: Parent Call Sid to filter on
:param call.status status: Status to filter on
:param date start_time_before: StartTime to filter on
:param date start_time: StartTime to filter on
:param date start_time_after: StartTime to filter on
:param date end_time_before: EndTime to filter on
:param date end_time: EndTime to filter on
:param date end_time_after: EndTime to filter on
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of CallInstance
:rtype: Page
"""
params = values.of({
'To': to,
'From': from_,
'ParentCallSid': parent_call_sid,
'Status': status,
'StartTime<': serialize.iso8601_date(start_time_before),
'StartTime': serialize.iso8601_date(start_time),
'StartTime>': serialize.iso8601_date(start_time_after),
'EndTime<': serialize.iso8601_date(end_time_before),
'EndTime': serialize.iso8601_date(end_time),
'EndTime>': serialize.iso8601_date(end_time_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return CallPage(self._version, response, self._solution)
def page(self, date_created_before=values.unset, date_created=values.unset,
date_created_after=values.unset, date_updated_before=values.unset,
date_updated=values.unset, date_updated_after=values.unset,
friendly_name=values.unset, status=values.unset,
page_token=values.unset, page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of ConferenceInstance records from the API.
Request is executed immediately
:param date date_created_before: Filter by date created
:param date date_created: Filter by date created
:param date date_created_after: Filter by date created
:param date date_updated_before: Filter by date updated
:param date date_updated: Filter by date updated
:param date date_updated_after: Filter by date updated
:param unicode friendly_name: Filter by friendly name
:param conference.status status: The status of the conference
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of ConferenceInstance
:rtype: Page
"""
params = values.of({
'DateCreated<': serialize.iso8601_date(date_created_before),
'DateCreated': serialize.iso8601_date(date_created),
'DateCreated>': serialize.iso8601_date(date_created_after),
'DateUpdated<': serialize.iso8601_date(date_updated_before),
'DateUpdated': serialize.iso8601_date(date_updated),
'DateUpdated>': serialize.iso8601_date(date_updated_after),
'FriendlyName': friendly_name,
'Status': status,
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return ConferencePage(
self._version,
response,
account_sid=self._solution['account_sid'],
)
def page(self, category=values.unset, start_date_before=values.unset,
start_date=values.unset, start_date_after=values.unset,
end_date_before=values.unset, end_date=values.unset,
end_date_after=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of RecordInstance records from the API.
Request is executed immediately
:param record.category category: Only include usage of a given category
:param date start_date_before: Filter by start date
:param date start_date: Filter by start date
:param date start_date_after: Filter by start date
:param date end_date_before: Filter by end date
:param date end_date: Filter by end date
:param date end_date_after: Filter by end date
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of RecordInstance
:rtype: Page
"""
params = values.of({
'Category': category,
'StartDate<': serialize.iso8601_date(start_date_before),
'StartDate': serialize.iso8601_date(start_date),
'StartDate>': serialize.iso8601_date(start_date_after),
'EndDate<': serialize.iso8601_date(end_date_before),
'EndDate': serialize.iso8601_date(end_date),
'EndDate>': serialize.iso8601_date(end_date_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return RecordPage(
self._version,
response,
account_sid=self._solution['account_sid'],
)
def page(self, log_level=values.unset, start_date_before=values.unset,
start_date=values.unset, start_date_after=values.unset,
end_date_before=values.unset, end_date=values.unset,
end_date_after=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of AlertInstance records from the API.
Request is executed immediately
:param unicode log_level: The log_level
:param date start_date_before: The start_date
:param date start_date: The start_date
:param date start_date_after: The start_date
:param date end_date_before: The end_date
:param date end_date: The end_date
:param date end_date_after: The end_date
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of AlertInstance
:rtype: Page
"""
params = values.of({
'LogLevel': log_level,
'StartDate<': serialize.iso8601_date(start_date_before),
'StartDate': serialize.iso8601_date(start_date),
'StartDate>': serialize.iso8601_date(start_date_after),
'EndDate<': serialize.iso8601_date(end_date_before),
'EndDate': serialize.iso8601_date(end_date),
'EndDate>': serialize.iso8601_date(end_date_after),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return AlertPage(
self._version,
response,
)
def fetch(self, minutes=values.unset, start_date_before=values.unset,
start_date=values.unset, start_date_after=values.unset,
end_date_before=values.unset, end_date=values.unset,
end_date_after=values.unset):
"""
Fetch a WorkspaceStatisticsInstance
:param unicode minutes: The minutes
:param date start_date_before: The start_date
:param date start_date: The start_date
:param date start_date_after: The start_date
:param date end_date_before: The end_date
:param date end_date: The end_date
:param date end_date_after: The end_date
:returns: Fetched WorkspaceStatisticsInstance
:rtype: WorkspaceStatisticsInstance
"""
params = values.of({
'Minutes': minutes,
'StartDate<': serialize.iso8601_date(start_date_before),
'StartDate': serialize.iso8601_date(start_date),
'StartDate>': serialize.iso8601_date(start_date_after),
'EndDate<': serialize.iso8601_date(end_date_before),
'EndDate': serialize.iso8601_date(end_date),
'EndDate>': serialize.iso8601_date(end_date_after),
})
payload = self._version.fetch(
'GET',
self._uri,
params=params,
)
return WorkspaceStatisticsInstance(
self._version,
payload,
workspace_sid=self._solution['workspace_sid'],
)
def test_date(self):
value = datetime.date(2015, 1, 2)
actual = serialize.iso8601_date(value)
self.assertEqual('2015-01-02', actual)
def page(self,
date_created_before=values.unset,
date_created=values.unset,
date_created_after=values.unset,
date_updated_before=values.unset,
date_updated=values.unset,
date_updated_after=values.unset,
friendly_name=values.unset,
status=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of ConferenceInstance records from the API.
Request is executed immediately
:param date date_created_before: Filter by date created
:param date date_created: Filter by date created
:param date date_created_after: Filter by date created
:param date date_updated_before: Filter by date updated
:param date date_updated: Filter by date updated
:param date date_updated_after: Filter by date updated
:param unicode friendly_name: Filter by friendly name
:param conference.status status: The status of the conference
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of ConferenceInstance
:rtype: Page
"""
params = values.of({
'DateCreated<':
serialize.iso8601_date(date_created_before),
'DateCreated':
serialize.iso8601_date(date_created),
'DateCreated>':
serialize.iso8601_date(date_created_after),
'DateUpdated<':
serialize.iso8601_date(date_updated_before),
'DateUpdated':
serialize.iso8601_date(date_updated),
'DateUpdated>':
serialize.iso8601_date(date_updated_after),
'FriendlyName':
friendly_name,
'Status':
status,
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return ConferencePage(self._version, response, self._solution)
def page(self,
start_date_before=values.unset,
start_date=values.unset,
start_date_after=values.unset,
end_date_before=values.unset,
end_date=values.unset,
end_date_after=values.unset,
identity=values.unset,
tag=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of BindingInstance records from the API.
Request is executed immediately
:param date start_date_before: The start_date
:param date start_date: The start_date
:param date start_date_after: The start_date
:param date end_date_before: The end_date
:param date end_date: The end_date
:param date end_date_after: The end_date
:param unicode identity: The identity
:param unicode tag: The tag
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of BindingInstance
:rtype: Page
"""
params = values.of({
'StartDate<':
serialize.iso8601_date(start_date_before),
'StartDate':
serialize.iso8601_date(start_date),
'StartDate>':
serialize.iso8601_date(start_date_after),
'EndDate<':
serialize.iso8601_date(end_date_before),
'EndDate':
serialize.iso8601_date(end_date),
'EndDate>':
serialize.iso8601_date(end_date_after),
'Identity':
identity,
'Tag':
tag,
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return BindingPage(self._version, response, self._solution)
def page(self,
actor_sid=values.unset,
end_date_before=values.unset,
end_date=values.unset,
end_date_after=values.unset,
event_type=values.unset,
resource_sid=values.unset,
source_ip_address=values.unset,
start_date_before=values.unset,
start_date=values.unset,
start_date_after=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of EventInstance records from the API.
Request is executed immediately
:param unicode actor_sid: The actor_sid
:param date end_date_before: The end_date
:param date end_date: The end_date
:param date end_date_after: The end_date
:param unicode event_type: The event_type
:param unicode resource_sid: The resource_sid
:param unicode source_ip_address: The source_ip_address
:param date start_date_before: The start_date
:param date start_date: The start_date
:param date start_date_after: The start_date
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of EventInstance
:rtype: Page
"""
params = values.of({
'ActorSid':
actor_sid,
'EndDate<':
serialize.iso8601_date(end_date_before),
'EndDate':
serialize.iso8601_date(end_date),
'EndDate>':
serialize.iso8601_date(end_date_after),
'EventType':
event_type,
'ResourceSid':
resource_sid,
'SourceIpAddress':
source_ip_address,
'StartDate<':
serialize.iso8601_date(start_date_before),
'StartDate':
serialize.iso8601_date(start_date),
'StartDate>':
serialize.iso8601_date(start_date_after),
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return EventPage(self._version, response, self._solution)
def test_unset(self):
value = values.unset
actual = serialize.iso8601_date(value)
self.assertEqual(values.unset, actual)
def test_str(self):
actual = serialize.iso8601_date('2015-01-02')
self.assertEqual('2015-01-02', actual)