Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-message

Source of release 0.5.0

0.5.0 / src / mail_sync / changes.lucb

#==============================================================================================
#
#   mail_sync/changes - Flags, moves and sending
#
#==============================================================================================

extend Engine:
    # mark: changes ==============================================================================

    ## Add (`add`) or remove flag bits `bits` on messages `uids` of folder `path`.
    func set_flags(path: const u8[], uids: const u8[], add: bool, bits: u16) -> !:
        _ = try self.select(path)
        try self.session.store((str)uids, (imap.Flags)bits, add)
        try self.update_index(path, uids, bits, add, false)

    ## Move messages `uids` of folder `path` to folder `target`.
    func move(path: const u8[], uids: const u8[], target: const u8[]) -> !:
        _ = try self.select(path)
        try self.session.move((str)uids, (str)target)
        try self.update_index(path, uids, 0, false, true)
        self.wants_full_sync = true

    ## Apply a flag change or a removal to folder `path` in the store and announce it.
    func update_index(path: const u8[], uids: const u8[], bits: u16, add: bool, remove: bool) -> !:
        var identity: Buffer
        defer identity.destroy()
        try self.folder_identity_of(path, &identity)
        var ledger = try mail_db.read_ledger(self.store, identity.text())
        defer ledger.close()
        var batch = try mail_db.Batch.begin(self.store, identity.text())
        defer batch.close()
        var numbers: List[u32]
        defer numbers.destroy()
        try read_set(uids, &numbers)
        for uid in numbers.view():
            if remove:
                try batch.remove(uid)
            elif let at = ledger.find(uid):
                let flags = ledger.flags.at(at)
                let updated = (flags | bits) if add else (flags & ~bits)
                if updated != flags:
                    try batch.set_flags(uid, updated)
        let changed = batch.count > 0
        try batch.commit()
        if changed:
            self.post("folder", path)

    ## Send the message queued at `queued` in the outbox from `sender` to the
    ## comma-separated `recipients`. It leaves the outbox once sent; a failed one stays.
    func send(queued: const u8[], sender: const u8[], recipients: const u8[]):
        self.send_message(queued, sender, recipients) catch failure:
            self.post("unsent", queued, failure.message.bytes)
            recover ()

    func send_message(queued: const u8[], sender: const u8[], recipients: const u8[]) -> !:
        self.post("status", b"Sending")
        var message: Buffer
        defer message.destroy()
        if not try mail_db.read_queued(self.store, self.account.id, (str)queued, &message):
            error(imap.unsupported, "the queued message is gone")
        let data = message.view()
        var list: List[str]
        defer list.destroy()
        var start: usize = 0
        for at in 0..<recipients.length + 1:
            if at == recipients.length or recipients[at] == ',':
                if at > start:
                    try list.append(try self.text.keep_text(recipients[start..<at]))
                start = at + 1
        var client = try smtp.Client.open(self.account.smtp_host, self.account.smtp_port, self.account.smtp_security, cancellation = &self.room.quit)
        defer client.close()
        if self.account.smtp_user.length > 0:
            try client.login(self.account.smtp_user, self.account.smtp_password)
        _ = try client.send((str)sender, list.view(), data)
        client.quit()
        # A copy in the Sent folder, unless the server files one itself (it does not
        # say; Gmail does, most do not).
        if self.folders.length() == 0:
            try self.list_folders()
        if let sent = self.sent_folder():
            _ = self.session.append(sent, data, imap.Flags.seen) catch failure:
                recover 0
        try mail_db.unqueue(self.store, self.account.id, (str)queued)
        self.post("sent", queued)
        self.post("status", b"")

    ## The folder sent mail is filed in: the one marked \\Sent, else one named as
    ## servers without special-use name it.
    func sent_folder() -> str?:
        return self.role_folder(imap.MailboxFlags.sent, ["Sent", "Sent Items", "Sent Messages", "Sent Mail", "INBOX.Sent"])

    ## The folder drafts are kept in: the one marked \\Drafts, else one named Drafts.
    func drafts_folder() -> str?:
        return self.role_folder(imap.MailboxFlags.drafts, ["Drafts", "INBOX.Drafts", "Draft"])

    ## The folder with special-use `flag`, else the first named one of `names`.
    func role_folder(flag: imap.MailboxFlags, names: const str[]) -> str?:
        for folder in self.folders.view():
            if (folder.flags & (u32)flag) != 0:
                return folder.path
        for name in names:
            for folder in self.folders.view():
                if imap.same(folder.path.bytes, name.bytes):
                    return folder.path
        return none

    ## File the message queued at `queued` in the Drafts folder, marked as a draft.
    func save_draft(queued: const u8[]):
        self.file_draft(queued) catch failure:
            self.post("unsaved", queued, failure.message.bytes)
            recover ()

    func file_draft(queued: const u8[]) -> !:
        var message: Buffer
        defer message.destroy()
        if not try mail_db.read_queued(self.store, self.account.id, (str)queued, &message):
            error(imap.unsupported, "the queued draft is gone")
        let data = message.view()
        if self.folders.length() == 0:
            try self.list_folders()
        let drafts = self.drafts_folder() else error(imap.unsupported, "this account has no Drafts folder")
        _ = try self.session.append(drafts, data, imap.Flags.seen | imap.Flags.draft)
        try mail_db.unqueue(self.store, self.account.id, (str)queued)
        self.post("saved", queued)
        self.wants_full_sync = true

extend Engine:
    ## Ask the server which messages of folder `path` hold `query` in a header or the
    ## body, and say so: `found PATH UIDS`.
    func search(path: const u8[], query: const u8[]) -> !:
        _ = try self.select(path)
        self.post("status", b"Searching")
        let uids = try self.session.search_text((str)query)
        var list: Buffer
        defer list.destroy()
        try imap.write_set(uids, &list)
        self.post("found", path, list.view())
        self.post("status", b"")