/* Copyright 2011 Yorba Foundation * * This software is licensed under the GNU Lesser General Public License * (version 2.1 or later). See the COPYING file in this distribution. */ // TODO: This class currently deals with generic email storage as well as IMAP-specific issues; in // the future, to support other email services, will need to break this up. private class Geary.Sqlite.Folder : Geary.AbstractFolder, Geary.LocalFolder, Geary.ReferenceSemantics { private const Geary.Email.Field REQUIRED_FOR_DUPLICATE_DETECTION = Geary.Email.Field.REFERENCES | Geary.Email.Field.PROPERTIES; protected int manual_ref_count { get; protected set; } private ImapDatabase db; private FolderRow folder_row; private Geary.Imap.FolderProperties? properties; private MessageTable message_table; private MessageLocationTable location_table; private ImapMessagePropertiesTable imap_message_properties_table; private Geary.FolderPath path; private bool opened = false; internal Folder(ImapDatabase db, FolderRow folder_row, Geary.Imap.FolderProperties? properties, Geary.FolderPath path) throws Error { this.db = db; this.folder_row = folder_row; this.properties = properties; this.path = path; message_table = db.get_message_table(); location_table = db.get_message_location_table(); imap_message_properties_table = db.get_imap_message_properties_table(); } private void check_open() throws Error { if (!opened) throw new EngineError.OPEN_REQUIRED("%s not open", to_string()); } public override Geary.FolderPath get_path() { return path; } public override Geary.FolderProperties? get_properties() { // TODO: TBD: alteration/updated signals for folders return properties; } public override Geary.Folder.ListFlags get_supported_list_flags() { return Geary.Folder.ListFlags.NONE; } public Geary.Email.Field get_duplicate_detection_fields() { return REQUIRED_FOR_DUPLICATE_DETECTION; } internal void update_properties(Geary.Imap.FolderProperties? properties) { this.properties = properties; } public override async void open_async(bool readonly, Cancellable? cancellable = null) throws Error { if (opened) throw new EngineError.ALREADY_OPEN("%s already open", to_string()); opened = true; notify_opened(Geary.Folder.OpenState.LOCAL, yield get_email_count_async(cancellable)); } public override async void close_async(Cancellable? cancellable = null) throws Error { if (!opened) return; opened = false; notify_closed(CloseReason.FOLDER_CLOSED); } public override async int get_email_count_async(Cancellable? cancellable = null) throws Error { check_open(); // TODO: This can be cached and updated when changes occur return yield location_table.fetch_count_for_folder_async(null, folder_row.id, cancellable); } public async int get_id_position_async(Geary.EmailIdentifier id, Cancellable? cancellable) throws Error { check_open(); Transaction transaction = yield db.begin_transaction_async("Folder.get_id_position_async", cancellable); int64 message_id; if (!yield location_table.does_ordering_exist_async(transaction, folder_row.id, id.ordering, out message_id, cancellable)) { return -1; } return yield location_table.fetch_message_position_async(transaction, message_id, folder_row.id, cancellable); } public override async void create_email_async(Geary.Email email, Cancellable? cancellable = null) throws Error { yield atomic_create_email_async(null, email, cancellable); } // TODO: Need to break out IMAP-specific functionality private async int64 search_for_duplicate_async(Transaction transaction, Geary.Email email, Cancellable? cancellable) throws Error { // if fields not present, then no duplicate can reliably be found if (!email.fields.is_all_set(REQUIRED_FOR_DUPLICATE_DETECTION)) return Sqlite.Row.INVALID_ID; // what's more, actually need all those fields to be available, not merely attempted, // to err on the side of safety if (email.message_id == null) return Sqlite.Row.INVALID_ID; Imap.EmailProperties? imap_properties = (Imap.EmailProperties) email.properties; string? internaldate = (imap_properties != null && imap_properties.internaldate != null) ? imap_properties.internaldate.original : null; long rfc822_size = (imap_properties != null) ? imap_properties.rfc822_size.value : -1; if (String.is_empty(internaldate) || rfc822_size < 0) return Sqlite.Row.INVALID_ID; // See if it already exists; first by UID (which is only guaranteed to be unique in a folder, // not account-wide) int64 message_id; if (yield location_table.does_ordering_exist_async(transaction, folder_row.id, email.id.ordering, out message_id, cancellable)) { return message_id; } // reset message_id = Sqlite.Row.INVALID_ID; // look for duplicate via Message-ID Gee.List? list = yield message_table.search_message_id_async(transaction, email.message_id, cancellable); // only a duplicate candidate if exactly one found, otherwise err on the side of safety if (list != null && list.size == 1) message_id = list[0]; // look for duplicate in IMAP message properties Gee.List? duplicate_ids = yield imap_message_properties_table.search_for_duplicates_async( transaction, internaldate, rfc822_size, cancellable); if (duplicate_ids != null && duplicate_ids.size > 0) { // if a message_id was found via Message-ID, search for a match; else if one duplicate // was found via IMAP properties, use that, otherwise err on the side of safety if (message_id != Sqlite.Row.INVALID_ID) { int64 match_id = Sqlite.Row.INVALID_ID; foreach (int64 duplicate_id in duplicate_ids) { if (message_id == duplicate_id) { match_id = duplicate_id; break; } } // use the matched ID, which if not found, invalidates the discovered ID message_id = match_id; } else if (duplicate_ids.size == 1) { message_id = duplicate_ids[0]; } else { message_id = Sqlite.Row.INVALID_ID; } } return message_id; } // Returns false if the message already exists at the specified position private async bool associate_with_folder_async(Transaction transaction, int64 message_id, Geary.Email email, Cancellable? cancellable) throws Error { // see if an email exists at this position MessageLocationRow? location_row = yield location_table.fetch_async(transaction, folder_row.id, email.position, cancellable); if (location_row != null) return false; // insert email at supplied position location_row = new MessageLocationRow(location_table, Row.INVALID_ID, message_id, folder_row.id, email.id.ordering, email.position); yield location_table.create_async(transaction, location_row, cancellable); return true; } private async void atomic_create_email_async(Transaction? supplied_transaction, Geary.Email email, Cancellable? cancellable) throws Error { check_open(); Transaction transaction = supplied_transaction ?? yield db.begin_transaction_async( "Folder.atomic_create_email_async", cancellable); // See if this Email is already associated with the folder int64 message_id; bool associated = yield location_table.does_ordering_exist_async(transaction, folder_row.id, email.id.ordering, out message_id, cancellable); // if duplicate found, associate this email with this folder and merge in any new details if (!associated || message_id == Sqlite.Row.INVALID_ID) message_id = yield search_for_duplicate_async(transaction, email, cancellable); // if already associated or a duplicate, associated if (message_id != Sqlite.Row.INVALID_ID) { if (!associated) yield associate_with_folder_async(transaction, message_id, email, cancellable); yield merge_email_async(transaction, message_id, email, cancellable); if (supplied_transaction == null) yield transaction.commit_if_required_async(cancellable); return; } // not found, so create and associate with this folder message_id = yield message_table.create_async(transaction, new MessageRow.from_email(message_table, email), cancellable); // create the message location in the location lookup table MessageLocationRow location_row = new MessageLocationRow(location_table, Row.INVALID_ID, message_id, folder_row.id, email.id.ordering, email.position); yield location_table.create_async(transaction, location_row, cancellable); // only write out the IMAP email properties if they're supplied and there's something to // write out -- no need to create an empty row Geary.Imap.EmailProperties? properties = (Geary.Imap.EmailProperties?) email.properties; if (email.fields.fulfills(Geary.Email.Field.PROPERTIES) && properties != null) { ImapMessagePropertiesRow properties_row = new ImapMessagePropertiesRow.from_imap_properties( imap_message_properties_table, message_id, properties); yield imap_message_properties_table.create_async(transaction, properties_row, cancellable); } int count = yield location_table.fetch_count_for_folder_async(transaction, folder_row.id, cancellable); // only commit if not supplied a transaction if (supplied_transaction == null) yield transaction.commit_async(cancellable); notify_messages_appended(count); } public override async Gee.List? list_email_async(int low, int count, Geary.Email.Field required_fields, Geary.Folder.ListFlags flags, Cancellable? cancellable) throws Error { check_open(); normalize_span_specifiers(ref low, ref count, yield get_email_count_async(cancellable)); if (count == 0) return null; Transaction transaction = yield db.begin_transaction_async("Folder.list_email_async", cancellable); Gee.List? list = yield location_table.list_async(transaction, folder_row.id, low, count, cancellable); return yield list_email(transaction, list, required_fields, cancellable); } public override async Gee.List? list_email_sparse_async(int[] by_position, Geary.Email.Field required_fields, Geary.Folder.ListFlags flags, Cancellable? cancellable = null) throws Error { check_open(); Transaction transaction = yield db.begin_transaction_async("Folder.list_email_sparse_async", cancellable); Gee.List? list = yield location_table.list_sparse_async(transaction, folder_row.id, by_position, cancellable); return yield list_email(transaction, list, required_fields, cancellable); } public override async Gee.List? list_email_by_id_async(Geary.EmailIdentifier initial_id, int count, Geary.Email.Field required_fields, Geary.Folder.ListFlags flags, Cancellable? cancellable = null) throws Error { if (count == 0 || count == 1) { Geary.Email email = yield fetch_email_async(initial_id, required_fields, cancellable); Gee.List singleton = new Gee.ArrayList(); singleton.add(email); return singleton; } check_open(); Geary.Imap.UID uid = ((Geary.Imap.EmailIdentifier) initial_id).uid; bool excluding_id = flags.is_all_set(Geary.Folder.ListFlags.EXCLUDING_ID); Transaction transaction = yield db.begin_transaction_async("Folder.list_email_by_id_async", cancellable); int64 low, high; if (count < 0) { high = excluding_id ? uid.value - 1 : uid.value; low = (count != int.MIN) ? (high + count).clamp(1, uint32.MAX) : -1; } else { // count > 1 low = excluding_id ? uid.value + 1 : uid.value; high = (count != int.MAX) ? (low + count).clamp(1, uint32.MAX) : -1; } Gee.List? list = yield location_table.list_ordering_async(transaction, folder_row.id, low, high, cancellable); return yield list_email(transaction, list, required_fields, cancellable); } private async Gee.List? list_email(Transaction transaction, Gee.List? list, Geary.Email.Field required_fields, Cancellable? cancellable) throws Error { check_open(); if (list == null || list.size == 0) return null; // TODO: As this loop involves multiple database operations to form an email, might make // sense in the future to launch each async method separately, putting the final results // together when all the information is fetched Gee.List emails = new Gee.ArrayList(); foreach (MessageLocationRow location_row in list) { // fetch the message itself MessageRow? message_row = null; if (required_fields != Geary.Email.Field.NONE && required_fields != Geary.Email.Field.PROPERTIES) { message_row = yield message_table.fetch_async(transaction, location_row.message_id, required_fields, cancellable); assert(message_row != null); // only add to the list if the email contains all the required fields (because // properties comes out of a separate table, skip this if properties are requested) if (!message_row.fields.fulfills(required_fields.clear(Geary.Email.Field.PROPERTIES))) continue; } ImapMessagePropertiesRow? properties = null; if (required_fields.require(Geary.Email.Field.PROPERTIES)) { properties = yield imap_message_properties_table.fetch_async(transaction, location_row.message_id, cancellable); if (properties == null) continue; } Geary.Imap.UID uid = new Geary.Imap.UID(location_row.ordering); int position = yield location_row.get_position_async(transaction, cancellable); if (position == -1) { debug("Unable to locate position of email during list of %s, dropping", to_string()); continue; } Geary.Imap.EmailIdentifier email_id = new Geary.Imap.EmailIdentifier(uid); Geary.Email email = (message_row != null) ? message_row.to_email(position, email_id) : new Geary.Email(position, email_id); if (properties != null) email.set_email_properties(properties.get_imap_email_properties()); emails.add(email); } return (emails.size > 0) ? emails : null; } public override async Geary.Email fetch_email_async(Geary.EmailIdentifier id, Geary.Email.Field required_fields, Cancellable? cancellable = null) throws Error { check_open(); Geary.Imap.UID uid = ((Imap.EmailIdentifier) id).uid; Transaction transaction = yield db.begin_transaction_async("Folder.fetch_email_async", cancellable); MessageLocationRow? location_row = yield location_table.fetch_by_ordering_async(transaction, folder_row.id, uid.value, cancellable); if (location_row == null) { throw new EngineError.NOT_FOUND("No message with ID %s in folder %s", id.to_string(), to_string()); } int position = yield location_row.get_position_async(transaction, cancellable); if (position == -1) { throw new EngineError.NOT_FOUND("Unable to determine position of email %s in %s", id.to_string(), to_string()); } // loopback on perverse case if (required_fields == Geary.Email.Field.NONE) return new Geary.Email(position, id); MessageRow? message_row = yield message_table.fetch_async(transaction, location_row.message_id, required_fields, cancellable); if (message_row == null) { throw new EngineError.NOT_FOUND("No message with ID %s in folder %s", id.to_string(), to_string()); } // see if the message row fulfills everything but properties, which are held in // separate table if (!message_row.fields.fulfills(required_fields.clear(Geary.Email.Field.PROPERTIES))) { throw new EngineError.INCOMPLETE_MESSAGE( "Message %s in folder %s only fulfills %Xh fields (required: %Xh)", id.to_string(), to_string(), message_row.fields, required_fields); } ImapMessagePropertiesRow? properties = null; if (required_fields.require(Geary.Email.Field.PROPERTIES)) { properties = yield imap_message_properties_table.fetch_async(transaction, location_row.message_id, cancellable); if (properties == null) { throw new EngineError.INCOMPLETE_MESSAGE( "Message %s in folder %s does not have PROPERTIES field", id.to_string(), to_string()); } } Geary.Email email = message_row.to_email(position, id); if (properties != null) email.set_email_properties(properties.get_imap_email_properties()); return email; } public async Geary.Imap.UID? get_earliest_uid_async(Cancellable? cancellable = null) throws Error { check_open(); int64 ordering = yield location_table.get_earliest_ordering_async(null, folder_row.id, cancellable); return (ordering >= 1) ? new Geary.Imap.UID(ordering) : null; } public override async void remove_email_async(Geary.EmailIdentifier id, Cancellable? cancellable = null) throws Error { check_open(); Transaction transaction = yield db.begin_transaction_async("Folder.remove_email_async", cancellable); // TODO: Right now, deleting an email is merely detaching its association with a folder // (since it may be located in multiple folders). This means at some point in the future // a vacuum will be required to remove emails that are completely unassociated with the // account if (!yield location_table.remove_by_ordering_async(transaction, folder_row.id, id.ordering, cancellable)) { throw new EngineError.NOT_FOUND("Message %s in local store of %s not found", id.to_string(), to_string()); } yield transaction.commit_async(cancellable); notify_message_removed(id); } public async bool is_email_present_async(Geary.EmailIdentifier id, out Geary.Email.Field available_fields, Cancellable? cancellable = null) throws Error { check_open(); Geary.Imap.UID uid = ((Imap.EmailIdentifier) id).uid; available_fields = Geary.Email.Field.NONE; Transaction transaction = yield db.begin_transaction_async("Folder.is_email_present", cancellable); MessageLocationRow? location_row = yield location_table.fetch_by_ordering_async(transaction, folder_row.id, uid.value, cancellable); if (location_row == null) return false; return yield message_table.fetch_fields_async(transaction, location_row.message_id, out available_fields, cancellable); } private async void merge_email_async(Transaction transaction, int64 message_id, Geary.Email email, Cancellable? cancellable = null) throws Error { assert(message_id != Row.INVALID_ID); // if nothing to merge, nothing to do if (email.fields == Geary.Email.Field.NONE) return; if (email.fields != Geary.Email.Field.PROPERTIES) { MessageRow? message_row = yield message_table.fetch_async(transaction, message_id, email.fields, cancellable); assert(message_row != null); message_row.merge_from_remote(email); // possible nothing has changed or been added if (message_row.fields != Geary.Email.Field.NONE) yield message_table.merge_async(transaction, message_row, cancellable); } // update IMAP properties if (email.fields.fulfills(Geary.Email.Field.PROPERTIES)) { Geary.Imap.EmailProperties properties = (Geary.Imap.EmailProperties) email.properties; string? internaldate = (properties.internaldate != null) ? properties.internaldate.original : null; long rfc822_size = (properties.rfc822_size != null) ? properties.rfc822_size.value : -1; yield imap_message_properties_table.update_async(transaction, message_id, properties.flags.serialize(), internaldate, rfc822_size, cancellable); } } }