def _handle_post(self, request):
_mail_service = self.mail_service(request)
content_dict = json.loads(request.content.read())
with_attachment_content = yield self._fetch_attachment_contents(content_dict, _mail_service)
sent_mail = yield _mail_service.send_mail(with_attachment_content)
respond_json_deferred(sent_mail.as_dict(), request, status_code=201)
def return422otherwise(mail_exists):
if not mail_exists:
respond_json_deferred("", request, status_code=422)
else:
new_draft = self._draft_service.update_draft(draft_id, _mail)
new_draft.addErrback(handleDuplicatedDraftException)
defer_response(new_draft)
def finish_request(key):
_fingerprint = key.fingerprint
respond_json_deferred(
{
'account_email': _account_email,
'fingerprint': _fingerprint
}, request)
def _handle_post(self, request):
_mail_service = self.mail_service(request)
content_dict = json.loads(request.content.read())
with_attachment_content = yield self._fetch_attachment_contents(content_dict, _mail_service)
sent_mail = yield _mail_service.send_mail(with_attachment_content)
respond_json_deferred(sent_mail.as_dict(), request, status_code=201)
def return422otherwise(mail_exists):
if not mail_exists:
respond_json_deferred("", request, status_code=422)
else:
new_draft = self._draft_service.update_draft(
draft_id, _mail)
new_draft.addErrback(onError)
defer_response(new_draft)
def send_location(attachment_id):
request.setHeader('Location', '/%s/%s' % (self.BASE_URL, attachment_id))
response_json = {"ident": attachment_id,
"content-type": _file.type,
"encoding": "base64", # hard coded for now -- not really used
"name": _file.filename,
"size": len(_file.value)}
respond_json_deferred(response_json, request, status_code=201)
def onError(error):
if isinstance(error.value, SMTPDownException):
respond_json_deferred({'message': str(error.value)},
request,
status_code=503)
else:
respond_json_deferred({'message': str(error)},
request,
status_code=422)
def render_POST(self, request):
idents = json.loads(request.content.read())["idents"]
deferreds = []
for ident in idents:
deferreds.append(self._mail_service.archive_mail(ident))
d = defer.gatherResults(deferreds, consumeErrors=True)
d.addCallback(lambda _: respond_json_deferred({"successMessage": "Your message was archived"}, request))
d.addErrback(lambda _: respond_json_deferred(None, request, status_code=500))
return NOT_DONE_YET
def render_POST(self, request):
idents = json.loads(request.content.read())['idents']
deferreds = []
for ident in idents:
deferreds.append(self._mail_service.recover_mail(ident))
d = defer.gatherResults(deferreds, consumeErrors=True)
d.addCallback(lambda _: respond_json_deferred(None, request))
d.addErrback(lambda _: respond_json_deferred(None, request, status_code=500))
return NOT_DONE_YET
def render_POST(self, request):
idents = json.loads(request.content.read())['idents']
deferreds = []
for ident in idents:
deferreds.append(self._mail_service.recover_mail(ident))
d = defer.gatherResults(deferreds, consumeErrors=True)
d.addCallback(lambda _: respond_json_deferred(None, request))
d.addErrback(lambda _: respond_json_deferred(None, request, status_code=500))
return NOT_DONE_YET
def onError(error):
if isinstance(error.value, SMTPDownException):
respond_json_deferred({'message': str(error.value)},
request,
status_code=503)
else:
err(error, 'error occurred while sending')
respond_json_deferred(
{'message': 'an error occurred while sending'},
request,
status_code=422)
def send_location(attachment_id):
request.setHeader('Location',
'/%s/%s' % (self.BASE_URL, attachment_id))
response_json = {
"ident": attachment_id,
"content-type": _file.type,
"encoding": "base64", # hard coded for now -- not really used
"name": _file.filename,
"size": len(_file.value)
}
respond_json_deferred(response_json, request, status_code=201)
def _handle_put(self, request):
_draft_service = self.draft_service(request)
_mail_service = self.mail_service(request)
content_dict = json.loads(request.content.read())
with_attachment_content = yield self._fetch_attachment_contents(content_dict, _mail_service)
_mail = InputMail.from_dict(with_attachment_content, from_address=_mail_service.account_email)
draft_id = content_dict.get('ident')
pixelated_mail = yield _draft_service.process_draft(draft_id, _mail)
if not pixelated_mail:
respond_json_deferred("", request, status_code=422)
else:
respond_json_deferred({'ident': pixelated_mail.ident}, request)
def _handle_put(self, request):
_draft_service = self.draft_service(request)
_mail_service = self.mail_service(request)
content_dict = json.loads(request.content.read())
with_attachment_content = yield self._fetch_attachment_contents(content_dict, _mail_service)
_mail = InputMail.from_dict(with_attachment_content, from_address=_mail_service.account_email)
draft_id = content_dict.get('ident')
pixelated_mail = yield _draft_service.process_draft(draft_id, _mail)
if not pixelated_mail:
respond_json_deferred("", request, status_code=422)
else:
respond_json_deferred({'ident': pixelated_mail.ident}, request)
def render_GET(self, request):
d = self._mail_service.mail(self._mail_id)
d.addCallback(
lambda mail: respond_json_deferred(mail.as_dict(), request))
return NOT_DONE_YET
def test_respond_json_deferred_should_populate_response(self):
request = DummyRequest([''])
body = respond_json_deferred({"test": "yep"}, request)
self.assertEqual(200, request.code)
self.assertEqual(b"{\"test\": \"yep\"}", request.written[0])
self.assertEqual([b"application/json"],
request.responseHeaders.getRawHeaders("Content-Type"))
def test_respond_json_deferred_should_populate_response(self):
request = DummyRequest([''])
body = respond_json_deferred({"test": "yep"}, request)
self.assertEqual(200, request.code)
self.assertEqual(b"{\"test\": \"yep\"}", request.written[0])
self.assertEqual([b"application/json"],
request.responseHeaders.getRawHeaders("Content-Type"))
def render_GET(self, request):
query = request.args.get('q', [''])[0]
skip_default_tags = request.args.get('skipDefaultTags', [False])[0]
d = deferToThread(lambda: self._search_engine.tags(query=query, skip_default_tags=skip_default_tags))
d.addCallback(lambda tags: respond_json_deferred(tags, request))
return NOT_DONE_YET
def render_GET(self, request):
query = request.args.get('q', [''])[0]
skip_default_tags = request.args.get('skipDefaultTags', [False])[0]
d = deferToThread(lambda: self._search_engine.tags(
query=query, skip_default_tags=skip_default_tags))
d.addCallback(lambda tags: respond_json_deferred(tags, request))
return NOT_DONE_YET
def render_DELETE(self, request):
def response_failed(failure):
err(failure, 'something failed')
request.finish()
d = self._mail_service.delete_mail(self._mail_id)
d.addCallback(lambda _: respond_json_deferred(None, request))
d.addErrback(response_failed)
return NOT_DONE_YET
def render_DELETE(self, request):
def response_failed(failure):
err(failure, 'something failed')
request.finish()
d = self._mail_service.delete_mail(self._mail_id)
d.addCallback(lambda _: respond_json_deferred(None, request))
d.addErrback(response_failed)
return NOT_DONE_YET
def render_POST(self, request):
new_tags = json.loads(request.content.read()).get('newtags')
d = self._mail_service.update_tags(self._mail_id, new_tags)
d.addCallback(lambda mail: respond_json_deferred(mail.as_dict(), request))
def handle403(failure):
failure.trap(ValueError)
return respond_json_deferred(failure.getErrorMessage(), request, 403)
d.addErrback(handle403)
return NOT_DONE_YET
def render_GET(self, request):
query, window_size, page = request.args.get("q")[0], request.args.get("w")[0], request.args.get("p")[0]
d = self._mail_service.mails(query, window_size, page)
d.addCallback(lambda (mails, total): {"stats": {"total": total}, "mails": [mail.as_dict() for mail in mails]})
d.addCallback(lambda res: respond_json_deferred(res, request))
def error_handler(error):
print error
d.addErrback(error_handler)
return NOT_DONE_YET
def render_GET(self, request):
query = request.args.get('q', [''])
d = deferToThread(lambda: self._search_engine.contacts(query))
d.addCallback(lambda tags: respond_json_deferred(tags, request))
def handle_error(error):
print 'Something went wrong'
import traceback
traceback.print_exc()
print error
d.addErrback(handle_error)
return server.NOT_DONE_YET
def render_POST(self, request):
def response_failed(failure):
log.error('something failed: %s' % failure.getErrorMessage())
request.finish()
idents = json.loads(request.content.read())['idents']
deferreds = []
for ident in idents:
deferreds.append(self._mail_service.delete_mail(ident))
d = defer.gatherResults(deferreds, consumeErrors=True)
d.addCallback(lambda _: respond_json_deferred(None, request))
d.addErrback(response_failed)
return NOT_DONE_YET
def render_GET(self, request):
query = request.args.get('q', [''])[-1]
d = deferToThread(lambda: self._search_engine.contacts(query))
d.addCallback(lambda tags: respond_json_deferred(tags, request))
def handle_error(error):
print 'Something went wrong'
import traceback
traceback.print_exc()
print error
d.addErrback(handle_error)
return server.NOT_DONE_YET
def render_POST(self, request):
new_tags = json.loads(request.content.read()).get('newtags')
d = self._mail_service.update_tags(self._mail_id, new_tags)
d.addCallback(
lambda mail: respond_json_deferred(mail.as_dict(), request))
def handle403(failure):
failure.trap(ValueError)
return respond_json_deferred(failure.getErrorMessage(), request,
403)
d.addErrback(handle403)
return NOT_DONE_YET
def render_GET(self, request):
def populate_reply(mail):
mail_dict = mail.as_dict()
current_user = self._mail_service.account_email
sender = mail.headers.get('Reply-to', mail.headers.get('From'))
to = mail.headers.get('To', [])
ccs = mail.headers.get('Cc', [])
mail_dict['replying'] = replier.generate_recipients(sender, to, ccs, current_user)
return mail_dict
d = self._mail_service.mail(self._mail_id)
d.addCallback(lambda mail: populate_reply(mail))
d.addCallback(lambda mail_dict: respond_json_deferred(mail_dict, request))
return NOT_DONE_YET
def render_POST(self, request):
def response_failed(failure):
err(failure, 'something failed')
request.finish()
idents = json.loads(request.content.read())['idents']
deferreds = []
for ident in idents:
deferreds.append(self._mail_service.delete_mail(ident))
d = defer.gatherResults(deferreds, consumeErrors=True)
d.addCallback(lambda _: respond_json_deferred(None, request))
d.addErrback(response_failed)
return NOT_DONE_YET
def render_GET(self, request):
_mail_service = self.mail_service(request)
query, window_size, page = request.args.get('q')[0], request.args.get('w')[0], request.args.get('p')[0]
unicode_query = to_unicode(query)
d = _mail_service.mails(unicode_query, window_size, page)
d.addCallback(self._build_mails_response)
d.addCallback(lambda res: respond_json_deferred(res, request))
def error_handler(error):
print error
d.addErrback(error_handler)
return NOT_DONE_YET
def render_GET(self, request):
def populate_reply(mail):
mail_dict = mail.as_dict()
current_user = self._mail_service.account_email
sender = mail.headers.get('Reply-to', mail.headers.get('From'))
to = mail.headers.get('To', [])
ccs = mail.headers.get('Cc', [])
mail_dict['replying'] = replier.generate_recipients(
sender, to, ccs, current_user)
return mail_dict
d = self._mail_service.mail(self._mail_id)
d.addCallback(lambda mail: populate_reply(mail))
d.addCallback(
lambda mail_dict: respond_json_deferred(mail_dict, request))
return NOT_DONE_YET
def render_GET(self, request):
_mail_service = self.mail_service(request)
query, window_size, page = request.args.get('q')[0], request.args.get('w')[0], request.args.get('p')[0]
unicode_query = to_unicode(query)
d = _mail_service.mails(unicode_query, window_size, page)
d.addCallback(self._build_mails_response)
d.addCallback(lambda res: respond_json_deferred(res, request))
def error_handler(error):
print error
d.addErrback(error_handler)
return NOT_DONE_YET
def render_GET(self, request):
query, window_size, page = request.args.get('q')[0], request.args.get(
'w')[0], request.args.get('p')[0]
d = self._mail_service.mails(query, window_size, page)
d.addCallback(
lambda (mails, total): {
"stats": {
"total": total,
},
"mails": [mail.as_dict() for mail in mails]
})
d.addCallback(lambda res: respond_json_deferred(res, request))
def error_handler(error):
print error
d.addErrback(error_handler)
return NOT_DONE_YET
def render_GET(self, request):
start = time.clock()
def log_after_completion(result, start):
end = time.clock()
log.info('Needed %f ms to render response' % (end - start))
return result
_mail_service = self.mail_service(request)
query, window_size, page = request.args.get('q')[0], request.args.get('w')[0], request.args.get('p')[0]
unicode_query = to_unicode(query)
d = _mail_service.mails(unicode_query, window_size, page)
d.addCallback(self._build_mails_response)
d.addCallback(lambda res: respond_json_deferred(res, request))
d.addCallback(log_after_completion, start=start)
def error_handler(error):
print error
d.addErrback(error_handler)
return NOT_DONE_YET
def render_GET(self, request):
start = time.clock()
def log_after_completion(result, start):
end = time.clock()
log.info('Needed %f ms to render response' % (end - start))
return result
_mail_service = self.mail_service(request)
query, window_size, page = request.args.get('q')[0], request.args.get(
'w')[0], request.args.get('p')[0]
unicode_query = to_unicode(query)
d = _mail_service.mails(unicode_query, window_size, page)
d.addCallback(self._build_mails_response)
d.addCallback(lambda res: respond_json_deferred(res, request))
d.addCallback(log_after_completion, start=start)
def error_handler(error):
print error
d.addErrback(error_handler)
return NOT_DONE_YET
def onError(error):
log.error('error saving draft: %s' % error.getErrorMessage())
respond_json_deferred("", request, status_code=422)
def onSuccess(sent_mail):
data = sent_mail.as_dict()
respond_json_deferred(data, request)
def render_GET(self, request):
d = self._mail_service.mail(self._mail_id)
d.addCallback(lambda mail: respond_json_deferred(mail.as_dict(), request))
return NOT_DONE_YET
def return422otherwise(mail_exists):
if not mail_exists:
respond_json_deferred("", request, status_code=422)
else:
defer_response(
self._draft_service.update_draft(draft_id, _mail))
def return422otherwise(mail_exists):
if not mail_exists:
respond_json_deferred("", request, status_code=422)
else:
defer_response(self._draft_service.update_draft(draft_id, _mail))
def handleDuplicatedDraftException(error):
respond_json_deferred("", request, status_code=422)
def key_not_found(_):
respond_json_deferred(
{
'account_email': _account_email,
'fingerprint': FINGERPRINT_NOT_FOUND
}, request)
def error_handler(error):
logger.error(error)
respond_json_deferred({"message": "Something went wrong. Attachment not saved."}, request, status_code=500)
def defer_response(deferred):
deferred.addCallback(lambda pixelated_mail: respond_json_deferred(
{'ident': pixelated_mail.ident}, request))
def finish_request(key):
if key.private:
respond_json_deferred(None, request, status_code=401)
else:
respond_json_deferred(key.get_active_json(), request)
def key_not_found(_):
respond_json_deferred(None, request, status_code=404)
def onError(error):
err(error, 'error saving draft')
respond_json_deferred("", request, status_code=422)
def render_GET(self, request):
query = request.args.get('q', [''])[0]
d = deferToThread(lambda: self._search_engine.contacts(query))
d.addCallback(lambda tags: respond_json_deferred(tags, request))
return server.NOT_DONE_YET
def onError(error):
err(error, 'error saving draft')
respond_json_deferred("", request, status_code=422)
def error_handler(error):
logger.error(error)
respond_json_deferred(
{"message": "Something went wrong. Attachment not saved."},
request,
status_code=500)
def onSuccess(sent_mail):
data = sent_mail.as_dict()
respond_json_deferred(data, request)
def onError(error):
if isinstance(error.value, SMTPDownException):
respond_json_deferred({'message': str(error.value)}, request, status_code=503)
else:
respond_json_deferred({'message': str(error)}, request, status_code=422)
def onError(error):
if isinstance(error.value, SMTPDownException):
respond_json_deferred({'message': str(error.value)}, request, status_code=503)
else:
err(error, 'something failed')
respond_json_deferred({'message': 'an error occurred while sending'}, request, status_code=422)
def handle403(failure):
failure.trap(ValueError)
return respond_json_deferred(failure.getErrorMessage(), request, 403)
def defer_response(deferred):
deferred.addCallback(lambda pixelated_mail: respond_json_deferred({'ident': pixelated_mail.ident}, request))
def updateCallback(pixelated_mail):
if not pixelated_mail:
respond_json_deferred("", request, status_code=422)
else:
respond_json_deferred({'ident': pixelated_mail.ident}, request)
def handle403(failure):
failure.trap(ValueError)
return respond_json_deferred(failure.getErrorMessage(), request,
403)
