def get_all(cls):
"""
Gets all programs
:return:
"""
all_programs = []
select = 1000
skip = 0
response = connection.get(cls.end_point,
query_params={
'Select': select,
'Skip': skip
})
programs = [cls(**entry) for entry in response]
num_of_programs = len(programs)
while num_of_programs > 0:
all_programs.extend(programs)
if num_of_programs < select:
break
skip += select
response = connection.get(cls.end_point,
query_params={
'Select': select,
'Skip': skip
})
programs = [cls(**entry) for entry in response]
num_of_programs = len(programs)
return programs
def get_multiple(cls, select=1000, skip=0):
response = connection.get(cls.end_point,
query_params={
'select': select,
'skip': skip
})
return [cls(**entry) for entry in response]
def get_stats(cls, since_date, end_date, aggregate_by):
"""
This operation retrieves your transactional email reporting
statistics (number sent, delivered, opens, clicks, ISP
complaints and bounces) for a specified time period.
This time period can be set with a specific end date, or
statistics can be aggregated by all time, week, month or day.
:param since_date: A date/datetime object which represents the
start date for which transactional email reporting
statistics will be returned.
:param end_date: A date/datetime object which represents the end
date up to which transactional email reporting wil be
returned (inclusive).
:param aggregate_by: The data aggregation period for
transactional email reporting statistics
:return:
"""
return connection.get(
'{}/stats/since-date/{}'.format(
cls.end_point, since_date.strftime('%Y-%m-%d')
),
query_params={
'EndDate': end_date.strftime('%Y-%m-%d'),
'AggregatedBy': aggregate_by
}
)
def get_multiple(cls, select=1000, skip=0):
"""
Gets all address books within the specified limits. This function
performs a query to return all the address books, limited by the
select and skip values. To easily get all the address books
associated with the account call :func:`~AddressBook.get_all`.
:param select: The select parameter requires a number between 1
and 1000 (0 is not a valid number). You may only select a maximum
of 1000 results in a single request. This parameter goes within
the URL.
:param skip: The skip parameter should be used in tandem with the
select parameter when wanting to iterate through a whole data set.
If you want to select the next 1000 records you should set the
select parameter to 1000 and the skip parameter to 1000, which will
return records 1001 to 2000. You should continue to do this until
0 records are returned to retrieve the whole data set. This
parameter goes within the URL.
:return:
"""
# TODO: Add some validation in for the parameter data types
response = connection.get(cls.end_point,
query_params={
'Select': select,
'Skip': skip
})
return [cls(**entry) for entry in response]
def get(cls, select=1000, skip=0):
response = connection.get('{}'.format(cls.end_point),
query_params={
'select': select,
'skip': skip
})
return [Segment(**entry) for entry in response]
def get_all(cls):
"""Gets all campaigns
:return: List of Campaigns
"""
all_campaigns = []
select = 1000
skip = 0
while True:
response = connection.get(cls.end_point,
query_params={
'Select': select,
'Skip': skip
})
campaigns = [cls(**campaign) for campaign in response]
all_campaigns.extend(campaigns)
if len(campaigns) < select:
# This means there are no more campaigns to fetch.
break
skip += select
return all_campaigns
def get_by_id(cls, id):
id = int(id)
if id < 1:
raise Exception()
response = connection.get('{}/{}'.format(cls.end_point, id))
return cls(**response)
def get_scores_modified_since(cls, date, select, skip):
response = connection.get('{}/score/modified-since/{}'.format(
cls.end_point, date.strftime('%Y-%m-%d')),
query_params={
'Select': select,
'Skip': skip
})
return [ContactScore(**entry) for entry in response]
def get_account_information():
"""
Gets a summary of information about the current status of the
account
:return:
"""
return connection.get('/v2/account-info')
def get_score_by_id(cls, id):
"""
Gets contact scoring for a contact by ID
:param id:
:return:
"""
response = connection.get('{}/{}/score'.format(cls.end_point, id))
return ContactScore(**response)
def get_by_email(cls, email):
"""
Gets a contact by email address
:param email:
:return:
"""
response = connection.get(cls.end_point + '/' + email)
return cls(**response)
def get_contact_import_report(cls, id):
"""
Gets a report with statistics about what was successfully
imported, and what was unable to be imported.
:param id:
:return:
"""
return connection.get('{}/import/{}/report'.format(cls.end_point, id))
def get_score_by_email(cls, email):
"""
Gets contact scoring for a contact by email address
:param email:
:return:
"""
response = connection.get('{}/{}/score'.format(cls.end_point, email))
return ContactScore(**response)
def get_by_id(cls, id):
"""
Gets a program enrolment by ID
:param id: The ID of the enrolment. This ID is a GUID and
looking something like b0ff06d6-af04-4af8-a299-51bcbad94c1c
:return:
"""
response = connection.get('{}/{}'.format(cls.end_point, id))
return cls(**response)
def get_contact_import_status(cls, id):
"""
Gets the import status of a previously started contact import.
:param id: The bulk upload ID value returned when you submitted
a bulk upload request. The ID is a GUID and should look similar
to 842d81e8-c619-457f-bb77-ab6c4a17da39.
:return: A dictionary that contains an the keys 'id' and 'status'.
"""
return connection.get('{}/imports/{}'.format(cls.end_point, id))
def get_by_id(cls, id):
"""
Gets a contact by ID
:param id:
:return:
"""
# TODO: Add some type checking in to make sure that the value supplied is actually an int
response = connection.get('{}/{}'.format(cls.end_point, id))
return cls(**response)
def get_survey_fields(cls, id):
"""
Gets a list of survey pages, each containing a list of the
fields on that page
:param id:
:return:
"""
response = connection.get('{}/{}/fields'.format(cls.end_point, id))
return response
def get_multiple_custom_from_addresses(select=1000, skip=0):
"""
Gets all custom from addresses which can be used in a campaign
:return:
"""
return connection.get('/v2/custom-from-addresses',
query_params={
'Select': select,
'Skip': skip
})
def get_faults(cls, id):
"""
Gets all contacts that were not successfully enrolled, by
enrolment ID
:param id: The ID of the enrolment. This ID is a GUID and
looking something like b0ff06d6-af04-4af8-a299-51bcbad94c1c
:return:
"""
response = connection.get('{}/{}/report-faults'.format(
cls.end_point, id))
return response
def get_server_time():
"""
Gets the UTC time as set on the server.
This function returns the UTC time as set on the server so you
can be sure that any dateTime dependent calls that you make are
going to happen at the time you think they will.
:return: The time on the server represented as a DateTime object
with the correct timezone applied.
"""
return date_parser(connection.get('/v2/server-time'))
def get_all(cls):
"""
Attempt to get a list of all the templates that you have associated
with your account.
This function continues to request for more templates until the
server doesn't return any more templates.
:return: A list containing :class:`Template` objects that \
represents all the templates that are associated with your account
"""
all_templates = []
select = 1000
skip = 0
response = connection.get(cls.end_point,
query_params={
'Select': select,
'Skip': skip
})
templates = [cls(**entry) for entry in response]
num_of_templates = len(templates)
while num_of_templates > 0:
all_templates.extend(templates)
if num_of_templates < select:
break
skip += select
response = connection.get(cls.end_point,
query_params={
'Select': select,
'Skip': skip
})
templates = [cls(**entry) for entry in response]
num_of_templates = len(templates)
return all_templates
def get_scoring(cls, select, skip):
"""
:param select:
:param skip:
:return:
"""
response = connection.get('{}/score/'.format(cls.end_point),
query_params={
'Select': select,
'Skip': skip
})
return [ContactScore(**entry) for entry in response]
def get_contacts_from_address_book(cls,
address_book,
with_full_data=True,
select=1000,
skip=0):
response = connection.get('/v2/address-books/{}/contacts'.format(
address_book.id),
query_params={
'withFullData': with_full_data,
'select': select,
'skip': skip
})
return [Contact(**entry) for entry in response]
def get_modified_contacts_since(cls,
date,
with_full_data=True,
select=1000,
skip=0):
response = connection.get('{}/modified-since/{}'.format(
cls.end_point, date.strftime('%Y-%m-%d')),
query_params={
'withFullData': with_full_data,
'select': select,
'skip': skip
})
return [Contact(**entry) for entry in response]
def get_all(cls):
response = connection.get('{}'.format(cls.end_point))
def _recursive_convert(entity):
folder = cls(**entity)
child_folders = entity.get('child_folders')
if child_folders is not None and child_folders != []:
folder.child_folders = []
for child in child_folders:
folder.child_folders.append(_recursive_convert(child))
return folder
return [_recursive_convert(entry) for entry in response]
def get_public(cls, select=1000, skip=0):
"""
Gets all public address books
:param select:
:param skip:
:return:
"""
# TODO: Add some validation in for the parameter data types
response = connection.get(
cls.end_point + '/public',
query_params={'Select': select, 'Skip':skip}
)
return [cls(**entry) for entry in response]
def get_contact_fields(cls):
"""
Lists all contact data fields within the account
This operation returns a list of all the contact data fields within your
account.
:return:
"""
response = connection.get(cls.end_point)
custom_data_fields = []
for entry in response:
custom_data_fields.append(cls(**entry))
return custom_data_fields
def get_by_id(cls, id):
"""
Gets a program by ID
:param id: The ID of the program
:return:
"""
id = int(id)
if id < 1:
raise Exception()
response = connection.get('{}/{}'.format(cls.end_point, id))
return cls(**response)
def get_multiple(cls, select=1000, skip=0):
"""
Gets a list of all contacts in the account
:param select:
:param skip:
:return:
"""
# TODO: Add some validation in for the parameter data types
response = connection.get(cls.end_point,
query_params={
'Select': select,
'Skip': skip
})
return [cls(**entry) for entry in response]
def get_modified_contacts_from_address_book_since(cls,
address_book,
date,
with_full_data=True,
select=1000,
skip=0):
response = connection.get(
'/v2/address-books/{}/contacts/modified-since/{}'.format(
address_book.id, date.strftime('%Y-%m-%d')),
query_params={
'withFullData': with_full_data,
'select': select,
'skip': skip
})
return [Contact(**entry) for entry in response]
