def add_fake_thread(db_session, namespace_id):
from inbox.models import Thread
dt = datetime.utcnow()
thr = Thread(subjectdate=dt, recentdate=dt, namespace_id=namespace_id)
db_session.add(thr)
db_session.commit()
return thr
def test_namespace_limiting(db, test_client):
dt = datetime.datetime.utcnow()
subject = dt.isoformat()
db.session.add(Namespace())
db.session.commit()
namespaces = db.session.query(Namespace).all()
assert len(namespaces) > 1
for ns in namespaces:
thread = Thread(namespace=ns, subjectdate=dt, recentdate=dt,
subject=subject)
add_fake_message(db.session, ns.id, thread, received_date=dt,
subject=subject)
db.session.add(Block(namespace=ns, filename=subject))
db.session.commit()
for ns in namespaces:
r = json.loads(test_client.get('/n/{}/threads?subject={}'.
format(ns.public_id, subject)).data)
assert len(r) == 1
r = json.loads(test_client.get('/n/{}/messages?subject={}'.
format(ns.public_id, subject)).data)
assert len(r) == 1
r = json.loads(test_client.get('/n/{}/files?filename={}'.
format(ns.public_id, subject)).data)
assert len(r) == 1
def test_namespace_limiting(db, api_client, default_namespaces):
dt = datetime.datetime.utcnow()
subject = dt.isoformat()
namespaces = db.session.query(Namespace).all()
assert len(namespaces) > 1
for ns in namespaces:
thread = Thread(namespace=ns,
subjectdate=dt,
recentdate=dt,
subject=subject)
add_fake_message(db.session,
ns.id,
thread,
received_date=dt,
subject=subject)
db.session.add(Block(namespace=ns, filename=subject))
db.session.commit()
for ns in namespaces:
r = api_client.get_data('/threads?subject={}'.format(subject))
assert len(r) == 1
r = api_client.get_data('/messages?subject={}'.format(subject))
assert len(r) == 1
r = api_client.get_data('/files?filename={}'.format(subject))
assert len(r) == 1
def create_and_save_draft(db_session,
account,
to_addr=None,
subject=None,
body=None,
blocks=None,
cc_addr=None,
bcc_addr=None,
new_tags=None,
thread=None,
is_reply=False,
parent_draft=None,
syncback=True):
"""
Create a draft object and commit it to the database.
"""
dt = datetime.utcnow()
uid = generate_public_id()
to_addr = to_addr or []
cc_addr = cc_addr or []
bcc_addr = bcc_addr or []
blocks = blocks or []
body = body or ''
if subject is None and thread is not None:
# Set subject from thread by default.
subject = thread.subject
subject = subject or ''
# Sets is_draft = True, state = 'draft'
message = Message.create_draft_message()
message.from_addr = [(account.sender_name, account.email_address)]
# TODO(emfree): we should maybe make received_date nullable, so its value
# doesn't change in the case of a drafted-and-later-reconciled message.
message.received_date = dt
if parent_draft is not None:
message.parent_draft_id = parent_draft.id
message.subject = subject
message.sanitized_body = body
message.to_addr = to_addr
message.cc_addr = cc_addr
message.bcc_addr = bcc_addr
# TODO(emfree): this is different from the normal 'size' value of a
# message, which is the size of the entire MIME message.
message.size = len(body)
message.is_read = True
message.is_sent = False
message.is_reply = is_reply
message.inbox_uid = uid
message.public_id = uid
# Set the snippet
message.calculate_html_snippet(body)
# Associate attachments to the draft message
for block in blocks:
# Create a new Part object to associate to the message object.
# (You can't just set block.message, because if block is an attachment
# on an existing message, that would dissociate it from the existing
# message.)
part = Part()
part.namespace_id = account.namespace.id
part.content_disposition = 'attachment'
part.content_type = block.content_type
part.is_inboxapp_attachment = True
part.data = block.data
part.filename = block.filename
message.parts.append(part)
db_session.add(part)
# TODO(emfree) Update contact data here.
if is_reply:
message.is_reply = True
# If we're updating a draft, copy the in-reply-to and references
# headers from the parent. Otherwise, construct them from the last
# message currently in the thread.
if parent_draft is not None:
message.in_reply_to = parent_draft.in_reply_to
message.references = parent_draft.references
else:
_set_reply_headers(message, thread)
if thread is None:
# Create a new thread object for the draft.
thread = Thread(subject=message.subject,
recentdate=message.received_date,
namespace=account.namespace,
subjectdate=message.received_date)
db_session.add(thread)
message.thread = thread
# This triggers an autoflush, so we need to execute it after setting
# message.thread
thread.apply_tag(account.namespace.tags['drafts'])
if new_tags:
tags_to_keep = {tag for tag in thread.tags if not tag.user_created}
thread.tags = new_tags | tags_to_keep
if syncback:
schedule_action('save_draft', message, message.namespace.id,
db_session)
db_session.add(message)
db_session.commit()
return message