def delete_multiple_contacts(self, id_list):
"""
Deletes multiple contacts from an address book
:param id_list:
:return:
"""
self.validate_id('Sorry, unable to delete contacts from this address '
'book, as no ID value has been defined for the '
'address book.')
connection.post(
'{}/{}/contacts/delete'.format(self.end_point, self.id), id_list)
def bulk_create(cls, filedata):
"""
Bulk creates, or bulk updates, contacts.
This function allows you to upload a bulk number of contacts to
the server. The contact data must be in either a CSV or Excel
format, and it must include one column that is called 'Email' or
equivalent if your account is using a language other than
English. All other columns will be mapped to your custom contact
data fields.
Currently DotMailer place a file upload limit of 10MB. If your
data is larger than this then you will need to split it into
small chunks.
The API will return an ID for the import, and the current status.
You can re-query the import status later, by using the unique
ID value.
:param filedata: Either a file or filepath which can be read from
:return:
"""
url = '{}/import'.format(cls.end_point)
return connection.post(url, {}, files={'file': filedata})
def bulk_create_in_address_book(cls, address_book, filedata):
"""
Bulk creates, or bulk updates, contacts in an address book.
Similar to the bulk create verions, this function can be used to
create a bulk number of contacts in one go. However, this
version will also automatically associate the contact with the
address book that has been specified. The contact data must be
in either a CSV or Excel format, and it must include one column
that is called 'Email' or equivalent if your account is using a
language other than English. All other columns will be mapped
to your custom contact data fields.
Currently DotMailer place a file upload limit of 10MB. If your
data is larger than this then you will need to split it into
small chunks.
The API will return an ID for the import, and the current status.
You can re-query the import status later, by using the unique
ID value.
:param address_book:
:param filedata:
:return:
"""
url = '/v2/address-books/{}/contacts/import'.format(address_book.id)
return connection.post(url, {}, files={'file': filedata})
def send_time_optimised(self, address_book_ids=None, contact_ids=None):
"""
Sends a specified campaign to one or more address books,
segments or contacts at the most appropriate time based upon
their previous opens.
:param address_book_ids:
:param contact_ids:
:return:
"""
self.validate_id('Unable to send campaign, as no ID is defined for the'
'campaign')
# TODO: Add some validation to the when value before proceeding to use it
payload = {}
if address_book_ids is not None:
payload['AddressBookIDs'] = address_book_ids
if contact_ids is not None:
payload['ContactIDs'] = contact_ids
# If no possible contact address have been specified then raise
# an exception, as the caller is trying to send a campaing to
# no-one.
if payload == {}:
raise Exception
response = connection.post('{}/send'.format(self.end_point), payload)
send = CampaignSends(**response)
self.sends[send.id] = send
return self
def send(self):
print self.param_dict()
response = connection.post(
self.end_point,
self.param_dict()
)
return response
def send_transactional_triggered_campaign(cls, to_addresses, campaign_id, personalisation_values=None):
"""
:param to_addresses: A list of email addresses which the campaign should be sent to.
:param campaign_id: The DotMailer ID value of the campaign you wish to trigger.
:param personalisation_values: A dictionary of any personalisation values that should be used to fill in the
email.
:return:
"""
# TODO: Waiting to hear back from DotMailer to find out if you send multiple recipients how personalisation values are handled
param_data = {
'toAddresses': to_addresses,
'campaignId': campaign_id
}
if personalisation_values is not None:
param_data['personalizationValues'] = [
{'Name': key, 'Value': value} for key, value in personalisation_values.items()
]
return connection.post(
'{}/triggered-campaign'.format(cls.end_point),
param_data
)
def _create(self, folder):
if self.local_path is None:
raise Exception('No local path to the file')
with open(self.local_path, 'r') as file_data:
response = connection.post(self.end_point.format(folder.id),
files={'file': file_data})
response['local_path'] = None
return self._update_values(response)
def create(self):
"""
Creates a contact
:return:
"""
response = connection.post(self.end_point, self.param_dict())
self._update_values(response)
def create(self):
"""
Create a new DotMailer template.
This function will issue the create request to DotMailer's API,
passing through all the information you have defined.
"""
response = connection.post(self.end_point, self.param_dict())
self._update_values(response)
def unsubscribe(cls, email):
"""
Unsubscribes contact from account
:param email:
:return:
"""
return connection.post('{}/unsubscribe'.format(cls.end_point),
{'Email': email})
def create(self):
"""
Create a campaign
:return:
"""
# TODO: Confirm that if I send "null" values that campaign will still be created correctly
response = connection.post(self.end_point, self.param_dict())
self._update_values(response)
return self
def copy(cls, id):
"""
Copies a given campaign, returning the new campaign
:param id:
:return:
"""
id = int(id)
if id < 1:
raise Exception()
response = connection.post('{}/{}'.format(cls.end_point, id))
return cls(**response)
def resubscribe(cls,
email,
preferred_local=None,
return_url_to_use_if_challenged=None):
payload = {'UnsubscribedContact': {'Email': email}}
if preferred_local is not None:
payload['PreferredLocale'] = preferred_local
if return_url_to_use_if_challenged is not None:
payload[
'ReturnUrlToUseIfChallenged'] = return_url_to_use_if_challenged
response = connection.post('{}/resubscribe'.format(cls.end_point),
payload)
return Contact(**response['contact']), response['status']
def add_contact(self, contact):
"""
Adds a contact to a given address book
:param contact:
:return:
"""
self.validate_id('Sorry, unable to add contact to the address book '
'as no ID value has been defined for the address '
'book.')
response = connection.post(
'{}/{}/contacts'.format(self.end_point, self.id),
contact.param_dict())
contact._update_values(response)
def create(self):
"""
Creates an address book. If the current instance is associated
with a DotMailer ID then an exception will be raised.
:return:
"""
if not self.valid_name(self.name):
raise Exception('Invalid address book name.')
if self.id is not None:
raise Exception('This address book already has a DotMailer ID')
response = connection.post(self.end_point, self.param_dict())
self._update_values(response)
def send(self, when=None, address_book_ids=None, contact_ids=None):
"""
Sends a specified campaign to one or more address books,
segments or contacts, either as an immediate or scheduled send
:param when: A date time object which should define when the
campaign should be sent. If None then it will be sent
immediately.
:param address_book_ids:
:param contact_ids:
:return:
"""
self.validate_id('Unable to send campaign, as no ID is defined for the'
'campaign')
# TODO: Add some validation to the when value before proceeding to use it
payload = {}
if address_book_ids is not None:
payload['AddressBookIDs'] = address_book_ids
if contact_ids is not None:
payload['ContactIDs'] = contact_ids
# If no possible contact address have been specified then raise
# an exception, as the caller is trying to send a campaing to
# no-one.
if payload == {}:
raise Exception
if when is not None:
payload['SendDate'] = self.strftime(when)
response = connection.post('{}/send'.format(self.end_point), payload)
send = CampaignSends(**response)
self.sends[send.id] = send
return self
def create(self):
"""
Creates a contact data field within the account.
This operation can be used to create a contact data field within your
account.
You can't create a contact data field that already exists. If you are
unsure which data fields currently exist, please call
get_contact_fields.
The contact data field's name can only be up to 20 characters in length
and must consist of alphanumeric characters only, with hyphens and
underscores if required. The contact data field that is created will be
private by default. The amount of contact data fields you can create
will be limited by the account type you have.
:return:
"""
if not self.valid_name(self.name):
raise Exception(self.invalid_name_msg)
response = connection.post(self.end_point, self.param_dict())
self._update_values(response)
def create(self):
response = connection.post(
'{}/{}'.format(self.end_point, self.parent_id), self.param_dict())
self._update_values(response)
def refresh(self):
response = connection.post('{}/refresh/{}'.format(
self.end_point, self.id))
self._update_values(response)
