def add_message_attrs(self, db_session, new_uid, msg): """ Post-create-message bits.""" with db_session.no_autoflush: parent_thread = fetch_corresponding_thread( db_session, self.namespace_id, new_uid.message) construct_new_thread = True if parent_thread: # If there's a parent thread that isn't too long already, # add to it. Otherwise create a new thread. parent_message_count = self._count_thread_messages( parent_thread.id, db_session) if parent_message_count < MAX_THREAD_LENGTH: construct_new_thread = False if construct_new_thread: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) else: parent_thread.messages.append(new_uid.message) db_session.flush() # Make sure this thread has all the correct labels common.add_any_new_thread_labels(new_uid.message.thread, new_uid, db_session) new_uid.update_flags_and_labels(msg.flags) return new_uid
def add_message_attrs(self, db_session, new_uid, msg): """ Post-create-message bits.""" with db_session.no_autoflush: parent_thread = fetch_corresponding_thread(db_session, self.namespace_id, new_uid.message) construct_new_thread = True if parent_thread: # If there's a parent thread that isn't too long already, # add to it. Otherwise create a new thread. parent_message_count = self._count_thread_messages( parent_thread.id, db_session) if parent_message_count < MAX_THREAD_LENGTH: construct_new_thread = False if construct_new_thread: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) else: parent_thread.messages.append(new_uid.message) db_session.flush() # Make sure this thread has all the correct labels common.add_any_new_thread_labels(new_uid.message.thread, new_uid, db_session) new_uid.update_flags_and_labels(msg.flags) return new_uid
def add_message_attrs(self, db_session, new_uid, msg, folder): """ Post-create-message bits.""" with db_session.no_autoflush: clean_subject = cleanup_subject(new_uid.message.subject) parent_threads = db_session.query(ImapThread).filter( ImapThread.subject.like(clean_subject)).all() if parent_threads == []: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) new_uid.message.thread_order = 0 else: # FIXME: arbitrarily select the first thread. This shouldn't # be a problem now but it could become one if we choose # to implement thread-splitting. parent_thread = parent_threads[0] parent_thread.messages.append(new_uid.message) constructed_thread = thread_messages(parent_thread.messages) for index, message in enumerate(constructed_thread): message.thread_order = index # Make sure this thread has all the correct labels common.update_thread_labels(new_uid.message.thread, folder.name, [folder.canonical_name], db_session) new_uid.update_imap_flags(msg.flags) return new_uid
def add_message_attrs(self, db_session, new_uid, msg, folder): """ Gmail-specific post-create-message bits. """ # Disable autoflush so we don't try to flush a message with null # thread_id, causing a crash, and so that we don't flush on each # added/removed label. with db_session.no_autoflush: new_uid.message.g_msgid = msg.g_msgid # NOTE: g_thrid == g_msgid on the first message in the thread :) new_uid.message.g_thrid = msg.g_thrid # we rely on Gmail's threading instead of our threading algorithm. new_uid.message.thread_order = 0 new_uid.update_imap_flags(msg.flags, msg.g_labels) # FIXME: @karim not sure if it's necessary to clean up strings like # \\Inbox, \\Trash, etc. new_uid.g_labels = [label for label in msg.g_labels] thread = new_uid.message.thread = ImapThread.from_gmail_message( db_session, new_uid.account.namespace, new_uid.message) # make sure this thread has all the correct labels common.update_thread_labels(thread, folder.name, msg.g_labels, db_session) return new_uid
def add_gmail_attrs(db_session, log, new_uid, flags, folder, g_thrid, g_msgid, g_labels, created): """ Gmail-specific post-create-message bits. """ # Disable autoflush so we don't try to flush a message with null # thread_id, causing a crash, and so that we don't flush on each # added/removed label. with db_session.no_autoflush: new_uid.message.g_msgid = g_msgid # NOTE: g_thrid == g_msgid on the first message in the thread :) new_uid.message.g_thrid = g_thrid new_uid.update_imap_flags(flags, g_labels) thread = new_uid.message.thread = ImapThread.from_gmail_message( db_session, new_uid.account.namespace, new_uid.message) # make sure this thread has all the correct labels new_labels = account.update_thread_labels(thread, folder.name, g_labels, db_session) # Reconciliation for Drafts, Sent Mail folders: if (('draft' in new_labels or 'sent' in new_labels) and not created and new_uid.message.inbox_uid): reconcile_message(db_session, log, new_uid.message.inbox_uid, new_uid.message) return new_uid
def add_message_attrs(self, db_session, new_uid, msg, folder): """ Post-create-message bits.""" with db_session.no_autoflush: parent_threads = self.fetch_similar_threads(db_session, new_uid) construct_new_thread = True if parent_threads: # If there's a parent thread that isn't too long already, # add to it. Otherwise create a new thread. parent_thread = parent_threads[0] parent_message_count, = db_session.query( func.count(Message.id)). \ filter(Message.thread_id == parent_thread.id).one() if parent_message_count < MAX_THREAD_LENGTH: construct_new_thread = False if construct_new_thread: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) new_uid.message.thread_order = 0 else: parent_thread = parent_threads[0] parent_thread.messages.append(new_uid.message) constructed_thread = thread_messages(parent_thread.messages) for index, message in enumerate(constructed_thread): message.thread_order = index db_session.flush() # Make sure this thread has all the correct labels common.add_any_new_thread_labels(new_uid.message.thread, new_uid, db_session) new_uid.update_imap_flags(msg.flags) return new_uid
def add_message_to_thread(self, db_session, message_obj, raw_message): """ Associate message_obj to the right Thread object, creating a new thread if necessary. """ with db_session.no_autoflush: # Disable autoflush so we don't try to flush a message with null # thread_id. parent_thread = fetch_corresponding_thread(db_session, self.namespace_id, message_obj) construct_new_thread = True if parent_thread: # If there's a parent thread that isn't too long already, # add to it. Otherwise create a new thread. parent_message_count = self._count_thread_messages( parent_thread.id, db_session) if parent_message_count < MAX_THREAD_LENGTH: construct_new_thread = False if construct_new_thread: message_obj.thread = ImapThread.from_imap_message( db_session, self.namespace_id, message_obj) else: parent_thread.messages.append(message_obj)
def add_message_attrs(self, db_session, new_uid, msg): """ Post-create-message bits.""" with db_session.no_autoflush: parent_threads = self.fetch_similar_threads(db_session, new_uid) construct_new_thread = True if parent_threads: # If there's a parent thread that isn't too long already, # add to it. Otherwise create a new thread. parent_thread = parent_threads[0] parent_message_count, = db_session.query( func.count(Message.id)). \ filter(Message.thread_id == parent_thread.id).one() if parent_message_count < MAX_THREAD_LENGTH: construct_new_thread = False if construct_new_thread: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) new_uid.message.thread_order = 0 else: parent_thread = parent_threads[0] parent_thread.messages.append(new_uid.message) constructed_thread = thread_messages(parent_thread.messages) for index, message in enumerate(constructed_thread): message.thread_order = index db_session.flush() # Make sure this thread has all the correct labels common.add_any_new_thread_labels(new_uid.message.thread, new_uid, db_session) new_uid.update_flags_and_labels(msg.flags) return new_uid
def add_message_to_thread(self, db_session, message_obj, raw_message): """ Associate message_obj to the right Thread object, creating a new thread if necessary. """ with db_session.no_autoflush: # Disable autoflush so we don't try to flush a message with null # thread_id. parent_thread = fetch_corresponding_thread( db_session, self.namespace_id, message_obj) construct_new_thread = True if parent_thread: # If there's a parent thread that isn't too long already, # add to it. Otherwise create a new thread. parent_message_count = self._count_thread_messages( parent_thread.id, db_session) if parent_message_count < MAX_THREAD_LENGTH: construct_new_thread = False if construct_new_thread: message_obj.thread = ImapThread.from_imap_message( db_session, self.namespace_id, message_obj) else: parent_thread.messages.append(message_obj)
def add_message_attrs(self, db_session, new_uid, msg, folder): """ Gmail-specific post-create-message bits. """ # Disable autoflush so we don't try to flush a message with null # thread_id, causing a crash, and so that we don't flush on each # added/removed label. with db_session.no_autoflush: new_uid.message.g_msgid = msg.g_msgid # NOTE: g_thrid == g_msgid on the first message in the thread :) new_uid.message.g_thrid = msg.g_thrid # we rely on Gmail's threading instead of our threading algorithm. new_uid.message.thread_order = 0 new_uid.update_imap_flags(msg.flags, msg.g_labels) thread = new_uid.message.thread = ImapThread.from_gmail_message( db_session, new_uid.account.namespace, new_uid.message) # make sure this thread has all the correct labels new_labels = common.update_thread_labels(thread, folder.name, msg.g_labels, db_session) # Reconciliation for Drafts, Sent Mail folders: if (('draft' in new_labels or 'sent' in new_labels) and not msg.created and new_uid.message.inbox_uid): reconcile_message(db_session, new_uid.message.inbox_uid, new_uid.message) return new_uid
def add_message_to_thread(self, db_session, message_obj, raw_message): """Associate message_obj to the right Thread object, creating a new thread if necessary. We rely on Gmail's threading as defined by X-GM-THRID instead of our threading algorithm.""" # NOTE: g_thrid == g_msgid on the first message in the thread message_obj.g_msgid = raw_message.g_msgid message_obj.g_thrid = raw_message.g_thrid with db_session.no_autoflush: # Disable autoflush so we don't try to flush a message with null # thread_id. message_obj.thread = ImapThread.from_gmail_message(db_session, self.namespace_id, message_obj)
def add_yahoo_attrs(db_session, log, new_uid, flags, folder, created): """ Yahoo-specific post-create-message bits.""" with db_session.no_autoflush: new_uid.message.thread = ImapThread.from_yahoo_message( db_session, new_uid.account.namespace, new_uid.message) new_uid.update_imap_flags(flags) if folder in ('draft', 'sent') and not created and new_uid.message.inbox_uid: reconcile_message(db_session, log, new_uid.message.inbox_uid, new_uid.message) return new_uid
def add_message_to_thread(self, db_session, message_obj, raw_message): """Associate message_obj to the right Thread object, creating a new thread if necessary. We rely on Gmail's threading as defined by X-GM-THRID instead of our threading algorithm.""" # NOTE: g_thrid == g_msgid on the first message in the thread message_obj.g_msgid = raw_message.g_msgid message_obj.g_thrid = raw_message.g_thrid with db_session.no_autoflush: # Disable autoflush so we don't try to flush a message with null # thread_id. message_obj.thread = ImapThread.from_gmail_message( db_session, self.namespace_id, message_obj)
def add_message_attrs(self, db_session, new_uid, msg): """ Gmail-specific post-create-message bits. """ # Disable autoflush so we don't try to flush a message with null # thread_id, causing a crash, and so that we don't flush on each # added/removed label. with db_session.no_autoflush: # NOTE: g_thrid == g_msgid on the first message in the thread :) new_uid.message.g_msgid = msg.g_msgid new_uid.message.g_thrid = msg.g_thrid # We rely on Gmail's threading instead of our threading algorithm. new_uid.message.thread = ImapThread.from_gmail_message( db_session, new_uid.account.namespace, new_uid.message) return new_uid
def add_message_attrs(self, db_session, new_uid, msg): """ Gmail-specific post-create-message bits. """ # Disable autoflush so we don't try to flush a message with null # thread_id, causing a crash, and so that we don't flush on each # added/removed label. with db_session.no_autoflush: new_uid.message.g_msgid = msg.g_msgid # NOTE: g_thrid == g_msgid on the first message in the thread :) new_uid.message.g_thrid = msg.g_thrid # we rely on Gmail's threading instead of our threading algorithm. new_uid.update_flags_and_labels(msg.flags, msg.g_labels) thread = new_uid.message.thread = ImapThread.from_gmail_message( db_session, new_uid.account.namespace, new_uid.message) # make sure this thread has all the correct labels common.add_any_new_thread_labels(thread, new_uid, db_session) return new_uid
def add_attrs(db_session, log, new_uid, flags, folder, created): """ Post-create-message bits.""" with db_session.no_autoflush: clean_subject = cleanup_subject(new_uid.message.subject) parent_threads = db_session.query(ImapThread).filter( ImapThread.subject.like(clean_subject)).all() if parent_threads == []: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) new_uid.message.thread_order = 0 else: # FIXME: arbitrarily select the first thread. This shouldn't # be a problem now but it could become one if we choose # to implement thread-splitting. parent_thread = parent_threads[0] parent_thread.messages.append(new_uid.message) constructed_thread = thread_messages(parent_thread.messages) for index, message in enumerate(constructed_thread): message.thread_order = index # FIXME: refactor 'new_labels' name. This is generic IMAP, not # gmail. # make sure this thread has all the correct labels new_labels = account.update_thread_labels(new_uid.message.thread, folder.name, [folder.canonical_name], db_session) # Reconciliation for Drafts, Sent Mail folders: if (('draft' in new_labels or 'sent' in new_labels) and not created and new_uid.message.inbox_uid): reconcile_message(db_session, log, new_uid.message.inbox_uid, new_uid.message) new_uid.update_imap_flags(flags) return new_uid
def add_attrs(db_session, log, new_uid, flags, folder, created): """ Post-create-message bits.""" with db_session.no_autoflush: clean_subject = cleanup_subject(new_uid.message.subject) parent_threads = db_session.query(ImapThread).\ filter(ImapThread.subject.like(clean_subject)).all() if parent_threads == []: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) new_uid.message.thread_order = 0 else: # FIXME: arbitrarily select the first thread. This shouldn't # be a problem now but it could become one if we choose # to implement thread-splitting. parent_thread = parent_threads[0] parent_thread.messages.append(new_uid.message) constructed_thread = thread_messages(parent_thread.messages) for index, message in enumerate(constructed_thread): message.thread_order = index # FIXME: refactor 'new_labels' name. This is generic IMAP, not # gmail. # make sure this thread has all the correct labels new_labels = account.update_thread_labels(new_uid.message.thread, folder.name, [folder.canonical_name], db_session) # Reconciliation for Drafts, Sent Mail folders: if (('draft' in new_labels or 'sent' in new_labels) and not created and new_uid.message.inbox_uid): reconcile_message(db_session, log, new_uid.message.inbox_uid, new_uid.message) new_uid.update_imap_flags(flags) return new_uid
def add_message_attrs(self, db_session, new_uid, msg, folder): """ Post-create-message bits.""" with db_session.no_autoflush: parent_threads = self.fetch_similar_threads(db_session, new_uid) construct_new_thread = True if parent_threads: # If there's a parent thread that isn't too long already, # add to it. Otherwise create a new thread. parent_thread = parent_threads[0] parent_message_count, = db_session.query( func.count(Message.id)). \ filter(Message.thread_id == parent_thread.id).one() if parent_message_count < MAX_THREAD_LENGTH: construct_new_thread = False if construct_new_thread: new_uid.message.thread = ImapThread.from_imap_message( db_session, new_uid.account.namespace, new_uid.message) new_uid.message.thread_order = 0 else: # FIXME: arbitrarily select the first thread. This shouldn't # be a problem now but it could become one if we choose # to implement thread-splitting. parent_thread = parent_threads[0] parent_thread.messages.append(new_uid.message) constructed_thread = thread_messages(parent_thread.messages) for index, message in enumerate(constructed_thread): message.thread_order = index # Make sure this thread has all the correct labels common.update_thread_labels(new_uid.message.thread, folder.name, [folder.canonical_name], db_session) new_uid.update_imap_flags(msg.flags) return new_uid
def add_message_attrs(self, db_session, new_uid, msg, folder): """ Gmail-specific post-create-message bits. """ # Disable autoflush so we don't try to flush a message with null # thread_id, causing a crash, and so that we don't flush on each # added/removed label. with db_session.no_autoflush: new_uid.message.g_msgid = msg.g_msgid # NOTE: g_thrid == g_msgid on the first message in the thread :) new_uid.message.g_thrid = msg.g_thrid # we rely on Gmail's threading instead of our threading algorithm. new_uid.message.thread_order = 0 new_uid.update_imap_flags(msg.flags, msg.g_labels) # FIXME: @karim not sure if it's necessary to clean up strings like # \\Inbox, \\Trash, etc. new_uid.g_labels = [label for label in msg.g_labels] thread = new_uid.message.thread = ImapThread.from_gmail_message( db_session, new_uid.account.namespace, new_uid.message) # make sure this thread has all the correct labels common.add_any_new_thread_labels(thread, new_uid, db_session) return new_uid