def test_sanitize_params_throws_error_if_required_param_not_in_params(
self):
allowed_args = ["foo", "dog"]
params = {"foo": "bar", "cat": "pants", "dog": "shirt"}
with self.assertRaises(ArgumentError):
helpers.sanitize_params(params,
all_args=allowed_args,
required_args=["fish"])
def test_sanitize_params_throws_error_if_required_param_not_in_params(self):
allowed_args = ["foo", "dog"]
params = {
"foo": "bar",
"cat": "pants",
"dog": "shirt"
}
with self.assertRaises(ArgumentError):
helpers.sanitize_params(params, all_args=allowed_args, required_args=["fish"])
def get_contacts(self, **params):
"""List contacts in an account.
Documentation: http://context.io/docs/2.0/accounts/contacts#get
Optional Arguments:
search: string - String identifying the name or the email address
of the contact(s) you are looking for.
active_before: integer (unix time) - Only include contacts
included in at least one email dated before a given time. This
parameter should be a standard unix timestamp
active_after: integer (unix time) - Only include contacts included
in at least one email dated after a given time. This parameter
should be a standard unix timestamp
sort_by: string - The field by which to sort the returned results.
Possible values are email, count, received_count and sent_count
sort_order: string - The sort order of the returned results.
Possible values are asc and desc
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Contact objects
"""
all_args = [
'search', 'active_before', 'active_after', 'limit', 'offset',
'sort_by', 'sort_order'
]
params = helpers.sanitize_params(params, all_args)
contacts = self._request_uri("contacts", params=params)
return [Contact(self, obj) for obj in contacts.get('matches')]
def post_flag(self, **params):
"""Set message flags for a given email.
Also, populates/updates self.flags with the new data.
Optional Arguments:
seen: integer - Message has been read. Set this parameter to 1 to
set the flag, 0 to unset it.
answered: integer - Message has been answered. Set this parameter
to 1 to set the flag, 0 to unset it.
flagged: integer - Message is "flagged" for urgent/special
attention. Set this parameter to 1 to set the flag, 0 to unset
it.
deleted: integer - Message is "deleted" for later removal. An
alternative way of deleting messages is to move it to the
Trash folder. Set this parameter to 1 to set the flag, 0 to
unset it.
draft: integer - Message has not completed composition (marked as
a draft). Set this parameter to 1 to set the flag, 0 to unset
it.
Returns:
Bool, after setting self.flags.
"""
all_args = ["seen", "answered", "flagged", "deleted", "draft"]
params = helpers.sanitize_params(params, all_args)
data = self._request_uri("flags", method="POST", params=params)
status = bool(data["success"])
if status:
self.flags = data["flags"]
return status
def get_body(self, **params):
"""Fetch the message body of a given email.
This method sets self.body, and returns a data structure.
Documentation: http://context.io/docs/2.0/accounts/messages/body#get
Optional Arguments:
type: string - Many emails are sent with both rich text and plain
text versions in the message body and by default, the response
of this call will include both. It is possible to only get
either the plain or rich text version by setting the type
parameter to text/plain or text/html respectively.
Returns:
a list of dictionaries, data format below
[
{
"type": string - MIME type of message part being fetched,
"charset": string - encoding of the characters in the part of
message,
"content": string - the actual content of the message part
being pulled,
"body_section": number - indicating position of the part in
the body structure,
}
]
"""
all_args = ['type']
params = helpers.sanitize_params(params, all_args)
self.body = self._request_uri("body", params=params)
return self.body
def get_sources(self, **params):
"""Lists IMAP sources assigned for an account.
GET method for sources resource.
Documentation: http://context.io/docs/2.0/accounts/sources#get
Optional Arguments:
status: string - Only return sources whose status is of a specific
value. Possible statuses are: INVALID_CREDENTIALS,
CONNECTION_IMPOSSIBLE, NO_ACCESS_TO_ALL_MAIL, OK,
TEMP_DISABLED, and DISABLED
status_ok: integer - Set to 0 to get sources that are not working
correctly. Set to 1 to get those that are.
Returns:
A list of Source objects
"""
all_args = ['status', 'status_ok']
params = helpers.sanitize_params(params, all_args)
return [
Source(self, obj)
for obj in self._request_uri("sources", params=params)
]
def post_flag(self, **params):
"""Set message flags for a given email.
Also, populates/updates self.flags with the new data.
Optional Arguments:
seen: integer - Message has been read. Set this parameter to 1 to
set the flag, 0 to unset it.
answered: integer - Message has been answered. Set this parameter
to 1 to set the flag, 0 to unset it.
flagged: integer - Message is "flagged" for urgent/special
attention. Set this parameter to 1 to set the flag, 0 to unset
it.
deleted: integer - Message is "deleted" for later removal. An
alternative way of deleting messages is to move it to the
Trash folder. Set this parameter to 1 to set the flag, 0 to
unset it.
draft: integer - Message has not completed composition (marked as
a draft). Set this parameter to 1 to set the flag, 0 to unset
it.
Returns:
Bool, after setting self.flags.
"""
all_args = ["seen", "answered", "flagged", "deleted", "draft"]
params = helpers.sanitize_params(params, all_args)
data = self._request_uri("flags", method="POST", params=params)
status = bool(data["success"])
if status:
self.flags = data["flags"]
return status
def get_contacts(self, **params):
"""List contacts in an account.
Documentation: http://context.io/docs/2.0/accounts/contacts#get
Optional Arguments:
search: string - String identifying the name or the email address
of the contact(s) you are looking for.
active_before: integer (unix time) - Only include contacts
included in at least one email dated before a given time. This
parameter should be a standard unix timestamp
active_after: integer (unix time) - Only include contacts included
in at least one email dated after a given time. This parameter
should be a standard unix timestamp
sort_by: string - The field by which to sort the returned results.
Possible values are email, count, received_count and sent_count
sort_order: string - The sort order of the returned results.
Possible values are asc and desc
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Contact objects
"""
all_args = [
'search', 'active_before', 'active_after', 'limit', 'offset',
'sort_by', 'sort_order'
]
params = helpers.sanitize_params(params, all_args)
contacts = self._request_uri("contacts", params=params)
return [Contact(self, obj) for obj in contacts.get('matches')]
def get_discovery(self, **params):
"""Attempts to discover IMAP settings for a given email address.
2.0
Documentation: http://context.io/docs/2.0/discovery
Lite
Documentation: http://context.io/lite.0/discovery
Required Arguments:
source_type: string - The type of source you want to discover
settings for. Right now, the only supported source type is IMAP
email: string - An email address you want to discover IMAP
settings for. Make sure source_type is set to IMAP.
Returns:
A Discovery object.
"""
if 'source_type' not in params:
params['source_type'] = 'IMAP'
all_args = req_args = ['source_type', 'email']
params = helpers.sanitize_params(params, all_args, req_args)
return Discovery(self, self._request_uri('discovery', params=params))
def test_sanitize_params_ignores_params_that_are_set_to_None(self):
allowed_args = ["foo", "dog"]
params = {"foo": None, "dog": "shirt"}
cleaned_params = helpers.sanitize_params(params, all_args=allowed_args)
self.assertEqual({"dog": "shirt"}, cleaned_params)
def get_discovery(self, **params):
"""Attempts to discover IMAP settings for a given email address.
2.0
Documentation: http://context.io/docs/2.0/discovery
Lite
Documentation: http://context.io/lite.0/discovery
Required Arguments:
source_type: string - The type of source you want to discover
settings for. Right now, the only supported source type is IMAP
email: string - An email address you want to discover IMAP
settings for. Make sure source_type is set to IMAP.
Returns:
A Discovery object.
"""
if 'source_type' not in params:
params['source_type'] = 'IMAP'
all_args = req_args = ['source_type', 'email']
params = helpers.sanitize_params(params, all_args, req_args)
return Discovery(self, self._request_uri('discovery', params=params))
def get_body(self, **params):
"""Fetch the message body of a given email.
This method sets self.body, and returns a data structure.
Documentation: http://context.io/docs/2.0/accounts/messages/body#get
Optional Arguments:
type: string - Many emails are sent with both rich text and plain
text versions in the message body and by default, the response
of this call will include both. It is possible to only get
either the plain or rich text version by setting the type
parameter to text/plain or text/html respectively.
Returns:
a list of dictionaries, data format below
[
{
"type": string - MIME type of message part being fetched,
"charset": string - encoding of the characters in the part of
message,
"content": string - the actual content of the message part
being pulled,
"body_section": number - indicating position of the part in
the body structure,
}
]
"""
all_args = ['type']
params = helpers.sanitize_params(params, all_args)
self.body = self._request_uri("body", params=params)
return self.body
def post_connect_token(self, **kwargs):
req_args = ["callback_url"]
all_args = ["email", "first_name", "last_name", "status_callback_url"] + req_args
params = sanitize_params(kwargs, all_args, req_args)
return super(Lite, self).post_connect_token(**params)
def get_accounts(self, **params):
"""List of Accounts.
GET method for the accounts resource.
Documentation: http://context.io/docs/2.0/accounts#get
Optional Arguments:
email: string - Only return account associated
to this email address
status: string - Only return accounts with sources
whose status is of a specific value. If an account has many
sources, only those matching the given value will be
included in the response. Possible statuses are:
INVALID_CREDENTIALS, CONNECTION_IMPOSSIBLE,
NO_ACCESS_TO_ALL_MAIL, OK, TEMP_DISABLED and DISABLED
status_ok: int - Only return accounts with sources
whose status is of a specific value. If an account has many
sources, only those matching the given value will be included
in the response. Possible statuses are: INVALID_CREDENTIALS,
CONNECTION_IMPOSSIBLE, NO_ACCESS_TO_ALL_MAIL, OK, TEMP_DISABLED
and DISABLED
limit: int - The maximum number of results to return
offset: int - Start the list at this offset (zero-based)
Returns:
A list of Account objects
"""
all_args = ["email", "status", "status_ok", "limit", "offset"]
params = helpers.sanitize_params(params, all_args)
return [Account(self, obj) for obj in self._request_uri("accounts", params=params)]
def test_sanitize_params_removes_unwanted_params(self):
allowed_args = ["foo", "dog"]
params = {"foo": "bar", "cat": "pants", "dog": "shirt"}
self.assertEqual({
"foo": "bar",
"dog": "shirt"
}, helpers.sanitize_params(params, all_args=allowed_args))
def post(self, uri="", return_bool=True, params={}, headers={}, all_args=[], required_args=[]):
params = helpers.sanitize_params(params, all_args, required_args)
response = self._request_uri(uri, method="POST", params=params, headers=headers)
if return_bool:
return bool(response['success'])
return response
def get_users(self, **kwargs):
all_args = ["email", "status", "status_ok", "limit", "offset"]
params = sanitize_params(kwargs, all_args)
return [
User(self, obj)
for obj in self._request_uri("users", params=params)
]
def post_connect_token(self, **kwargs):
req_args = ["callback_url"]
all_args = ["email", "first_name", "last_name", "status_callback_url"
] + req_args
params = sanitize_params(kwargs, all_args, req_args)
return super(Lite, self).post_connect_token(**params)
def get(self, uri="", return_bool=True, params={}, all_args=[], required_args=[]):
response = self._request_uri(uri, params=helpers.sanitize_params(params, all_args, required_args))
self.__init__(self.parent, response)
if return_bool:
return True
return response
def get_email_accounts(self, **params):
all_args = ["status", "status_ok"]
params = sanitize_params(params, all_args)
return [
EmailAccount(self, obj)
for obj in self._request_uri("email_accounts", params=params)
]
def test_sanitize_params_ignores_params_that_are_set_to_None(self):
allowed_args = ["foo", "dog"]
params = {
"foo": None,
"dog": "shirt"
}
cleaned_params = helpers.sanitize_params(params, all_args=allowed_args)
self.assertEqual({"dog": "shirt"}, cleaned_params)
def get_thread(self, **params):
"""List other messages in the same thread as this message.
Documentation: http://context.io/docs/2.0/accounts/messages/thread#get
Optional Arguments:
include_body: integer - Set to 1 to include message bodies in the
result. Since message bodies must be retrieved from the IMAP
server, expect a performance hit when setting this parameter.
include_headers: mixed - Can be set to 0 (default), 1 or raw. If
set to 1, complete message headers, parsed into an array, are
included in the results. If set to raw, the headers are also
included but as a raw unparsed string. Since full original
headers bodies must be retrieved from the IMAP server, expect
a performance hit when setting this parameter.
include_flags: integer - Set to 1 to include IMAP flags of
messages in the result. Since message flags must be retrieved
from the IMAP server, expect a performance hit when setting
this parameter.
body_type: string - Used when include_body is set to get only body
parts of a given MIME-type (for example text/html)
limit: integer - The maximum number of messages to include in the
messages property of the response.
offset: integer - Start the list of messages at this offset
(zero-based).
Returns:
a Thread object. Unless we can't find a thread id, then just the
response
"""
all_args = [
"include_body", "include_headers", "include_flags", "body_type",
"limit", "offset"
]
params = helpers.sanitize_params(params, all_args)
data = self._request_uri("thread", params=params)
# try to find the gmail_thread_id
gmail_thread_id = None
messages = data.get("messages")
if messages is not None:
first_message = messages[0]
gmail_thread_id = first_message.get("gmail_thread_id")
if gmail_thread_id:
data["gmail_thread_id"] = "gm-{0}".format(gmail_thread_id)
self.thread = Thread(self.parent, data) if gmail_thread_id else data
# if we have the subject, set thread.subject
if self.subject and self.thread:
self.thread.subject = self.subject
return self.thread
def get_thread(self, **params):
"""List other messages in the same thread as this message.
Documentation: http://context.io/docs/2.0/accounts/messages/thread#get
Optional Arguments:
include_body: integer - Set to 1 to include message bodies in the
result. Since message bodies must be retrieved from the IMAP
server, expect a performance hit when setting this parameter.
include_headers: mixed - Can be set to 0 (default), 1 or raw. If
set to 1, complete message headers, parsed into an array, are
included in the results. If set to raw, the headers are also
included but as a raw unparsed string. Since full original
headers bodies must be retrieved from the IMAP server, expect
a performance hit when setting this parameter.
include_flags: integer - Set to 1 to include IMAP flags of
messages in the result. Since message flags must be retrieved
from the IMAP server, expect a performance hit when setting
this parameter.
body_type: string - Used when include_body is set to get only body
parts of a given MIME-type (for example text/html)
limit: integer - The maximum number of messages to include in the
messages property of the response.
offset: integer - Start the list of messages at this offset
(zero-based).
Returns:
a Thread object. Unless we can't find a thread id, then just the
response
"""
all_args = [
"include_body", "include_headers", "include_flags", "body_type",
"limit", "offset"
]
params = helpers.sanitize_params(params, all_args)
data = self._request_uri("thread", params=params)
# try to find the gmail_thread_id
gmail_thread_id = None
messages = data.get("messages")
if messages is not None:
first_message = messages[0]
gmail_thread_id = first_message.get("gmail_thread_id")
if gmail_thread_id:
data["gmail_thread_id"] = "gm-{0}".format(gmail_thread_id)
self.thread = Thread(self.parent, data) if gmail_thread_id else data
# if we have the subject, set thread.subject
if self.subject and self.thread:
self.thread.subject = self.subject
return self.thread
def test_sanitize_params_removes_unwanted_params(self):
allowed_args = ["foo", "dog"]
params = {
"foo": "bar",
"cat": "pants",
"dog": "shirt"
}
self.assertEqual(
{"foo": "bar", "dog": "shirt"},
helpers.sanitize_params(params, all_args=allowed_args)
)
def post_user(self, **kwargs):
req_args = ["email", "server", "username", "use_ssl", "port", "type"]
if check_for_account_credentials(kwargs):
all_args = [
"password", "provider_refresh_token", "provider_consumer_key", "migrate_account_id",
"first_name", "last_name"
] + req_args
params = sanitize_params(kwargs, all_args, req_args)
return User(self, self._request_uri("users", method="POST", params=params))
def post_user(self, **kwargs):
req_args = ["email", "server", "username", "use_ssl", "port", "type"]
if check_for_account_credentials(kwargs):
all_args = [
"password", "provider_refresh_token", "provider_consumer_key",
"migrate_account_id", "first_name", "last_name"
] + req_args
params = sanitize_params(kwargs, all_args, req_args)
return User(
self, self._request_uri("users", method="POST", params=params))
def get(self,
uri="",
return_bool=True,
params={},
all_args=[],
required_args=[]):
response = self._request_uri(uri,
params=helpers.sanitize_params(
params, all_args, required_args))
self.__init__(self.parent, response)
if return_bool:
return True
return response
def get_files(self, **params):
"""List files exchanges with a contact.
Documentation: http://context.io/docs/2.0/accounts/contacts/files#get
Optional Arguments:
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of File objects
"""
all_args = ['limit', 'offset']
params = helpers.sanitize_params(params, all_args)
return [File(self.parent, obj) for obj in self._request_uri('files', params=params)]
def post_oauth_provider(self, **params):
"""Add a new OAuth provider.
Required Arguments:
type: string - Identification of the OAuth provider. This must be
either GMAIL_OAUTH2 and MSLIVECONNECT.
provider_consumer_key: string - The OAuth consumer key
provider_consumer_secret: string - The OAuth consumer secret
Returns:
a dictionary
"""
all_args = req_args = ["type", "provider_consumer_key", "provider_consumer_secret"]
params = helpers.sanitize_params(params, all_args, req_args)
return self._request_uri("oauth_providers", method="POST", params=params)
def get_messages(self, **params):
"""Get current listings of email messages in a given folder.
NOTE: this gets all messages including since last sync. It's fresher,
but expect slower performance than using Account.get_messages()
Documentation:
http://context.io/docs/2.0/accounts/sources/folders/messages#get
Optional Arguments:
include_thread_size: integer - Set to 1 to include thread size in
the result.
include_body: integer - Set to 1 to include message bodies in the
result. Since message bodies must be retrieved from the IMAP
server, expect a performance hit when setting this parameter.
body_type: string - Used when include_body is set to get only body
parts of a given MIME-type (for example text/html)
include_headers: mixed - Can be set to 0 (default), 1 or raw. If
set to 1, complete message headers, parsed into an array, are
included in the results. If set to raw, the headers are also
included but as a raw unparsed string. Since full original
headers bodies must be retrieved from the IMAP server, expect
a performance hit when setting this parameter.
include_flags: integer - Set to 1 to include IMAP flags for this
message in the result. Since message flags must be retrieved
from the IMAP server, expect a performance hit when setting
this parameter.
flag_seen: integer - Set to 1 to restrict list to messages having
the \Seen flag set, set to 0 to have the messages with that
flag unset (ie. list unread messages in the folder).
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
a list of Message objects.
"""
all_args = [
"include_thread_size", "include_body", "body_type",
"include_headers", "include_flags", "flag_seen", "limit", "offset"
]
params = helpers.sanitize_params(params, all_args)
return [
Message(self, obj)
for obj in self._request_uri('messages', params=params)
]
def get_messages(self, **params):
"""Get current listings of email messages in a given folder.
NOTE: this gets all messages including since last sync. It's fresher,
but expect slower performance than using Account.get_messages()
Documentation:
http://context.io/docs/2.0/accounts/sources/folders/messages#get
Optional Arguments:
include_thread_size: integer - Set to 1 to include thread size in
the result.
include_body: integer - Set to 1 to include message bodies in the
result. Since message bodies must be retrieved from the IMAP
server, expect a performance hit when setting this parameter.
body_type: string - Used when include_body is set to get only body
parts of a given MIME-type (for example text/html)
include_headers: mixed - Can be set to 0 (default), 1 or raw. If
set to 1, complete message headers, parsed into an array, are
included in the results. If set to raw, the headers are also
included but as a raw unparsed string. Since full original
headers bodies must be retrieved from the IMAP server, expect
a performance hit when setting this parameter.
include_flags: integer - Set to 1 to include IMAP flags for this
message in the result. Since message flags must be retrieved
from the IMAP server, expect a performance hit when setting
this parameter.
flag_seen: integer - Set to 1 to restrict list to messages having
the \Seen flag set, set to 0 to have the messages with that
flag unset (ie. list unread messages in the folder).
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
a list of Message objects.
"""
all_args = [
"include_thread_size", "include_body",
"body_type", "include_headers", "include_flags", "flag_seen",
"limit", "offset"
]
params = helpers.sanitize_params(params, all_args)
return [
Message(self, obj) for obj in self._request_uri('messages', params=params)
]
def post(self,
uri="",
return_bool=True,
params={},
headers={},
all_args=[],
required_args=[]):
params = helpers.sanitize_params(params, all_args, required_args)
response = self._request_uri(uri,
method="POST",
params=params,
headers=headers)
if return_bool:
return bool(response['success'])
return response
def get_folders(self, **params):
"""Get list of folders in an IMAP source.
Documentation: http://context.io/docs/2.0/accounts/sources/folders#get
Optional Arguments:
include_extended_counts: integer -
Returns:
A list of Folder objects.
"""
all_args = ["include_extended_counts"]
params = helpers.sanitize_params(params, all_args)
return [
Folder(self, obj)
for obj in self._request_uri("folders", params=params)
]
def put(self, **params):
"""Create a folder on an IMAP source.
Documentation:
http://context.io/docs/2.0/accounts/sources/folders#id-put
Optional Arguments:
delim: string - If / isn't fancy enough as a hierarchy delimiter
when specifying the folder you want to create, you're free to
use what you want, just make sure you set this delim parameter
to tell us what you're using.
Returns:
Bool
"""
all_args = ["delim"]
params = helpers.sanitize_params(params, all_args)
status = self._request_uri(method="PUT", params=params)
return bool(status["success"])
def post_folder(self, **params):
"""Edits the folders a message is in.
This call supports adding and/or removing more than one folder
simultaneously using the [] suffix to the parameter name.
Documentation:
http://context.io/docs/2.0/accounts/messages/folders#post
Optional Arguments:
add: string - New folder this message should appear in.
remove: string - Folder this message should be removed from.
Returns:
Bool
"""
all_args = ['add', 'remove', 'add[]', 'remove[]']
params = helpers.sanitize_params(params, all_args)
return super(Message, self).post("folders", params=params)
def get_files(self, **params):
"""List files exchanges with a contact.
Documentation: http://context.io/docs/2.0/accounts/contacts/files#get
Optional Arguments:
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of File objects
"""
all_args = ['limit', 'offset']
params = helpers.sanitize_params(params, all_args)
return [
File(self.parent, obj)
for obj in self._request_uri('files', params=params)
]
def put(self, **params):
"""Create a folder on an IMAP source.
Documentation:
http://context.io/docs/2.0/accounts/sources/folders#id-put
Optional Arguments:
delim: string - If / isn't fancy enough as a hierarchy delimiter
when specifying the folder you want to create, you're free to
use what you want, just make sure you set this delim parameter
to tell us what you're using.
Returns:
Bool
"""
all_args = ["delim"]
params = helpers.sanitize_params(params, all_args)
status = self._request_uri(method="PUT", params=params)
return bool(status["success"])
def post_folder(self, **params):
"""Edits the folders a message is in.
This call supports adding and/or removing more than one folder
simultaneously using the [] suffix to the parameter name.
Documentation:
http://context.io/docs/2.0/accounts/messages/folders#post
Optional Arguments:
add: string - New folder this message should appear in.
remove: string - Folder this message should be removed from.
Returns:
Bool
"""
all_args = ['add', 'remove', 'add[]', 'remove[]']
params = helpers.sanitize_params(params, all_args)
return super(Message, self).post("folders", params=params)
def post_email_account(self, **kwargs):
req_args = ["email", "server", "username", "use_ssl", "port", "type"]
all_args = req_args + ["status_callback_url", "password"]
email_account = super(User, self).post(
uri="email_accounts", params=kwargs, return_bool=False, all_args=all_args,
required_args=req_args
)
if bool(email_account["success"]) is False:
return False
return EmailAccount(self, email_account)
if check_for_account_credentials(kwargs):
all_args = ["migrate_account_id", "first_name", "last_name"] + req_args
params = sanitize_params(kwargs, all_args, req_args)
return User(self, self._request_uri("users", method="POST", params=params))
def post_oauth_provider(self, **params):
"""Add a new OAuth provider.
Required Arguments:
type: string - Identification of the OAuth provider. This must be
either GMAIL_OAUTH2 and MSLIVECONNECT.
provider_consumer_key: string - The OAuth consumer key
provider_consumer_secret: string - The OAuth consumer secret
Returns:
a dictionary
"""
all_args = req_args = [
"type", "provider_consumer_key", "provider_consumer_secret"
]
params = helpers.sanitize_params(params, all_args, req_args)
return self._request_uri("oauth_providers",
method="POST",
params=params)
def get_sources(self, **params):
"""Lists IMAP sources assigned for an account.
GET method for sources resource.
Documentation: http://context.io/docs/2.0/accounts/sources#get
Optional Arguments:
status: string - Only return sources whose status is of a specific
value. Possible statuses are: INVALID_CREDENTIALS,
CONNECTION_IMPOSSIBLE, NO_ACCESS_TO_ALL_MAIL, OK,
TEMP_DISABLED, and DISABLED
status_ok: integer - Set to 0 to get sources that are not working
correctly. Set to 1 to get those that are.
Returns:
A list of Source objects
"""
all_args = ['status', 'status_ok']
params = helpers.sanitize_params(params, all_args)
return [Source(self, obj) for obj in self._request_uri("sources", params=params)]
def get_headers(self, **params):
"""Get complete headers for a message.
Documentation: http://context.io/docs/2.0/accounts/messages/headers#get
Optional Arguments:
raw: integer - By default, this returns messages headers parsed
into an array. Set this parameter to 1 to get raw unparsed
headers.
Returns:
Dict, data structure below.
{
Name-Of-Header: array - Values for that header (some headers can
appear more than once in the message source),
...
}
"""
all_args = ['raw']
params = helpers.sanitize_params(params, all_args)
self.headers = self._request_uri('headers', params=params)
return self.headers
def post_email_account(self, **kwargs):
req_args = ["email", "server", "username", "use_ssl", "port", "type"]
all_args = req_args + ["status_callback_url"]
email_account = super(User, self).post(uri="email_accounts",
params=kwargs,
return_bool=False,
all_args=all_args,
required_args=req_args)
if bool(email_account["success"]) is False:
return False
return EmailAccount(self, email_account)
if check_for_account_credentials(kwargs):
all_args = ["migrate_account_id", "first_name", "last_name"
] + req_args
params = sanitize_params(kwargs, all_args, req_args)
return User(
self, self._request_uri("users", method="POST", params=params))
def get_headers(self, **params):
"""Get complete headers for a message.
Documentation: http://context.io/docs/2.0/accounts/messages/headers#get
Optional Arguments:
raw: integer - By default, this returns messages headers parsed
into an array. Set this parameter to 1 to get raw unparsed
headers.
Returns:
Dict, data structure below.
{
Name-Of-Header: array - Values for that header (some headers can
appear more than once in the message source),
...
}
"""
all_args = ['raw']
params = helpers.sanitize_params(params, all_args)
self.headers = self._request_uri('headers', params=params)
return self.headers
def post_connect_token(self, **params):
"""Obtain a new connect_token for an IMAP source.
* Note: unused connect tokens are purged after 24 hours.
Documentation: http://context.io/docs/2.0/accounts/sources/connect_tokens#post
Required Arguments:
callback_url: string (url) - When the user's mailbox is connected
to your API key, the browser will call this url (GET). This
call will have a parameter called contextio_token indicating
the connect_token related to this callback. You can then do a
get on this connect_token to obtain details about the account
and source created through that token and save that account id
in your own user data.
Returns:
A dictionary (data format below)
{
"success": string - true if connect_token was successfully
created, false otherwise,
"token": string - Id of the token,
"resource_url": string - URL to of the token,
"browser_redirect_url": string - Redirect the user's browser to
this URL to have them connect their mailbox through this
token
}
"""
all_args = req_args = ['callback_url']
params = helpers.sanitize_params(params, all_args, req_args)
return self._request_uri('connect_tokens',
method='POST',
params=params)
def get_threads(self, **params):
"""List threads where contact is present.
Documentation: http://context.io/docs/2.0/accounts/contacts/threads#get
Optional Arguments:
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Thread objects.
"""
all_args = ['limit', 'offset']
params = helpers.sanitize_params(params, all_args)
thread_urls = self._request_uri('threads', params=params)
objs = []
# isolate just the gmail_thread_id so we can instantiate Thread objects
for thread_url in thread_urls:
url_components = thread_url.split('/')
objs.append({'gmail_thread_id': url_components[-1]})
return [Thread(self.parent, obj) for obj in objs]
def get_threads(self, **params):
"""List threads where contact is present.
Documentation: http://context.io/docs/2.0/accounts/contacts/threads#get
Optional Arguments:
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Thread objects.
"""
all_args = ['limit', 'offset']
params = helpers.sanitize_params(params, all_args)
thread_urls = self._request_uri('threads', params=params)
objs = []
# isolate just the gmail_thread_id so we can instantiate Thread objects
for thread_url in thread_urls:
url_components = thread_url.split('/')
objs.append({'gmail_thread_id': url_components[-1]})
return [Thread(self.parent, obj) for obj in objs]
def post_connect_token(self, **params):
"""Obtain a new connect token.
2.0
Documentation: http://context.io/docs/2.0/connect_tokens#post
Lite
Documentation: http://context.io/docs/lite/connect_tokens#post
Required Arguments:
callback_url: string (url) - When the user's mailbox is connected
to your API key, the browser will call this url (GET). This
call will have a parameter called contextio_token indicating
the connect_token related to this callback. You can then do a
get on this connect_token to obtain details about the account
and source created through that token and save that account id
in your own user data.
Optional Arguments:
email: string - The email address of the account to be added. If
specified, the first step of the connect UI where users are
prompted for their email address, first name and last name is
skipped.
first_name: string - First name of the account holder.
last_name: string - Last name of the account holder.
source_callback_url: string - If specified, we'll make a POST
request to this URL when the initial sync is completed.
source_sync_all_folders: integer - By default, we filter out some
folders like 'Deleted Items' and 'Drafts'. Set this parameter
to 1 to turn off this filtering and show every single folder.
source_sync_flags: integer - By default, we don't synchronize IMAP
flags. Set this parameter to 1 to turn on IMAP flag syncing
for the 'seen' and 'flagged' flags.
source_raw_file_list: integer - By default, we filter out files
like signature images from the files list. Set this parameter
to 1 to turn off this filtering and show every single file
attachment.
status_callback_url: string (url) - If specified, we'll make a POST
request to this URL if the connection status of the source changes.
Returns:
A dictionary, data format below
{
"success": string - true if connect_token was successfully
created, false otherwise,
"token": string - Id of the token,
"resource_url": string - URL to of the token,
"browser_redirect_url": string - Redirect the user's browser to
this URL to have them connect their mailbox through this
token
}
"""
req_args = ["callback_url"]
all_args = [
"callback_url", "email", "first_name", "last_name",
"source_callback_url", "source_sync_all_folders",
"source_sync_flags", "source_raw_file_list", "status_callback_url"
]
params = helpers.sanitize_params(params, all_args, req_args)
return super(V2_0, self).post_connect_token(**params)
def delete_read(self, **params):
all_args = ["delimiter"]
params = helpers.sanitize_params(params, all_args)
return super(Message, self).delete("read")
def get_threads(self, **params):
"""List of threads on an account.
Documentation: http://context.io/docs/2.0/accounts/threads#get
Optional Arguments:
subject: string - Get threads with messages whose subject matches
this search string. To use regular expressions instead of
simple string matching, make sure the string starts and ends
with /.
email: string - Email address of the contact for whom you want the
latest threads. This value is interpreted as received from
email X, sent to email X or sent by anyone to both email X and
the source owner.
to: string - Get threads with at least one message sent to this
email address.
sender: string - Get threads with at least one message sent from
this email address.
cc: string - Get threads with at least one message having this
email address CC'ed.
bcc: string - Get threads with at least one message having this
email address BCC'ed.
folder: string - Filter threads by the folder (or Gmail label).
This parameter can be the complete folder name with the
appropriate hierarchy delimiter for the mail server being
queried (eg. Inbox/My folder) or the "symbolic name" of the
folder (eg. \Starred). The symbolic name refers to attributes
used to refer to special use folders in a language-independant
way. See http://code.google.com/apis/gmail/imap/#xlist (Gmail
specific) and RFC-6154.
indexed_before: integer (unix time) - Get threads with at least
one message indexed before this timestamp. This is not the
same as the date of the email, it is the time Context.IO
indexed this message.
indexed_after: integer (unix time) - Get threads with at least one
message indexed after this timestamp. This is not the same as
the date of the email, it is the time Context.IO indexed this
message.
active_before: integer (unix time) - Get threads with at least one
message dated before this timestamp. The value this filter is
applied to is the Date: header of the message which refers to
the time the message is sent from the origin.
active_after: integer (unix time) - Get threads with at least one
message dated after this timestamp. The value this filter is
applied to is the Date: header of the message which refers to
the time the message is sent from the origin.
started_before: integer (unix time) - Get threads whose first
message is dated before this timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
started_after: integer (unix time) - Get threads whose first
message is dated after this timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Thread objects (nearly empty thread objects). Use the
Thread.get() method to populate the object.
"""
all_args = [
'subject', 'email', 'to', 'sender', 'from_', 'cc', 'bcc', 'folder',
'indexed_before', 'indexed_after', 'active_before', 'active_after',
'started_before', 'started_after', 'limit', 'offset'
]
params = helpers.sanitize_params(params, all_args)
# workaround to send param "from" even though it's a reserved keyword
# in python
if 'sender' in params:
params['from'] = params['sender']
del params['sender']
if 'from_' in params:
params['from'] = params['from_']
del params['from_']
thread_urls = self._request_uri('threads', params=params)
objs = []
# isolate just the gmail_thread_id so we can instantiate Thread objects
for thread_url in thread_urls:
url_components = thread_url.split('/')
objs.append({'gmail_thread_id': url_components[-1]})
return [Thread(self, obj) for obj in objs]
def get_messages(self, **params):
"""List email messages for an account.
GET method for the messages resource.
Each of the email, to, from, cc and bcc parameters can be set to a
comma-separated list of email addresses. These multiple addresses
are treated as an OR combination.
You can set more than one parameter when doing this call. Multiple
parameters are treated as an AND combination.
Optional Arguments:
subject: string - Get messages whose subject matches this search
string. To use regular expressions instead of simple string
matching, make sure the string starts and ends with /.
email: string - Email address of the contact for whom you want the
latest messages exchanged with. By "exchanged with contact X"
we mean any email received from contact X, sent to contact X
or sent by anyone to both contact X and the source owner.
to: string - Email address of a contact messages have been sent to.
sender: string - Email address of a contact messages have been
received from. Same as "from" in documentation. "from" is a
python keyword and we can't use that...
cc: string - Email address of a contact CC'ed on the messages.
bcc: string - Email address of a contact BCC'ed on the messages.
folder: string - Filter messages by the folder (or Gmail label).
This parameter can be the complete folder name with the
appropriate hierarchy delimiter for the mail server being
queried (eg. Inbox/My folder) or the "symbolic name" of the
folder (eg. \Starred). The symbolic name refers to attributes
used to refer to special use folders in a language-independant
way. See http://code.google.com/apis/gmail/imap/#xlist
(Gmail specific) and RFC-6154.
source: string - Filter messages by the account source label.
file_name: string - Search for files based on their name. You can
filter names using typical shell wildcards such as *, ? and []
or regular expressions by enclosing the search expression in a
leading / and trailing /. For example, *.pdf would give you
all PDF files while /\.jpe?g$/ would return all files whose
name ends with .jpg or .jpeg
file_size_min: integer - Search for files based on their size (in bytes).
file_size_max: integer - Search for files based on their size (in bytes).
date_before: integer (unix time) - Only include messages before a
given timestamp. The value this filter is applied to is the
Date: header of the message which refers to the time the
message is sent from the origin.
date_after: integer (unix time) - Only include messages after a
given timestamp. The value this filter is applied to is the
Date: header of the message which refers to the time the
message is sent from the origin.
indexed_before: integer (unix time) - Only include messages
indexed before a given timestamp. This is not the same as the
date of the email, it is the time Context.IO indexed this
message.
indexed_after: integer (unix time) - Only include messages indexed
after a given timestamp. This is not the same as the date of
the email, it is the time Context.IO indexed this message.
include_thread_size: integer - Set to 1 to include thread size in the result.
include_body: integer - Set to 1 to include message bodies in the
result. Since message bodies must be retrieved from the IMAP
server, expect a performance hit when setting this parameter.
include_headers: mixed - Can be set to 0 (default), 1 or raw. If
set to 1, complete message headers, parsed into an array, are
included in the results. If set to raw, the headers are also
included but as a raw unparsed string. Since full original
headers bodies must be retrieved from the IMAP server, expect
a performance hit when setting this parameter.
include_flags: integer - Set to 1 to include IMAP flags of
messages in the result. Since message flags must be retrieved
from the IMAP server, expect a performance hit when setting
this parameter.
body_type: string - Used when include_body is set to get only body
parts of a given MIME-type (for example text/html)
include_source: integer - Set to 1 to include message sources in the
result. Since message sources must be retrieved from the IMAP server,
expect a performance hit when setting this parameter.
sort_order: string - The sort order of the returned results.
Possible values are asc and desc
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Message objects.
"""
all_args = [
"subject", "email", "to", "sender", "from_", "cc", "bcc", "folder",
"date_before", "date_after", "indexed_before", "indexed_after",
"include_thread_size", "include_body", "source", "file_name",
"file_size_min", "file_size_max", "include_source",
"include_headers", "include_flags", "body_type", "sort_order",
"limit", "offset"
]
params = helpers.sanitize_params(params, all_args)
# workaround to send param "from" even though it's a reserved keyword
# in python
if 'sender' in params:
params['from'] = params['sender']
del params['sender']
if 'from_' in params:
params['from'] = params['from_']
del params['from_']
return [
Message(self, obj)
for obj in self._request_uri('messages', params=params)
]
def get_files(self, **params):
"""List of files found as email attachments.
GET method for the files resource.
Documentation: http://context.io/docs/2.0/accounts/files
Each of the email, to, from, cc and bcc parameters can be set to a
comma-separated list of email addresses. These multiple addresses
are treated as an OR combination.
You can set more than one parameter when doing this call. Multiple
parameters are treated as an AND combination.
Optional Arguments:
file_name: string - Search for files based on their name. You can
filter names using typical shell wildcards such as *, ? and []
or regular expressions by enclosing the search expression in a
leading / and trailing /. For example, *.pdf would give you
all PDF files while /\.jpe?g$/ would return all files whose
name ends with .jpg or .jpeg
file_size_min: integer - Search for files based on their size (in bytes).
file_size_max: integer - Search for files based on their size (in bytes).
email: string - Email address of the contact for whom you want the
latest files exchanged with. By "exchanged with contact X" we
mean any email received from contact X, sent to contact X or
sent by anyone to both contact X and the source owner.
to: string - Email address of a contact files have been sent to.
from: string - Email address of a contact files have been received
from.
cc: string - Email address of a contact CC'ed on the messages.
bcc: string - Email address of a contact BCC'ed on the messages.
date_before: integer (unix time) - Only include files attached to
messages sent before a given timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
date_after: integer (unix time) - Only include files attached to
messages sent after a given timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
indexed_before: integer (unix time) - Only include files attached
to messages indexed before a given timestamp. This is not the
same as the date of the email, it is the time Context.IO
indexed this message.
indexed_after: integer (unix time) - Only include files attached
to messages indexed after a given timestamp. This is not the
same as the date of the email, it is the time Context.IO
indexed this message.
source: string - Filter messages by the account source label.
sort_order: string - The sort order of the returned results.
Possible values are asc and desc
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of File objects
"""
all_args = [
'file_name', 'file_size_min', 'file_size_max', 'email', 'to',
'from', 'cc', 'bcc', 'date_before', 'date_after', 'indexed_before',
'indexed_after', 'source', 'limit', 'offset'
]
params = helpers.sanitize_params(params, all_args)
return [
File(self, obj)
for obj in self._request_uri('files', params=params)
]
def get_users(self, **kwargs):
all_args = ["email", "status", "status_ok", "limit", "offset"]
params = sanitize_params(kwargs, all_args)
return [User(self, obj) for obj in self._request_uri("users", params=params)]
def get_files(self, **params):
"""List of files found as email attachments.
GET method for the files resource.
Documentation: http://context.io/docs/2.0/accounts/files
Each of the email, to, from, cc and bcc parameters can be set to a
comma-separated list of email addresses. These multiple addresses
are treated as an OR combination.
You can set more than one parameter when doing this call. Multiple
parameters are treated as an AND combination.
Optional Arguments:
file_name: string - Search for files based on their name. You can
filter names using typical shell wildcards such as *, ? and []
or regular expressions by enclosing the search expression in a
leading / and trailing /. For example, *.pdf would give you
all PDF files while /\.jpe?g$/ would return all files whose
name ends with .jpg or .jpeg
file_size_min: integer - Search for files based on their size (in bytes).
file_size_max: integer - Search for files based on their size (in bytes).
email: string - Email address of the contact for whom you want the
latest files exchanged with. By "exchanged with contact X" we
mean any email received from contact X, sent to contact X or
sent by anyone to both contact X and the source owner.
to: string - Email address of a contact files have been sent to.
from: string - Email address of a contact files have been received
from.
cc: string - Email address of a contact CC'ed on the messages.
bcc: string - Email address of a contact BCC'ed on the messages.
date_before: integer (unix time) - Only include files attached to
messages sent before a given timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
date_after: integer (unix time) - Only include files attached to
messages sent after a given timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
indexed_before: integer (unix time) - Only include files attached
to messages indexed before a given timestamp. This is not the
same as the date of the email, it is the time Context.IO
indexed this message.
indexed_after: integer (unix time) - Only include files attached
to messages indexed after a given timestamp. This is not the
same as the date of the email, it is the time Context.IO
indexed this message.
source: string - Filter messages by the account source label.
sort_order: string - The sort order of the returned results.
Possible values are asc and desc
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of File objects
"""
all_args = [
'file_name', 'file_size_min', 'file_size_max', 'email', 'to', 'from', 'cc', 'bcc',
'date_before', 'date_after', 'indexed_before', 'indexed_after', 'source', 'limit',
'offset'
]
params = helpers.sanitize_params(params, all_args)
return [File(self, obj) for obj in self._request_uri('files', params=params)]
def get_messages(self, **params):
"""List email messages for an account.
GET method for the messages resource.
Each of the email, to, from, cc and bcc parameters can be set to a
comma-separated list of email addresses. These multiple addresses
are treated as an OR combination.
You can set more than one parameter when doing this call. Multiple
parameters are treated as an AND combination.
Optional Arguments:
subject: string - Get messages whose subject matches this search
string. To use regular expressions instead of simple string
matching, make sure the string starts and ends with /.
email: string - Email address of the contact for whom you want the
latest messages exchanged with. By "exchanged with contact X"
we mean any email received from contact X, sent to contact X
or sent by anyone to both contact X and the source owner.
to: string - Email address of a contact messages have been sent to.
sender: string - Email address of a contact messages have been
received from. Same as "from" in documentation. "from" is a
python keyword and we can't use that...
cc: string - Email address of a contact CC'ed on the messages.
bcc: string - Email address of a contact BCC'ed on the messages.
folder: string - Filter messages by the folder (or Gmail label).
This parameter can be the complete folder name with the
appropriate hierarchy delimiter for the mail server being
queried (eg. Inbox/My folder) or the "symbolic name" of the
folder (eg. \Starred). The symbolic name refers to attributes
used to refer to special use folders in a language-independant
way. See http://code.google.com/apis/gmail/imap/#xlist
(Gmail specific) and RFC-6154.
source: string - Filter messages by the account source label.
file_name: string - Search for files based on their name. You can
filter names using typical shell wildcards such as *, ? and []
or regular expressions by enclosing the search expression in a
leading / and trailing /. For example, *.pdf would give you
all PDF files while /\.jpe?g$/ would return all files whose
name ends with .jpg or .jpeg
file_size_min: integer - Search for files based on their size (in bytes).
file_size_max: integer - Search for files based on their size (in bytes).
date_before: integer (unix time) - Only include messages before a
given timestamp. The value this filter is applied to is the
Date: header of the message which refers to the time the
message is sent from the origin.
date_after: integer (unix time) - Only include messages after a
given timestamp. The value this filter is applied to is the
Date: header of the message which refers to the time the
message is sent from the origin.
indexed_before: integer (unix time) - Only include messages
indexed before a given timestamp. This is not the same as the
date of the email, it is the time Context.IO indexed this
message.
indexed_after: integer (unix time) - Only include messages indexed
after a given timestamp. This is not the same as the date of
the email, it is the time Context.IO indexed this message.
include_thread_size: integer - Set to 1 to include thread size in the result.
include_body: integer - Set to 1 to include message bodies in the
result. Since message bodies must be retrieved from the IMAP
server, expect a performance hit when setting this parameter.
include_headers: mixed - Can be set to 0 (default), 1 or raw. If
set to 1, complete message headers, parsed into an array, are
included in the results. If set to raw, the headers are also
included but as a raw unparsed string. Since full original
headers bodies must be retrieved from the IMAP server, expect
a performance hit when setting this parameter.
include_flags: integer - Set to 1 to include IMAP flags of
messages in the result. Since message flags must be retrieved
from the IMAP server, expect a performance hit when setting
this parameter.
body_type: string - Used when include_body is set to get only body
parts of a given MIME-type (for example text/html)
include_source: integer - Set to 1 to include message sources in the
result. Since message sources must be retrieved from the IMAP server,
expect a performance hit when setting this parameter.
sort_order: string - The sort order of the returned results.
Possible values are asc and desc
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Message objects.
"""
all_args = [
"subject", "email", "to", "sender", "from_", "cc", "bcc", "folder", "date_before",
"date_after", "indexed_before", "indexed_after", "include_thread_size", "include_body",
"source", "file_name", "file_size_min", "file_size_max", "include_source",
"include_headers", "include_flags", "body_type", "sort_order",
"limit", "offset"
]
params = helpers.sanitize_params(params, all_args)
# workaround to send param "from" even though it's a reserved keyword
# in python
if 'sender' in params:
params['from'] = params['sender']
del params['sender']
if 'from_' in params:
params['from'] = params['from_']
del params['from_']
return [
Message(self, obj) for obj in self._request_uri('messages', params=params)]
def post_account(self, **params):
"""Add a new account.
POST method for the accounts resource.
You can optionally pass in the params to simultaneously add a source
with just this one call. In order to accomplish this you must include all of the
required parameters to create a source AS WELL AS one of the following:
- the password for the source
- the provider_refresh_token AND provider_consumer_key
*see https://context.io/docs/2.0/accounts/sources#post for more information*
Documentation: http://context.io/docs/2.0/accounts#post
Required Arguments:
email: string - The primary email address of the account holder.
migrate_account_id: string - Existing user_id (from lite) you want
to migrate to 2.0. Either migrate_account_id or email must be specified
Optional Arguments:
first_name: string - First name of the account holder.
last_name: string - Last name of the account holder.
If adding a source in the same call:
Required Arguments:
server: string - Name or IP of the IMAP server, eg. imap.gmail.com
username: string - The username used to authenticate an IMAP
connection. On some servers, this is the same thing as
the primary email address.
use_ssl: integer - Set to 1 if you want SSL encryption to
be used when opening connections to the IMAP server. Any
other value will be considered as "do not use SSL"
port: integer - Port number to connect to on the server. Keep in
mind that most IMAP servers will have one port for standard
connection and another one for encrypted connection (see
use-ssl parameter above)
type: string - Currently, the only supported type is IMAP
Optional Arguments:
origin_ip: string - IP address of the end user requesting the account
to be created
expunge_on_deleted_flag: integer - By default, we don't filter out messages
flagged as deleted. Set this parameter to 1 to turn on this filtering.
sync_all_folders: integer - By default, we filter out some folders like
'Deleted Items' and 'Drafts'. Set this parameter to 1 to turn off this
filtering and show every single folder.
sync_folders: string - By default, we filter out some folders like
'Deleted Items' and 'Drafts'. Set this parameter to
'All,Trash' to show the 'Deleted Items' folder.
sync_flags: integer By default, we don't synchronize IMAP flags.
Set this parameter to 1 to turn on IMAP flag syncing for the 'seen' and
'flagged' flags.
raw_file_list: integer - By default, we filter out files like
signature images or those winmail.dat files form the files
list. Set this parameter to 1 to turn off this filtering and
show every single file attachments.
password: string - Password for authentication on the IMAP server.
Ignored if any of the provider_* parameters are set below.
provider_refresh_token: An OAuth2 refresh token obtained from the
IMAP account provider to be used to authenticate on this email
account.
provider_consumer_key: string - The OAuth consumer key used to
obtain the the token and token secret above for that account.
That consumer key and secret must be configured in your
Context.IO account.
callback_url: string (url) - If specified, we'll make a POST
request to this URL when the initial sync is completed.
status_callback_url: string (url) - If specified, we'll make a POST
request to this URL if the connection status of the source changes.
Returns:
An Account object
"""
req_args = ["email"]
all_args = ["email", "migrate_account_id", "first_name", "last_name", "server",
"username", "use_ssl", "port", "type", "origin_ip", "expunge_on_deleted_flag",
"sync_all_folders", "sync_folders", "sync_flags", "raw_file_list", "password",
"provider_refresh_token", "provider_consumer_key", "callback_url", "status_callback_url"
]
params = helpers.sanitize_params(params, all_args, req_args)
return Account(self, self._request_uri("accounts", method="POST", params=params))
def get_threads(self, **params):
"""List of threads on an account.
Documentation: http://context.io/docs/2.0/accounts/threads#get
Optional Arguments:
subject: string - Get threads with messages whose subject matches
this search string. To use regular expressions instead of
simple string matching, make sure the string starts and ends
with /.
email: string - Email address of the contact for whom you want the
latest threads. This value is interpreted as received from
email X, sent to email X or sent by anyone to both email X and
the source owner.
to: string - Get threads with at least one message sent to this
email address.
sender: string - Get threads with at least one message sent from
this email address.
cc: string - Get threads with at least one message having this
email address CC'ed.
bcc: string - Get threads with at least one message having this
email address BCC'ed.
folder: string - Filter threads by the folder (or Gmail label).
This parameter can be the complete folder name with the
appropriate hierarchy delimiter for the mail server being
queried (eg. Inbox/My folder) or the "symbolic name" of the
folder (eg. \Starred). The symbolic name refers to attributes
used to refer to special use folders in a language-independant
way. See http://code.google.com/apis/gmail/imap/#xlist (Gmail
specific) and RFC-6154.
indexed_before: integer (unix time) - Get threads with at least
one message indexed before this timestamp. This is not the
same as the date of the email, it is the time Context.IO
indexed this message.
indexed_after: integer (unix time) - Get threads with at least one
message indexed after this timestamp. This is not the same as
the date of the email, it is the time Context.IO indexed this
message.
active_before: integer (unix time) - Get threads with at least one
message dated before this timestamp. The value this filter is
applied to is the Date: header of the message which refers to
the time the message is sent from the origin.
active_after: integer (unix time) - Get threads with at least one
message dated after this timestamp. The value this filter is
applied to is the Date: header of the message which refers to
the time the message is sent from the origin.
started_before: integer (unix time) - Get threads whose first
message is dated before this timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
started_after: integer (unix time) - Get threads whose first
message is dated after this timestamp. The value this filter
is applied to is the Date: header of the message which refers
to the time the message is sent from the origin.
limit: integer - The maximum number of results to return.
offset: integer - Start the list at this offset (zero-based).
Returns:
A list of Thread objects (nearly empty thread objects). Use the
Thread.get() method to populate the object.
"""
all_args = [
'subject', 'email', 'to', 'sender', 'from_', 'cc', 'bcc', 'folder',
'indexed_before', 'indexed_after', 'active_before', 'active_after',
'started_before', 'started_after', 'limit', 'offset'
]
params = helpers.sanitize_params(params, all_args)
# workaround to send param "from" even though it's a reserved keyword
# in python
if 'sender' in params:
params['from'] = params['sender']
del params['sender']
if 'from_' in params:
params['from'] = params['from_']
del params['from_']
thread_urls = self._request_uri('threads', params=params)
objs = []
# isolate just the gmail_thread_id so we can instantiate Thread objects
for thread_url in thread_urls:
url_components = thread_url.split('/')
objs.append({'gmail_thread_id': url_components[-1]})
return [Thread(self, obj) for obj in objs]
def get_email_accounts(self, **params):
all_args = ["status", "status_ok"]
params = sanitize_params(params, all_args)
return [EmailAccount(self, obj) for obj in self._request_uri("email_accounts", params=params)]
