Event canceled
' + '' + f"{_esc(summary)}
" + 'When
' + f'{_esc(when)}
' + f'{_esc(who)} has canceled this event.
' + "' + "You are receiving this message because you were a guest of this event. " + "Sent by Ultimo Calendar.
" + "" + ) + + +async def send_cancellation( + *, + user_id: uuid.UUID, + ical_uid: str, + summary: str, + dtstart: datetime, + dtend: datetime | None, + tz: str, + all_day: bool, + organizer: dict[str, str] | None, + attendees: list[dict[str, str]], + sequence: int, + notify_emails: set[str], + rrule: str | None = None, + recurrence_id: datetime | None = None, +) -> int: + """Tell guests the event is off: one iTIP CANCEL per guest, from the + organizer's mailbox — their calendar (Google, Outlook, Apple) removes it. + With ``recurrence_id`` only that occurrence. Returns how many were sent.""" + ics = build_ics( + ical_uid=ical_uid, + summary=summary, + description="", + location="", + dtstart=dtstart, + dtend=dtend, + organizer=organizer, + attendees=attendees, + sequence=sequence, + method="CANCEL", + rrule=rrule if recurrence_id is None else None, + recurrence_id=recurrence_id, + ) + when = format_when(dtstart, dtend, tz, all_day) + subject_when = _subject_when(dtstart, dtend, tz, all_day) + html = build_cancel_html(summary=summary or "(no title)", when=when, organizer=organizer) + text = f"Event canceled: {summary or '(no title)'}\n{when}\n" + sent = 0 + for a in attendees: + email = a.get("email") + if not email or email.lower() not in notify_emails: + continue + await _SDK.mail.send( + user_id, + to=[email], + subject=f"Canceled: {summary or '(no title)'} - {subject_when}", + html=html, + text=text, + from_email=(organizer or {}).get("email"), + ics=ics, + ics_method="CANCEL", + ics_filename="cancel.ics", + ) + sent += 1 + return sent diff --git a/plugins/webmail_plugin_calendar/webmail_plugin_calendar/router.py b/plugins/webmail_plugin_calendar/webmail_plugin_calendar/router.py index 8116be9..0c1f2d3 100644 --- a/plugins/webmail_plugin_calendar/webmail_plugin_calendar/router.py +++ b/plugins/webmail_plugin_calendar/webmail_plugin_calendar/router.py @@ -616,6 +616,7 @@ async def _send_invites_from( conference_url=body.conference_url, sequence=sequence, notify_emails=notify, + rrule=body.rrule, ) except Exception: # noqa: BLE001 - invitation delivery is best-effort _log.warning("calendar: failed to send invitations for %s", event_id, exc_info=True) @@ -808,15 +809,22 @@ async def delete_event( user_id: CurrentUserId, scope: str = Query("all"), occurrence: datetime | None = Query(None), -) -> dict[str, str]: + notify: bool = Query(False), +) -> dict[str, object]: """Delete an event. For recurring events ``scope`` selects what to remove: ``all`` (whole series), ``this`` (add an EXDATE for ``occurrence``), or - ``following`` (truncate the series just before ``occurrence``).""" + ``following`` (truncate the series just before ``occurrence``). + + With ``notify``, the guests of an event the user organizes are told: an iTIP + CANCEL (for ``this``, of that one occurrence), or for ``following`` the + shortened series — so their calendars drop it too.""" async with _SDK.session(user_id) as s: row = ( await s.execute( text( - "SELECT e.calendar_id, e.dtstart, e.rrule, c.kind " + "SELECT e.calendar_id, e.dtstart, e.dtend, e.rrule, e.ical_uid, e.sequence, " + "e.summary, e.description, e.location, e.all_day, e.tz, e.organizer, " + "e.attendees, e.conference_url, c.kind " "FROM plg_calendar_events e JOIN plg_calendar_calendars c " "ON c.id = e.calendar_id WHERE e.id = :id" ), @@ -837,7 +845,9 @@ async def delete_event( ) recurring = row["rrule"] is not None - if not recurring or scope == "all" or occurrence is None: + whole = not recurring or scope == "all" or occurrence is None + new_rrule: str | None = None + if whole: await s.execute(text(remove_sql), {"id": str(event_id)}) elif scope == "this": await s.execute( @@ -852,6 +862,7 @@ async def delete_event( if occ <= _aware(row["dtstart"]): # Truncating from the first occurrence removes everything. await s.execute(text(remove_sql), {"id": str(event_id)}) + whole = True else: until = (occ - timedelta(seconds=1)).astimezone(UTC).strftime("%Y%m%dT%H%M%SZ") trimmed = _strip_recurrence_end(str(row["rrule"])) @@ -862,9 +873,75 @@ async def delete_event( ) else: raise HTTPException(status_code=400, detail="bad_scope") + if not whole: # the event lives on, changed: guests' copies must yield to it + await s.execute( + text("UPDATE plg_calendar_events SET sequence = sequence + 1 WHERE id = :id"), + {"id": str(event_id)}, + ) if row["kind"] == "caldav": await _enqueue_dav_sync(row["calendar_id"]) - return {"status": "ok"} + notified = 0 + if notify: + notified = await _notify_guests_of_deletion( + user_id, event_id, dict(row), whole=whole, scope=scope, + occurrence=_aware(occurrence) if occurrence else None, new_rrule=new_rrule, + ) + return {"status": "ok", "notified": notified} + + +async def _notify_guests_of_deletion( + user_id: uuid.UUID, + event_id: uuid.UUID, + row: dict[str, Any], + *, + whole: bool, + scope: str, + occurrence: datetime | None, + new_rrule: str | None, +) -> int: + """Tell the guests of a deleted (or shortened) event the user organized. + Best-effort: the deletion stands whatever the mail does.""" + mine = {e.lower() for _a, e, _n in await _SDK.accounts.of_user(user_id)} + organizer = row["organizer"] or None + if organizer and str(organizer.get("email", "")).lower() not in mine: + return 0 # someone else's event: not the user's to cancel for its guests + attendees = list(row["attendees"] or []) + guests = { + str(a.get("email", "")).lower() + for a in attendees + if a.get("email") and str(a["email"]).lower() not in mine + } + if not guests: + return 0 + sequence = int(row["sequence"] or 0) + 1 + start, end = _aware(row["dtstart"]), _aware(row["dtend"]) if row["dtend"] else None + try: + if scope == "following" and not whole and new_rrule: + # Not a cancellation: the series ends earlier — an updated invitation. + await invites.send_invites( + user_id=user_id, event_id=event_id, ical_uid=row["ical_uid"], + summary=row["summary"], description=row["description"], + location=row["location"], dtstart=start, dtend=end, tz=row["tz"], + all_day=row["all_day"], organizer=organizer, attendees=attendees, + conference_url=row["conference_url"] or "", sequence=sequence, + notify_emails=guests, rrule=new_rrule, + ) + return len(guests) + one = scope == "this" and not whole and occurrence is not None + if one: # just that occurrence: its own times + assert occurrence is not None + length = (end - start) if end else timedelta(hours=1) + start, end = occurrence, occurrence + length + return await invites.send_cancellation( + user_id=user_id, ical_uid=row["ical_uid"], summary=row["summary"], + dtstart=start, dtend=end, tz=row["tz"], all_day=row["all_day"], + organizer=organizer, attendees=attendees, sequence=sequence, + notify_emails=guests, rrule=row["rrule"], + recurrence_id=occurrence if one else None, + ) + except Exception: # noqa: BLE001 - the event is deleted either way + _log.warning("calendar: telling guests of %s failed", event_id, exc_info=True) + return 0 # --- public read-only .ics feed (published calendars; no login) --------------- @@ -1000,7 +1077,8 @@ async def _invited_copy(s: AsyncSession, inv: dict[str, Any]) -> dict[str, Any] row = ( await s.execute( text( - "SELECT e.id, e.calendar_id, e.sequence, e.my_partstat, c.kind, c.name " + "SELECT e.id, e.calendar_id, e.sequence, e.my_partstat, e.organizer, e.rrule, " + "c.kind, c.name " "FROM plg_calendar_events e JOIN plg_calendar_calendars c ON c.id = e.calendar_id " "WHERE e.ical_uid = :uid AND e.recurrence_id IS NOT DISTINCT FROM :rid " "AND e.dav_deleted = false ORDER BY e.sequence DESC LIMIT 1" @@ -1028,12 +1106,203 @@ async def _invitation_calendar(s: AsyncSession, user_id: uuid.UUID) -> uuid.UUID return uuid.UUID(writable[0]) +def _cancelled_key(inv: dict[str, Any]) -> str: + rid = inv["recurrence_id"].isoformat() if inv["recurrence_id"] else "" + return f"cancelled:{inv['uid']}:{rid}" + + +async def apply_cancellation(user_id: uuid.UUID, inv: dict[str, Any]) -> str: + """Apply an organizer's cancellation (iTIP CANCEL) to the user's calendar. + + Only a genuine one: the same event, sent by that event's own organizer, and + not older than the version in the calendar — anyone can send an email that + claims to cancel a meeting. A cancelled occurrence of a series becomes an + EXDATE. Returns ``removed`` | ``not_in_calendar`` | ``not_organizer`` | + ``outdated``. Applied whatever Settings → Invitations say (the one exception). + Idempotent: safe from both the new-mail hook and the card. + """ + kv = _SDK.kv(user_id) + dav_calendar: str | None = None + async with _SDK.session(user_id) as s: + target = await _invited_copy(s, inv) + occurrence_of_series = False + if target is None and inv["recurrence_id"] is not None: + # One occurrence of a series held as a single row: cancel that date. + target = await _invited_copy(s, {**inv, "recurrence_id": None}) + occurrence_of_series = target is not None and target["rrule"] is not None + if target is not None and not occurrence_of_series: + target = None + if target is None: + return "removed" if await kv.get(_cancelled_key(inv)) else "not_in_calendar" + stored = target["organizer"] or {} + sender = inv["organizer"] or {} + if str(stored.get("email", "")).lower() != str(sender.get("email", "")).lower(): + return "not_organizer" + if inv["sequence"] < int(target["sequence"] or 0): + return "outdated" + if occurrence_of_series: + await s.execute( + text( + "UPDATE plg_calendar_events SET exdates = array_append(exdates, :occ) " + "WHERE id = :id AND NOT (:occ = ANY(exdates))" + ), + {"occ": inv["recurrence_id"], "id": str(target["id"])}, + ) + else: + await s.execute( + text( + "UPDATE plg_calendar_events SET dav_deleted = true WHERE id = :id" + if target["kind"] == "caldav" + else "DELETE FROM plg_calendar_events WHERE id = :id" + ), + {"id": str(target["id"])}, + ) + if target["kind"] == "caldav": + dav_calendar = str(target["calendar_id"]) + if dav_calendar: + await _enqueue_dav_sync(uuid.UUID(dav_calendar)) + await kv.set(_cancelled_key(inv), True) + _log.info("calendar: applied the organizer's cancellation of %s", inv["uid"]) + return "removed" + + +# --- Settings → Calendars → Invitations: what an emailed event does on its own ----- + + +async def _invitation_settings(user_id: uuid.UUID) -> dict[str, Any]: + s = await _SDK.accounts.settings_of(user_id) + policy = str(s.get("invitation_policy") or "none") + return { + # none: wait for the user · update_only: keep added events current (changes, + # cancellations) · add_update: that, and add new invitations too. + "policy": policy if policy in ("none", "update_only", "add_update") else "none", + "from": str(s.get("invitation_from") or "contacts"), + "file": bool(s.get("invitation_file", False)), + } + + +async def _is_contact(s: AsyncSession, email: str) -> bool: + """Whether ``email`` is in the user's contacts (Settings: "Add new events + from My contacts"). No contacts plugin, no contacts.""" + try: + async with s.begin_nested(): # a missing table must not spoil the transaction + row = await s.execute( + text( + "SELECT 1 FROM plg_contacts_contacts WHERE lower(default_email) = :e " + "OR EXISTS (SELECT 1 FROM jsonb_array_elements(emails) x " + " WHERE lower(x->>'value') = :e) LIMIT 1" + ), + {"e": email.lower()}, + ) + return row.first() is not None + except Exception: # noqa: BLE001 + return False + + +async def apply_update( + user_id: uuid.UUID, inv: dict[str, Any], ics: str, message_id: uuid.UUID +) -> str: + """An organizer's changed invitation (new time, place, …) for an event the + user has: bring it up to date, keeping the user's own answer. Only from that + event's organizer, and only newer. ``updated`` | ``unchanged`` | + ``not_in_calendar`` | ``not_organizer``.""" + dav_calendar: str | None = None + async with _SDK.session(user_id) as s: + copy = await _invited_copy(s, inv) + if copy is None: + return "not_in_calendar" + stored = copy["organizer"] or {} + sender = inv["organizer"] or {} + if str(stored.get("email", "")).lower() != str(sender.get("email", "")).lower(): + return "not_organizer" + if inv["sequence"] <= int(copy["sequence"] or 0): + return "unchanged" + me = await _me(user_id, inv) + mine = copy["my_partstat"] or "needs-action" + attendees = [ + {**a, "partstat": mine} if me and a["email"] == me["email"] else a + for a in inv["attendees"] + ] + dav_calendar = await _store_invited_event( + s, user_id, inv, ics, message_id, attendees, mine, copy + ) + if dav_calendar: + await _enqueue_dav_sync(uuid.UUID(dav_calendar)) + return "updated" + + +async def _auto_add( + user_id: uuid.UUID, inv: dict[str, Any], ics: str, message_id: uuid.UUID, from_: str +) -> str: + """A new invitation, added to the calendar as it arrives — not yet answered + (the card still asks). ``added`` or why not.""" + me = await _me(user_id, inv) + if me is None: + return "not_invited" + organizer = (inv["organizer"] or {}).get("email", "") + if not organizer or organizer == me["email"]: + return "own_event" + if await _SDK.kv(user_id).get(_declined_key(inv)): + return "declined" + dav_calendar: str | None = None + async with _SDK.session(user_id) as s: + if from_ == "contacts" and not await _is_contact(s, organizer): + return "not_from_contact" + if await _invited_copy(s, inv) is not None: + return "exists" + dav_calendar = await _store_invited_event( + s, user_id, inv, ics, message_id, inv["attendees"], "needs-action", None + ) + if dav_calendar: + await _enqueue_dav_sync(uuid.UUID(dav_calendar)) + return "added" + + +async def process_incoming(user_id: uuid.UUID, message_id: uuid.UUID) -> str | None: + """New mail with an invitation, cancellation or change: do what Settings → + Calendars → Invitations says (nothing, by default). Returns what changed in + the calendar — ``added`` | ``updated`` | ``removed`` — or None.""" + try: + ics, inv = await _invitation(user_id, message_id) + except HTTPException: + return None + rules = await _invitation_settings(user_id) + outcome: str | None = None + if inv["method"] == "CANCEL": + # The one exception to the setting: an organizer's cancellation always + # takes the event out — an event that is off has no business staying. + outcome = await apply_cancellation(user_id, inv) + elif rules["policy"] == "none": + return None + elif inv["method"] == "REQUEST": + outcome = await apply_update(user_id, inv, ics, message_id) + if outcome == "not_in_calendar" and rules["policy"] == "add_update": + outcome = await _auto_add(user_id, inv, ics, message_id, rules["from"]) + if outcome not in ("added", "updated", "removed"): + return None + if rules["file"]: # "Also mark the message as read and file it" + await _SDK.actions.set_flags(user_id, message_id, add=["\\Seen"]) + await _SDK.actions.move_to_special(user_id, message_id, "archive") + _log.info("calendar: invitation email %s → %s", message_id, outcome) + return outcome + + def _brief(ev: dict[str, Any]) -> dict[str, Any]: return {k: ev.get(k) for k in ("summary", "start", "end", "all_day", "color")} async def _invitation_view(user_id: uuid.UUID, message_id: uuid.UUID) -> dict[str, Any]: - _ics, inv = await _invitation(user_id, message_id) + ics, inv = await _invitation(user_id, message_id) + # Normally already applied when the email arrived (hook.py); this catches up + # on mail from before that. Cancellations always; changes to an event only + # when Settings allow automatic updates. + rules = await _invitation_settings(user_id) + automatic = rules["policy"] != "none" + cancellation = None + if inv["method"] == "CANCEL": + cancellation = await apply_cancellation(user_id, inv) + elif automatic and inv["method"] == "REQUEST": + await apply_update(user_id, inv, ics, message_id) me = await _me(user_id, inv) start, end = inv["dtstart"], inv["dtend"] settings = await _SDK.accounts.settings_of(user_id) @@ -1101,6 +1370,13 @@ async def _invitation_view(user_id: uuid.UUID, message_id: uuid.UUID) -> dict[st "outdated": bool(copy and int(copy["sequence"]) > inv["sequence"]), "conflicts": conflicts, "previous": _brief(earlier[-1]) if earlier and not conflicts else None, + # For a cancellation: removed | not_in_calendar | not_organizer | outdated. + "cancellation": cancellation, + # The organizer changed the event since the calendar's copy (answer again + # to take the change — automatic only when Settings allow it). + "update_pending": bool( + copy and inv["method"] == "REQUEST" and inv["sequence"] > int(copy["sequence"]) + ), } @@ -1119,6 +1395,77 @@ def _default_reminders(settings: dict[str, Any]) -> list[int]: return out +async def _store_invited_event( + s: AsyncSession, + user_id: uuid.UUID, + inv: dict[str, Any], + ics: str, + message_id: uuid.UUID, + attendees: list[dict[str, Any]], + partstat: str, + copy: dict[str, Any] | None, +) -> str | None: + """Write an invitation's event into the calendar: update ``copy`` when the + calendar holds it, else add it to the invitations calendar. Returns the + calendar id when it is a CalDAV one (to be pushed), else None.""" + fields = { + "sum": inv["summary"], + "desc": inv["description"], + "loc": inv["location"], + "start": inv["dtstart"], + "end": inv["dtend"], + "allday": inv["all_day"], + "tz": inv["tz"], + "rrule": inv["rrule"], + "rid": inv["recurrence_id"], + "status": "cancelled" if inv["status"] == "cancelled" else "confirmed", + "org": json.dumps(inv["organizer"]) if inv["organizer"] else None, + "att": json.dumps(attendees), + "mine": partstat, + "seq": inv["sequence"], + "raw": ics, + "msg": str(message_id), + "conf": inv["conference_url"], + "showas": inv["show_as"], + } + if copy is not None: + await s.execute( + text( + "UPDATE plg_calendar_events SET summary = :sum, description = :desc, " + "location = :loc, dtstart = :start, dtend = :end, all_day = :allday, " + "tz = :tz, rrule = :rrule, status = :status, " + "organizer = CAST(:org AS jsonb), attendees = CAST(:att AS jsonb), " + "my_partstat = :mine, sequence = :seq, raw_ical = :raw, " + "origin_message_id = :msg, conference_url = :conf, show_as = :showas " + "WHERE id = :id" + ), + {**fields, "id": str(copy["id"])}, + ) + return str(copy["calendar_id"]) if copy["kind"] == "caldav" else None + calendar_id = await _invitation_calendar(s, user_id) + settings = await _SDK.accounts.settings_of(user_id) + await s.execute( + text( + "INSERT INTO plg_calendar_events " + "(user_id, calendar_id, ical_uid, summary, description, location, " + " dtstart, dtend, all_day, tz, rrule, recurrence_id, status, organizer, " + " attendees, my_partstat, sequence, raw_ical, origin_message_id, " + " conference_url, show_as, reminders) " + "VALUES (:u, :cal, :uid, :sum, :desc, :loc, :start, :end, :allday, :tz, " + " :rrule, :rid, :status, CAST(:org AS jsonb), CAST(:att AS jsonb), :mine, " + " :seq, :raw, :msg, :conf, :showas, :rem)" + ), + { + **fields, + "u": str(user_id), + "cal": str(calendar_id), + "uid": inv["uid"], + "rem": _default_reminders(settings), + }, + ) + return str(calendar_id) if await _is_caldav(s, calendar_id) else None + + @router.post("/invitations/{message_id}/respond", dependencies=[Depends(require_csrf)]) async def respond_to_invitation( message_id: uuid.UUID, body: InvitationAnswer, user_id: CurrentUserId @@ -1159,64 +1506,9 @@ async def respond_to_invitation( ) dav_calendar = str(copy["calendar_id"]) if copy["kind"] == "caldav" else None else: - fields = { - "sum": inv["summary"], - "desc": inv["description"], - "loc": inv["location"], - "start": inv["dtstart"], - "end": inv["dtend"], - "allday": inv["all_day"], - "tz": inv["tz"], - "rrule": inv["rrule"], - "rid": inv["recurrence_id"], - "status": "cancelled" if inv["status"] == "cancelled" else "confirmed", - "org": json.dumps(inv["organizer"]) if inv["organizer"] else None, - "att": json.dumps(attendees), - "mine": body.response, - "seq": inv["sequence"], - "raw": ics, - "msg": str(message_id), - "conf": inv["conference_url"], - "showas": inv["show_as"], - } - if copy is not None: - await s.execute( - text( - "UPDATE plg_calendar_events SET summary = :sum, description = :desc, " - "location = :loc, dtstart = :start, dtend = :end, all_day = :allday, " - "tz = :tz, rrule = :rrule, status = :status, " - "organizer = CAST(:org AS jsonb), attendees = CAST(:att AS jsonb), " - "my_partstat = :mine, sequence = :seq, raw_ical = :raw, " - "origin_message_id = :msg, conference_url = :conf, show_as = :showas " - "WHERE id = :id" - ), - {**fields, "id": str(copy["id"])}, - ) - dav_calendar = str(copy["calendar_id"]) if copy["kind"] == "caldav" else None - else: - calendar_id = await _invitation_calendar(s, user_id) - settings = await _SDK.accounts.settings_of(user_id) - await s.execute( - text( - "INSERT INTO plg_calendar_events " - "(user_id, calendar_id, ical_uid, summary, description, location, " - " dtstart, dtend, all_day, tz, rrule, recurrence_id, status, organizer, " - " attendees, my_partstat, sequence, raw_ical, origin_message_id, " - " conference_url, show_as, reminders) " - "VALUES (:u, :cal, :uid, :sum, :desc, :loc, :start, :end, :allday, :tz, " - " :rrule, :rid, :status, CAST(:org AS jsonb), CAST(:att AS jsonb), :mine, " - " :seq, :raw, :msg, :conf, :showas, :rem)" - ), - { - **fields, - "u": str(user_id), - "cal": str(calendar_id), - "uid": inv["uid"], - "rem": _default_reminders(settings), - }, - ) - if await _is_caldav(s, calendar_id): - dav_calendar = str(calendar_id) + dav_calendar = await _store_invited_event( + s, user_id, inv, ics, message_id, attendees, body.response, copy + ) if dav_calendar: await _enqueue_dav_sync(uuid.UUID(dav_calendar)) kv = _SDK.kv(user_id) @@ -1252,28 +1544,6 @@ async def respond_to_invitation( return view -@router.post("/invitations/{message_id}/remove", dependencies=[Depends(require_csrf)]) -async def remove_cancelled_event(message_id: uuid.UUID, user_id: CurrentUserId) -> dict[str, Any]: - """The organizer cancelled the event: take it out of the calendar.""" - _ics, inv = await _invitation(user_id, message_id) - dav_calendar: str | None = None - async with _SDK.session(user_id) as s: - copy = await _invited_copy(s, inv) - if copy is not None: - await s.execute( - text( - "UPDATE plg_calendar_events SET dav_deleted = true WHERE id = :id" - if copy["kind"] == "caldav" - else "DELETE FROM plg_calendar_events WHERE id = :id" - ), - {"id": str(copy["id"])}, - ) - dav_calendar = str(copy["calendar_id"]) if copy["kind"] == "caldav" else None - if dav_calendar: - await _enqueue_dav_sync(uuid.UUID(dav_calendar)) - return await _invitation_view(user_id, message_id) - - # --- bundle ------------------------------------------------------------------ @router.get("/ui/{filename}") diff --git a/plugins/webmail_plugin_calendar/webmail_plugin_calendar/ui/invite.js b/plugins/webmail_plugin_calendar/webmail_plugin_calendar/ui/invite.js index f4f3d54..98e6934 100644 --- a/plugins/webmail_plugin_calendar/webmail_plugin_calendar/ui/invite.js +++ b/plugins/webmail_plugin_calendar/webmail_plugin_calendar/ui/invite.js @@ -37,6 +37,7 @@ const CSS = ` .cal-inv-btn:disabled { opacity: .6; cursor: default; } .cal-inv-note { font-size: 12px; color: rgb(var(--app-muted)); } .cal-inv-note.err { color: rgb(220 38 38); } +.cal-inv-note.done { font-size: 14px; color: rgb(var(--app-fg)); } .cal-inv-badge { display: inline-block; margin-left: 8px; padding: 1px 7px; border-radius: 6px; font-size: 11px; font-weight: 700; text-transform: uppercase; vertical-align: 2px; background: rgb(220 38 38 / .15); color: rgb(220 38 38); } `; @@ -141,9 +142,14 @@ function render(el, inv, h12, note) { : ""; let actions = ""; if (cancelled) { - actions = inv.in_calendar - ? '' - : 'Would you like to inform the participants that this event is canceled?
+${n === 1 ? "1 guest" : `${n} guests`} will get an email their calendar understands.
+