"""The scheduled send job (SPEC §6.5). Fires ``UNDO_SECONDS`` after the user hits send. If the outbox row was cancelled in the meantime, it does nothing (no SMTP traffic). Otherwise: SMTP send, append to Sent (skipped for Gmail, which self-appends), harvest recipients into ``known_recipients`` (weight 3), and publish ``message.sent``. """ from __future__ import annotations import contextlib import logging import uuid from datetime import UTC, datetime from typing import Any from sqlalchemy import select from sqlalchemy.dialects.postgresql import insert as pg_insert from sqlalchemy.ext.asyncio import AsyncSession from app.db import session_scope from app.events import get_event_bus from app.indexer.indexer import persist_message from app.models import Account, Draft, KnownRecipient, Mailbox, Message, Outbox from app.outbox.attachments import load_attachments from app.outbox.mime_build import build_mime from app.outbox.service import delete_mirrored_draft_row from app.providers.base import RemoteMessage from app.search.factory import get_search_backend from app.sync.provider_factory import build_provider logger = logging.getLogger(__name__) def _is_gmail(account: Account) -> bool: host = str(account.imap_config.get("host", "")).lower() return "gmail.com" in host or "googlemail.com" in host async def _harvest_recipients(session: AsyncSession, user_id: uuid.UUID, emails: list[str]) -> None: now = datetime.now(UTC) for email in {e.lower() for e in emails if e}: stmt = pg_insert(KnownRecipient).values( user_id=user_id, email=email, name="", times_used=3, last_used_at=now ) stmt = stmt.on_conflict_do_update( index_elements=[KnownRecipient.user_id, KnownRecipient.email], set_={ "times_used": KnownRecipient.times_used + 3, # sent-to weight (SPEC §4) "last_used_at": stmt.excluded.last_used_at, }, ) await session.execute(stmt) async def _persist_sent_copy(user_id: uuid.UUID, account: Account, raw: bytes, uid: int) -> None: """Store the just-sent message in the DB (Sent mailbox) and notify the UI. No-op without a UIDPLUS append UID (uid <= 0); in that case a future Sent sync would pick it up. persist_message dedupes on (mailbox_id, uid). """ if uid <= 0: return async with session_scope() as session: sent_mb = await session.scalar( select(Mailbox).where(Mailbox.account_id == account.id, Mailbox.special_use == "sent") ) if sent_mb is None: return remote = RemoteMessage( uid=uid, raw=raw, flags=frozenset({"\\Seen"}), internal_date=datetime.now(UTC) ) result = await persist_message( session, user_id=user_id, account_id=account.id, mailbox_id=sent_mb.id, mailbox_special_use="sent", remote=remote, ) if result is None: return message_id = result.message.id thread_id = result.message.thread_id search_doc = result.search_doc await get_search_backend().index(search_doc) bus = get_event_bus() await bus.publish( "message.new", { "user_id": str(user_id), "account_id": str(account.id), "message_id": str(message_id), "thread_id": str(thread_id) if thread_id else None, }, ) if thread_id is not None: await bus.publish("thread.updated", {"user_id": str(user_id), "thread_id": str(thread_id)}) async def send_job(ctx: dict[str, Any], outbox_id: str) -> None: """Send a queued message unless it was cancelled during the undo window.""" oid = uuid.UUID(outbox_id) async with session_scope() as session: outbox = await session.get(Outbox, oid) if outbox is None or outbox.state != "undo_window": return # cancelled, or already handled -> no SMTP traffic outbox.state = "sending" draft = await session.get(Draft, outbox.draft_id) if draft is None: outbox.state = "failed" outbox.error = "draft missing" return account = await session.get(Account, draft.account_id) reply_to = ( await session.get(Message, draft.reply_to_message_id) if draft.reply_to_message_id else None ) if account is None: outbox.state = "failed" outbox.error = "account missing" return user_id = outbox.user_id attachments = await load_attachments(session, user_id, draft) transmit_raw, sent_raw, envelope_from, envelope_to = build_mime( account, draft, reply_to, attachments ) sent_path = await session.scalar( select(Mailbox.path).where( Mailbox.account_id == account.id, Mailbox.special_use == "sent" ) ) drafts_path = await session.scalar( select(Mailbox.path).where( Mailbox.account_id == account.id, Mailbox.special_use == "drafts" ) ) draft_imap_uid = draft.imap_uid gmail = _is_gmail(account) account_obj = account provider = build_provider(account_obj) appended_uid = 0 try: await provider.send(transmit_raw, envelope_from, envelope_to) if sent_path and not gmail: appended_uid = await provider.append(sent_path, sent_raw, frozenset({"\\Seen"})) # Remove the mirrored Drafts-folder copy now that it has been sent. if drafts_path and draft_imap_uid: with contextlib.suppress(Exception): await provider.delete_messages(drafts_path, [draft_imap_uid]) except Exception as exc: # noqa: BLE001 - record and notify, keep the draft async with session_scope() as session: ob = await session.get(Outbox, oid) if ob is not None: ob.state = "failed" ob.error = str(exc)[:500] await get_event_bus().publish( "outbox.state_changed", {"user_id": str(user_id), "outbox_id": str(oid), "state": "failed"}, ) logger.exception("send failed for outbox %s", oid) return finally: await provider.close() # Persist the sent copy (with Bcc) ourselves so it shows in Sent and threads # immediately; the periodic Sent poll would also catch it (dedup by UID). await _persist_sent_copy(user_id, account_obj, sent_raw, appended_uid) async with session_scope() as session: ob = await session.get(Outbox, oid) if ob is not None: ob.state = "sent" # The message left successfully: drop its draft so it no longer shows in # the Drafts folder (undo/cancel returns earlier, keeping the draft). draft_row = await session.get(Draft, draft.id) if draft_row is not None: await session.delete(draft_row) # Also drop the mirrored Drafts-folder copy's DB row (we expunged it on the # server above) so it doesn't resurface as a "remote" draft. if draft_imap_uid: await delete_mirrored_draft_row( session, account_id=account_obj.id, imap_uid=draft_imap_uid ) await _harvest_recipients(session, user_id, envelope_to) bus = get_event_bus() await bus.publish( "message.sent", {"user_id": str(user_id), "outbox_id": str(oid), "thread_id": str(draft.thread_id)}, ) await bus.publish( "outbox.state_changed", {"user_id": str(user_id), "outbox_id": str(oid), "state": "sent"}, )