def imap_get():
#TODO: implement redis cache
#
user = getUser(request.args["user"])
params = get_header_params(request.headers, request.args['user'])
params.update(request.args.to_dict())
if user and not user["pending"] and user["imap_account"] and 'sig' in params and verifySignature(request.base_url, request.method, params, user["secret"]):
account_dict = json.loads(user["imap_account"])
cio_params = {'id':account_dict["id"]}
account = contextio.Account(context_io, cio_params)
messages = account.get_messages(include_body=1,body_type='text/plain',limit=100,offset=params["offset"])
#filter out unencrypted mail, and create an array of serialized messages
serialized_messages = []
for message in messages:
try:
if "-----BEGIN PGP MESSAGE-----" in message.body[0]["content"]:
message_dict = {}
for key in contextio.Message.keys:
if key != 'files':
message_dict[key] = getattr(message,key)
message_dict['body'] = message.body
serialized_messages.append(message_dict)
except:
pass
if not len(messages):
serialized_messages = None
return jsonify(messages=serialized_messages)
else:
abort(403)
def test_ContextIOFactory_returns_v2_0_instance_by_default(self):
context_io = ContextIO(consumer_key=CONTEXTIO_KEY,
consumer_secret=CONTEXTIO_SECRET)
self.assertIsInstance(context_io, V2_0)
params = {'id': CONTEXTIO_EMAIL_ID}
account = contextio.Account(context_io, params)
self.assertTrue(account.get())
def get1(uid, mid):
account = c.Account(context_io, {'id': uid})
m = c.Message(account, {'message_id': mid})
m.get(include_body=1)
return m
body = m.get_body()
s = ''
for b in body:
s += b["content"]
return s
def get_message(uid, mid):
account = c.Account(context_io, {'id': uid})
m = c.Message(account, {'message_id': mid})
m.get()
email_addr = m.addresses["to"][0]["email"]
sender_email = m.addresses["from"]["email"]
sender_name = m.addresses["from"]["name"]
email_id = m.message_id
gmail_message_id = m.gmail_message_id
timestamp = m.date
subject = m.subject
body = m.get_body()
s = ''
for b in body:
s += b["content"]
return email_addr, sender_email, sender_name, email_id, gmail_message_id, timestamp, subject, s
def get_last100_emails(uid):
f = open("/tmp/get_email.txt", "a")
f.write('id:---' + str(uid) + '-----\n')
# uid = '55210e7d8e079d8c528b4568'
account = c.Account(context_io, {'id': uid})
account.get()
time.sleep(10)
f.write(str(account))
m_list = account.get_messages(limit=30)
emails = []
i = 0
#return m_list
f.write(str(len(m_list)))
f.write(str(m_list))
for m in m_list:
i += 1
try:
f.write(str(i) + "\n")
email_addr = m.addresses["to"][0]["email"]
if email_addr != account.email_addresses[0]:
f.write('ignore')
continue
sender_email = m.addresses["from"]["email"]
sender_name = m.addresses["from"]["name"]
email_id = m.message_id
gmail_message_id = m.gmail_message_id
timestamp = m.date
subject = m.subject
body = m.get_body()
s = ''
for b in body:
s += b["content"]
emails.append([
email_addr, sender_email, sender_name, email_id,
gmail_message_id, timestamp, subject, s
])
except:
pass
f.write('----------------------------\n')
f.close()
return emails
def imap_contacts():
user = getUser(request.args["user"])
params = get_header_params(request.headers, request.args['user'])
params.update(request.args.to_dict())
if user and not user["pending"] and user["imap_account"] and 'sig' in params and verifySignature(request.base_url, request.method, params, user["secret"]):
account_dict = json.loads(user["imap_account"])
cio_params = {'id':account_dict["id"]}
account = contextio.Account(context_io, cio_params)
contacts = account.get_contacts(active_after=int(time.time())-6*30*24*60*60,sort_by='sent_count',limit=20)
#create an array of serialized contacts
serialized_contacts = []
for contact in contacts:
try:
contact_dict = {}
for key in ('email','count','name','thumbnail'):
contact_dict[key] = getattr(contact,key)
serialized_contacts.append(contact_dict)
except:
pass
return jsonify(contacts=serialized_contacts)
else:
abort(403)
def send_email(uid):
account = c.Account(context_io, {'id': uid})
account.post_message('0', '0')
def mark_read(uid, mid):
account = c.Account(context_io, {'id': uid})
m = c.Message(account, {'message_id': mid})
m.get()
m.post_flag(seen=1)
return 1
def create_webhook(uid):
account = c.Account(context_io, {'id': uid})
webhook_callback_url = "http://ec2-52-5-42-106.compute-1.amazonaws.com/webhook"
fail_url = "http://ec2-52-5-42-106.compute-1.amazonaws.com/webhook_fail"
webhook = account.post_webhook(callback_url=webhook_callback_url,
failure_notif_url=fail_url)
import contextio as c
CONSUMER_KEY = 'map3l6ci'
CONSUMER_SECRET = 'dFdFD0ykcfKhdsX9'
cio = c.ContextIO(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET)
accounts = cio.get_accounts()
print accounts
params = {'id': '565f46ffbf29598c0d8b4567'}
account = c.Account(cio, params)
account.get()
import helpers
import contextio as c
CONSUMER_KEY = "YOUR_CONTEXTIO_CONSUMER_KEY"
CONSUMER_SECRET = "YOUR_CONTEXTIO_CONSUMER_KEY"
EXISTING_ACCOUNT_ID = "AN_EXISTING_2.0_API_ACCOUNT_ID" # see the ContextIO dev console
api = c.ContextIO(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, debug=True)
account = c.Account(api, {"id": EXISTING_ACCOUNT_ID})
helpers.headerprint("FETCHING ACCOUNT INFO (Lite API)")
account.get()
helpers.cprint("id", account.id)
helpers.cprint("username", account.username)
helpers.cprint("created", account.created)
helpers.cprint("suspended", account.suspended)
helpers.cprint("email_addresses", account.email_addresses)
helpers.cprint("first_name", account.first_name)
helpers.cprint("last_name", account.last_name)
helpers.cprint("password_expired", account.password_expired)
helpers.cprint("sources", account.sources)
helpers.cprint("resource_url", account.resource_url)
print "\n"
import contextio as c
CONSUMER_KEY = 'x8k6sokj'
CONSUMER_SECRET = 'VSHVN2f4Praml16A'
context_io = c.ContextIO(
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
)
account = c.Account(context_io, {'id': '55201e008e079da4338b4569'})
m = account.get_messages(limit=1)[0]
wh = account.get_webhooks()
###################################
## Querying the API for accounts ##
###################################
context_io = c.ContextIO(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET)
accounts = context_io.get_accounts(email=user['email'])
if accounts:
account = accounts[0]
id = account.id
params = {'id': id}
account = c.Account(context_io, params)
contacts = account.get_contacts(limit=300)
pt = PrettyTable(field_names=['Name', 'E-mail ID'])
pt.align='l'
[pt.add_row((contacts[i].name, contacts[i].email))
for i in range(len(contacts))]
print pt
