@acms-subir/core 0.3.46 → 0.3.48

package/src/lib/calendar/filter.ts

@@ -0,0 +1,140 @@
+// Which events a calendar view shows, read from its address. The /calendar
+// page, embeds, /api/v1/events, /api/calendar/events, the subscribe feeds
+// and the TV display all take the same parameters and apply the same rules:
+//   cal=youth,events   only these calendars (slugs); `calendar` is an alias
+//   tag=Class          only events with one of these tags
+//   notag=Class        never events with any of these; `excludeTag` is an alias
+//   room=chapel        only events held in one of these rooms (resource slugs)
+// Each can repeat (tag=a&tag=b) or be comma-separated (tag=a,b). A list
+// matches any of its values; different parameters must all match. Tags keep
+// the hasTag rules (a name in any case, or its slug); internal "#" tags only
+// match with allowPrivate. Publicly, private calendars and rooms not shown on
+// public events resolve exactly like slugs that don't exist, so a link can't
+// probe for them.
+import { hasTag, publicTags, type CalEvent, type Calendar, type Resource } from '../schema';
+
+export interface EventFilter {
+  cal: string[];
+  tag: string[];
+  notag: string[];
+  room: string[];
+}
+
+export const NO_FILTER: EventFilter = Object.freeze({ cal: [], tag: [], notag: [], room: [] }) as EventFilter;
+
+const NAMES: Record<keyof EventFilter, string[]> = {
+  cal: ['cal', 'calendar'],
+  tag: ['tag'],
+  notag: ['notag', 'excludeTag'],
+  room: ['room'],
+};
+const MAX_VALUES = 20;
+const MAX_LENGTH = 100;
+
+/** the filter in an address's query (`Astro.url.searchParams`, `url.searchParams`) */
+export function readEventFilter(params: URLSearchParams): EventFilter {
+  const read = (names: string[]) => {
+    const out: string[] = [];
+    for (const name of names) for (const raw of params.getAll(name)) for (const part of raw.split(',')) {
+      const v = part.trim().slice(0, MAX_LENGTH);
+      if (v && out.length < MAX_VALUES && !out.some((o) => o.toLowerCase() === v.toLowerCase())) out.push(v);
+    }
+    return out;
+  };
+  return { cal: read(NAMES.cal), tag: read(NAMES.tag), notag: read(NAMES.notag), room: read(NAMES.room) };
+}
+
+export const hasEventFilter = (f: EventFilter) => f.cal.length + f.tag.length + f.notag.length + f.room.length > 0;
+
+/**
+ * The filter as a query string without the "?" ('' when empty), in the
+ * canonical names with comma-separated values: "cal=events&notag=Class".
+ * For links, subscribe feeds and API calls that should show the same events.
+ */
+export function eventFilterQuery(f: EventFilter): string {
+  return (Object.keys(NAMES) as (keyof EventFilter)[])
+    .filter((k) => f[k].length)
+    .map((k) => `${k}=${f[k].map(encodeURIComponent).join(',')}`)
+    .join('&');
+}
+
+export interface ResolvedEventFilter {
+  /** null: no calendar filter; [] when `cal` was given but none resolved (the view is then empty) */
+  calendarIds: string[] | null;
+  /** null: no room filter; [] when `room` was given but none resolved */
+  roomIds: string[] | null;
+  /** the calendars and rooms that resolved, in the order the address gave them */
+  calendars: Calendar[];
+  rooms: Resource[];
+  tag: string[];
+  notag: string[];
+  /** internal "#" tags match (allowPrivate) */
+  internal: boolean;
+  /** some `cal` or `room` value didn't resolve (unknown, private or hidden) */
+  unknown: boolean;
+}
+
+
+/**
+ * Turns slugs into ids. Publicly, unlisted calendars resolve (as a direct
+ * `?cal=` link always has) but private ones don't, and only rooms shown on
+ * public events resolve. allowPrivate (API keys with events:read, saved
+ * screens) resolves every calendar and room and lets "#" tags match.
+ */
+export function resolveEventFilter(
+  f: EventFilter,
+  ctx: { calendars: Calendar[]; resources?: Resource[]; allowPrivate?: boolean }
+): ResolvedEventFilter {
+  const allowPrivate = ctx.allowPrivate ?? false;
+  const pick = <T extends { id: string; slug: string }>(slugs: string[], items: T[], visible: (item: T) => boolean) => {
+    const found: T[] = [];
+    for (const s of slugs) {
+      const item = items.find((i) => i.slug === s.toLowerCase() && visible(i));
+      if (item && !found.includes(item)) found.push(item);
+    }
+    return found;
+  };
+  const calendars = pick(f.cal, ctx.calendars, (c) => allowPrivate || c.visibility !== 'private');
+  const rooms = pick(f.room, ctx.resources ?? [], (r) => allowPrivate || r.showOnEvents);
+  return {
+    calendarIds: f.cal.length ? calendars.map((c) => c.id) : null,
+    roomIds: f.room.length ? rooms.map((r) => r.id) : null,
+    calendars, rooms,
+    tag: f.tag, notag: f.notag,
+    internal: allowPrivate,
+    unknown: calendars.length < f.cal.length || rooms.length < f.room.length,
+  };
+}
+
+/** `tag` (any of them, when given) and no `notag`; "#" tags only count when internal */
+export function tagsMatch(f: Pick<EventFilter, 'tag' | 'notag'>, names: string[], opts: { internal?: boolean } = {}): boolean {
+  const shown = opts.internal ? names : publicTags(names);
+  return (!f.tag.length || f.tag.some((t) => hasTag(shown, t))) && !f.notag.some((t) => hasTag(shown, t));
+}
+
+const overlaps = (wanted: string[] | null, have: string[]) => wanted === null || have.some((id) => wanted.includes(id));
+
+/**
+ * Does one event pass? `roomIds` are the rooms the date holds: the event's
+ * room hold unless a moved date changed them. Visibility (drafts, private
+ * calendars) is the caller's job; this only applies the filter.
+ */
+export function eventMatches(r: ResolvedEventFilter, e: Pick<CalEvent, 'calendarIds' | 'tags' | 'roomHold'>, roomIds: string[] = e.roomHold.resourceIds): boolean {
+  return overlaps(r.calendarIds, e.calendarIds) && overlaps(r.roomIds, roomIds) && tagsMatch(r, e.tags, { internal: r.internal });
+}
+
+/** eventMatches for one occurrence, using the rooms that date holds */
+export function occurrenceMatches(r: ResolvedEventFilter, o: { event: Pick<CalEvent, 'calendarIds' | 'tags' | 'roomHold'>; roomIds?: string[] }): boolean {
+  return eventMatches(r, o.event, o.roomIds ?? o.event.roomHold.resourceIds);
+}
+
+/**
+ * Entries without an event (feed calendars, Reserved blocks) have no tags:
+ * `tag` leaves them out and `notag` keeps them. A Reserved block passes a
+ * room filter for its own room; feed entries never do.
+ */
+export function untaggedMatches(r: ResolvedEventFilter, opts: { calendarId?: string; roomId?: string } = {}): boolean {
+  if (r.tag.length) return false;
+  if (r.roomIds !== null && !(opts.roomId && r.roomIds.includes(opts.roomId))) return false;
+  return r.calendarIds === null || Boolean(opts.calendarId && r.calendarIds.includes(opts.calendarId));
+}

package/src/lib/calendar/ics-write.ts

@@ -5,7 +5,8 @@
 // across DST — Google, Apple and Outlook all resolve IANA zone ids. All-day
 // events are VALUE=DATE with the RFC's exclusive DTEND. A single cancelled
 // date of a series is an override VEVENT (same UID, RECURRENCE-ID) with
-// STATUS:CANCELLED, so calendar apps strike that one date.
+// STATUS:CANCELLED, so calendar apps strike that one date; a moved date is an
+// override with its new DTSTART/DTEND (and its own place), so they show it there.
 import type { CalEvent, Calendar } from '../schema';
 import { addWallDays, eventInstants, eventTimeZone, findOccurrence, locationLine, parseWall, type Wall } from './events';
 import { zonedToUtc } from './ics';
@@ -103,10 +104,32 @@ export function eventToVevent(e: CalEvent, siteTz: string, opts: FeedOptions): s
   if (e.cancelled) lines.push('STATUS:CANCELLED');
   const stamps = [`LAST-MODIFIED:${utcStamp(e.updatedAt)}`, `SEQUENCE:${Math.max(0, Math.floor((e.updatedAt - e.createdAt) / 1000)) % 2147483647}`];
   lines.push(...stamps, 'END:VEVENT');
-  if (rule && !e.cancelled) lines.push(...cancelledOverrides(e, s, en, tz, siteTz, url, opts, stamps));
+  if (rule && !e.cancelled) lines.push(...cancelledOverrides(e, s, en, tz, siteTz, url, opts, stamps), ...movedOverrides(e, tz, siteTz, url, opts, stamps));
   return lines;
 }
 
+// one override per moved date that is still part of the series (and not
+// cancelled): the same date (RECURRENCE-ID) at its new time
+function movedOverrides(e: CalEvent, tz: string, siteTz: string, url: string, opts: FeedOptions, stamps: string[]): string[] {
+  const out: string[] = [];
+  const cancelled = new Set(e.cancelledDates ?? []);
+  for (const key of Object.keys(e.movedDates ?? {}).sort()) {
+    const m = e.movedDates[key];
+    const w = parseWall(key), ms = parseWall(m.start), me = parseWall(m.end) ?? ms;
+    if (cancelled.has(key) || !w || !ms || !me || !findOccurrence(e, key, { timezone: siteTz }, siteTz || 'UTC')) continue;
+    const when = e.allDay
+      ? [`RECURRENCE-ID;VALUE=DATE:${dateValue(w)}`, `DTSTART;VALUE=DATE:${dateValue(ms)}`, `DTEND;VALUE=DATE:${dateValue(addWallDays({ ...me, dateOnly: true }, 1))}`]
+      : [`RECURRENCE-ID;TZID=${tz}:${localValue(w)}`, `DTSTART;TZID=${tz}:${localValue(ms)}`, `DTEND;TZID=${tz}:${localValue(me)}`];
+    const place = m.location ?? e.location;
+    const loc = locationLine(place);
+    const desc = [m.note, e.excerpt, place.url && place.url !== loc ? place.url : '', url].filter(Boolean).join('\n\n');
+    out.push('BEGIN:VEVENT', `UID:${e.id}@${opts.host}`, `DTSTAMP:${utcStamp(opts.now ?? Date.now())}`, ...when,
+      `SUMMARY:${escapeText(e.title || 'Untitled event')}`, ...(loc ? [`LOCATION:${escapeText(loc)}`] : []),
+      `DESCRIPTION:${escapeText(desc)}`, `URL:${url}`, ...stamps, 'END:VEVENT');
+  }
+  return out;
+}
+
 // one override per cancelled date that is still part of the series (keys
 // left behind by a moved series are ignored)
 function cancelledOverrides(e: CalEvent, s: Wall, en: Wall, tz: string, siteTz: string, url: string, opts: FeedOptions, stamps: string[]): string[] {

package/src/lib/calendar/moves.ts

@@ -0,0 +1,291 @@
+// Moved dates (CalEvent.movedDates): one date of a repeating event at another
+// time, and maybe in other rooms or at another place, keeping what makes it
+// that date: its key, its RSVPs (they move with it, and people get the "new
+// time" email in their language with their cancel link), its hosts and its
+// page. Moving and moving back apply at once, even on a published event, and
+// leave staged edits alone, like cancelling a date. A date is moved or
+// cancelled, never both: cancelling a moved date drops the move.
+//
+// These check who is acting, so the admin, the built-in member pages and a
+// site's own code (@acms-subir/core/server) share the rules:
+// - staff ("Create and edit content") and GOOGLE_SYNC (a calendar sync acting
+//   with staff rights) may move any date. A room taken at the new time is
+//   returned as a warning, since the change may already have happened
+//   elsewhere;
+// - a host of the event may move its dates while the rooms are free; a taken
+//   room refuses the move (409), and staff are emailed about each host move.
+// `quiet` skips the app notice and the staff email (a sync catching up); the
+// RSVP emails always go, because those people's own booking changed.
+import type { ContentRepository } from '../repo/types';
+import { EventLocation, type CalEvent, type MovedDate } from '../schema';
+import { ApiError } from '../api';
+import { eventSideEffects, type SaveHooks } from '../content-service';
+import { addWallDays, addWallMinutes, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence } from './events';
+import { holdsFromEvents, roomBusy, type BusySlot } from '../booking/holds';
+import { kickEmail } from '../email/service';
+import { waitUntilFrom } from '../webhooks';
+import { MEMBERS } from './members-config';
+import { siteLocale } from '../dates';
+
+/** The actor for a calendar sync (e.g. Google): staff rights, room clashes only warn. */
+export const GOOGLE_SYNC = 'google-sync';
+/** Who is acting: a person (currentUser() from @acms-subir/core/server fits) or the sync. */
+export type MoveActor = { id: string; can(permission: string): boolean } | typeof GOOGLE_SYNC;
+
+export interface MoveInput {
+  /** the new start, wall-clock in the event's timezone: YYYY-MM-DDTHH:mm, or YYYY-MM-DD for an all-day event */
+  start: string;
+  /** the new end in the same form (all-day: the last day, inclusive); default: the date keeps its length */
+  end?: string;
+  /** the rooms that date holds instead (Resource ids); omit to keep its current rooms */
+  roomIds?: string[];
+  /** that date's place instead; null = the event's place again; omit to keep its current one */
+  location?: Partial<EventLocation> | null;
+  /** a public note shown with the date ("Moved for the youth retreat"); omit to keep the current one */
+  note?: string;
+}
+export interface MoveOptions {
+  /** no app notice and no staff email (a sync catching up); RSVP emails still go */
+  quiet?: boolean;
+  now?: number;
+}
+export interface MoveResult {
+  event: CalEvent;
+  /** what else takes the date's rooms at its new time (warnings for staff; hosts are refused instead) */
+  clashes: BusySlot[];
+  /** false: the date already was exactly so, and nothing was written, sent or emailed */
+  changed: boolean;
+}
+
+/**
+ * Why a move was refused (error.code, with error.status): one-off (not a
+ * repeating event), cancelled-event, not-a-date (the key isn't one of its
+ * dates), cancelled-date, started (the date has started or passed),
+ * original-passed (moving back to a time that has passed), past (the new time
+ * has passed), bad-time, room-taken (a host, 409).
+ */
+export type MoveRefusal = 'one-off' | 'cancelled-event' | 'not-a-date' | 'cancelled-date' | 'started' | 'original-passed' | 'past' | 'bad-time' | 'room-taken';
+const refuse = (status: number, code: MoveRefusal, message: string) => Object.assign(new ApiError(status, message), { code });
+
+const DAY = 86_400_000;
+const NOTE_MAX = 500;
+
+type Role = 'staff' | 'host';
+function roleOf(actor: MoveActor | null, e: CalEvent): Role {
+  if (actor === GOOGLE_SYNC) return 'staff';
+  if (!actor) throw new ApiError(401, 'Sign in to continue.');
+  if (actor.can('content.edit')) return 'staff';
+  if (e.hostIds.includes(actor.id)) return 'host';
+  throw new ApiError(404, 'Event not found.');
+}
+const actorId = (actor: MoveActor) => (actor === GOOGLE_SYNC ? GOOGLE_SYNC : actor.id);
+
+async function load(repo: ContentRepository, id: string) {
+  const e = await repo.getEvent(id);
+  if (!e || e.status === 'archived') throw new ApiError(404, 'Event not found.');
+  return e;
+}
+
+// the date as it is now (moved or not), checked for moving (`started` waits: an unchanged move is a no-op even then)
+function dateToChange(e: CalEvent, key: string, settings: { timezone: string }): Occurrence {
+  if (!e.rrule) throw refuse(400, 'one-off', 'Only a repeating event has single dates to move. Change the event’s time instead.');
+  if (e.cancelled) throw refuse(409, 'cancelled-event', 'This event is cancelled.');
+  if (typeof key !== 'string' || key.length > 20) throw refuse(400, 'not-a-date', 'That date isn’t part of this event.');
+  if (e.cancelledDates.includes(key)) throw refuse(409, 'cancelled-date', 'That date is cancelled. Restore it before moving it.');
+  const o = findOccurrence(e, key, settings);
+  if (!o) throw refuse(400, 'not-a-date', 'That date isn’t part of this event.');
+  return o;
+}
+const started = () => refuse(400, 'started', 'That date has already started or passed.');
+
+// The new wall times: `start` in the event's form, `end` defaulting to the
+// date's own length (all-day: the same number of days)
+function newTimes(e: CalEvent, input: MoveInput): { start: string; end: string } {
+  const s = parseWall(input.start);
+  if (!s) throw refuse(400, 'bad-time', e.allDay ? 'Pick a date (YYYY-MM-DD).' : 'Pick a date and time (YYYY-MM-DDTHH:mm).');
+  if (s.dateOnly !== e.allDay) throw refuse(400, 'bad-time', e.allDay ? 'This event lasts all day: give a date only (YYYY-MM-DD).' : 'Give a date and a time (YYYY-MM-DDTHH:mm).');
+  let end = input.end;
+  if (!end) {
+    const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
+    const length = es && ee ? wallMinutesBetween(es, ee) : 60;
+    end = formatWall(e.allDay ? addWallDays(s, Math.round(length / 1440)) : addWallMinutes(s, Math.max(1, length)));
+  }
+  try {
+    return normalizeEventTimes({ start: input.start, end, allDay: e.allDay });
+  } catch (err) {
+    throw refuse(400, 'bad-time', err instanceof Error ? err.message : 'Pick a valid time.');
+  }
+}
+
+// what else takes the rooms this date would hold at its new time (setup and
+// cleanup, or the whole day, as the event holds them)
+async function clashesFor(repo: ContentRepository, next: CalEvent, key: string, at: { start: number; end: number }, settings: { timezone: string }): Promise<BusySlot[]> {
+  const resources = new Map((await repo.listResources()).map((r) => [r.id, r]));
+  const holds = holdsFromEvents([next], resources, settings, at.start - 2 * DAY, at.end + 2 * DAY, { force: true }).filter((h) => h.key === key);
+  const seen = new Set<string>();
+  const out: BusySlot[] = [];
+  for (const h of holds) {
+    for (const b of await roomBusy(repo, settings, { resourceIds: [h.resourceId], from: h.start, to: h.end, ignore: { eventId: next.id, key } })) {
+      const id = `${b.resourceId}:${b.kind}:${b.bookingId ?? `${b.eventId}:${b.key}`}:${b.start}`;
+      if (!seen.has(id)) { seen.add(id); out.push(b); }
+    }
+  }
+  return out.sort((a, b) => a.start - b.start);
+}
+
+async function refuseForHost(repo: ContentRepository, clashes: BusySlot[]) {
+  const names = new Map((await repo.listResources()).map((r) => [r.id, r.name]));
+  const rooms = [...new Set(clashes.map((c) => names.get(c.resourceId) ?? 'The room'))];
+  const list = rooms.length > 1 ? `${rooms.slice(0, -1).join(', ')} and ${rooms[rooms.length - 1]}` : rooms[0];
+  throw refuse(409, 'room-taken', `${list} ${rooms.length > 1 ? 'are' : 'is'} taken at that time. Pick another time${rooms.length ? ' or room' : ''}, or ask the team.`);
+}
+
+const sameRooms = (a: string[] | undefined, b: string[]) => a !== undefined && a.length === b.length && a.every((x, i) => x === b[i]);
+// the same move, whoever made it and when
+const sameMove = (a: MovedDate, b: MovedDate) => a.start === b.start && a.end === b.end && a.note === b.note
+  && JSON.stringify(a.roomIds ?? null) === JSON.stringify(b.roomIds ?? null) && JSON.stringify(a.location ?? null) === JSON.stringify(b.location ?? null);
+
+/**
+ * Move one date of a repeating event to a new time (and maybe other rooms or
+ * another place). Moving an already moved date replaces its move; moving it
+ * back to exactly where it was is moveOccurrenceBack. Moving it to where it
+ * already is changes nothing (`changed: false`): retries never email twice.
+ */
+export async function moveOccurrence(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, input: MoveInput, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  const role = roleOf(actor, e);
+  const settings = await repo.getSettings();
+  const current = dateToChange(e, key, settings);
+  const prior = e.movedDates[key];
+  const times = newTimes(e, input);
+
+  let roomIds = input.roomIds === undefined ? prior?.roomIds : [...new Set(input.roomIds)];
+  if (roomIds !== undefined) {
+    const known = new Set((await repo.listResources()).map((r) => r.id));
+    roomIds = roomIds.filter((r) => known.has(r));
+    // the event's own rooms aren't an override
+    if (sameRooms(roomIds, e.roomHold.resourceIds)) roomIds = undefined;
+  }
+  let location = input.location === undefined ? prior?.location : input.location === null ? undefined : EventLocation.parse({ ...e.location, ...input.location });
+  if (location && !location.name.trim() && !location.address.trim()) throw new ApiError(400, 'Give the place a name or an address.');
+  if (location && JSON.stringify(location) === JSON.stringify(e.location)) location = undefined;
+  const note = input.note === undefined ? prior?.note ?? '' : String(input.note).replace(/\s+/g, ' ').trim().slice(0, NOTE_MAX);
+
+  const entry: MovedDate = { start: times.start, end: times.end, ...(roomIds ? { roomIds } : {}), ...(location ? { location } : {}), note, by: actorId(actor!), at: now };
+  if (prior && sameMove(prior, entry)) return { event: e, clashes: [], changed: false };
+  const at = movedInstants(e, entry, settings);
+  if (!at) throw refuse(400, 'bad-time', 'Pick a valid time.');
+
+  // back where the series puts it, with nothing else different: that's moving it back
+  const series = findOccurrence({ ...e, movedDates: {} }, key, settings)!;
+  if (at.start === series.start && at.end === series.end && !roomIds && !location) return moveOccurrenceBack(repo, actor, id, key, hooks, opts);
+  if (current.start <= now) throw started();
+  if (at.start <= now) throw refuse(400, 'past', 'Pick a time that hasn’t passed yet.');
+
+  const next: CalEvent = { ...e, movedDates: { ...e.movedDates, [key]: entry } };
+  const clashes = await clashesFor(repo, next, key, at, settings);
+  if (clashes.length && role === 'host') await refuseForHost(repo, clashes);
+
+  await repo.setEventMovedDates(id, next.movedDates, undefined, { quiet: opts.quiet });
+  const after = (await repo.getEvent(id))!;
+  const moved = findOccurrence(after, key, settings)!;
+  await afterChange(repo, after, current, moved, { role, actor: actor!, note, hooks, opts, settings });
+  return { event: after, clashes, changed: true };
+}
+
+/** Put a moved date back where the series has it (idempotent: a date that isn't moved is `changed: false`). Hosts are refused if its rooms are taken there now. */
+export async function moveOccurrenceBack(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  const role = roleOf(actor, e);
+  if (!Object.hasOwn(e.movedDates, key)) return { event: e, clashes: [], changed: false };
+  const settings = await repo.getSettings();
+  const { [key]: _gone, ...rest } = e.movedDates;
+  const next: CalEvent = { ...e, movedDates: rest };
+  const current = findOccurrence(e, key, settings);
+  const back = findOccurrence(next, key, settings);
+  // a key the series no longer has (it was retimed): nothing to put back, just forget it
+  if (current && back) {
+    if (current.start <= now) throw started();
+    if (back.start <= now) throw refuse(400, 'original-passed', 'Its original time has already passed.');
+  }
+  const clashes = back ? await clashesFor(repo, next, key, back, settings) : [];
+  if (clashes.length && role === 'host') await refuseForHost(repo, clashes);
+  await repo.setEventMovedDates(id, rest, undefined, { quiet: opts.quiet });
+  const after = (await repo.getEvent(id))!;
+  if (current && back) await afterChange(repo, after, current, back, { role, actor: actor!, note: '', hooks, opts, settings });
+  else await eventSideEffects(repo, hooks, after);
+  return { event: after, clashes, changed: true };
+}
+
+// RSVPs follow the date (emailed when its time changed), then the usual side
+// effects (webhook; the app notice unless the write was quiet), then staff hear about a host's move
+async function afterChange(repo: ContentRepository, after: CalEvent, from: Occurrence, to: Occurrence,
+  c: { role: Role; actor: MoveActor; note: string; hooks: SaveHooks; opts: MoveOptions; settings: Awaited<ReturnType<ContentRepository['getSettings']>> }) {
+  if ((from.start !== to.start || from.end !== to.end) && await repo.moveOccurrenceRsvps(after.id, from.start, { start: to.start, end: to.end }, c.note)) {
+    await kickEmail(repo, c.hooks.locals, waitUntilFrom(c.hooks.locals));
+  }
+  await eventSideEffects(repo, c.hooks, after);
+  if (c.role === 'host' && !c.opts.quiet && c.actor !== GOOGLE_SYNC) await notifyStaffOfMove(repo, after, from, to, c.actor.id, c.note, c.settings, c.hooks);
+}
+
+// "Date moved" to members.notify (else the owners), like members' requests
+async function notifyStaffOfMove(repo: ContentRepository, e: CalEvent, from: Occurrence, to: Occurrence, by: string, note: string,
+  settings: Awaited<ReturnType<ContentRepository['getSettings']>>, hooks: SaveHooks) {
+  const recipients = MEMBERS.notify.length ? MEMBERS.notify : (await repo.listUsers()).filter((u) => u.role === 'owner' && u.email).map((u) => u.email);
+  if (!recipients.length) return;
+  const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
+  const fmt = (o: Occurrence) => {
+    try { return new Intl.DateTimeFormat(siteLocale(settings), e.allDay ? { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz } : { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZone: tz }).format(o.start); }
+    catch { return new Date(o.start).toISOString(); }
+  };
+  const version = (await repo.email.config().catch(() => null))?.version ?? 0;
+  const at = Date.now();
+  for (const recipient of recipients) {
+    await repo.email.enqueue({ dedupe: `event-move:${e.id}:${from.key}:${at}:${recipient}`, kind: 'event-request', recipient,
+      payload: JSON.stringify({ eventId: e.id, kind: 'staff-moved', at, reply: '', by, note, when: `${fmt(from)} → ${fmt(to)}` }), configVersion: version, expiresAt: at + 7 * DAY });
+  }
+  await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals)).catch(() => {});
+}
+
+/** One upcoming date for the editor's Dates panel: its key, wall times (for the move form), words, and state. */
+export interface DateRow {
+  key: string;
+  /** where it is now, wall-clock in the event's zone (a moved date: its new time) */
+  start: string;
+  end: string;
+  /** "Thu, Jan 10 · 6:00 – 7:00 PM" */
+  when: string;
+  cancelled: boolean;
+  /** moved: "Thu, Jan 10 · 6:00 PM" (where it was) and the note */
+  moved: { from: string; note: string } | null;
+  roomIds: string[];
+}
+
+/** The next `limit` dates of a series from `now`, moved and cancelled ones included. */
+export function upcomingDates(e: CalEvent, settings: Awaited<ReturnType<ContentRepository['getSettings']>>, limit: number, now = Date.now()): DateRow[] {
+  if (!e.rrule) return [];
+  const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
+  const locale = siteLocale(settings);
+  const day = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz });
+  const time = new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: tz });
+  const range = (a: number, b: number) => { try { return time.formatRange(a, b); } catch { return `${time.format(a)} – ${time.format(b)}`; } };
+  const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
+  const length = es && ee ? wallMinutesBetween(es, ee) : 60;
+  return expandEvents([e], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now, windowEndMs: now + 400 * DAY })
+    .slice(0, limit)
+    .map((o) => {
+      const m = o.moved ? e.movedDates[o.key] : undefined;
+      const k = parseWall(o.key)!;
+      return {
+        key: o.key,
+        start: m?.start ?? o.key,
+        end: m?.end ?? formatWall(e.allDay ? addWallDays(k, Math.round(length / 1440)) : addWallMinutes(k, length)),
+        when: e.allDay ? day.format(o.start) : `${day.format(o.start)} · ${range(o.start, o.end)}`,
+        cancelled: o.cancelled,
+        moved: o.moved ? { from: e.allDay ? day.format(o.moved.from.start) : `${day.format(o.moved.from.start)} · ${time.format(o.moved.from.start)}`, note: o.moved.note } : null,
+        roomIds: o.roomIds,
+      };
+    });
+}

package/src/lib/calendar/render.ts

@@ -11,7 +11,8 @@ import { siteLocale } from '../dates';
 import { getCalendarEvents, tzParts, zonedToUtc } from './ics';
 import { calendarPageUrl } from './src';
 import { collectViewEvents, type ViewEvent } from './data';
-import { eventStrings } from './event-words';
+import { eventStrings, type EventStrings } from './event-words';
+import { fill } from '../live/words';
 
 // Card sources are ICS feed URLs or native site calendars:
 //   'acms:all'         every public calendar (+ uncategorized events)
@@ -58,6 +59,7 @@ interface DisplayEvent {
   u?: string; // native events: the event page
   k?: string; // calendar color (#rrggbb), overrides the indexed dot color
   x?: 1; // cancelled
+  mv?: string; // a moved date: "Moved from Thu, Jan 10 · 6:00 PM."
 }
 
 function compactTime(s: string): string {
@@ -65,6 +67,8 @@ function compactTime(s: string): string {
 }
 
 function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayEvent[] {
+  const ew = eventStrings(locale);
+  const allDay = ew.allDay;
   const timeFmt = new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: tz });
   const dayFmt = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz });
   return events.map((e) => {
@@ -73,7 +77,7 @@ function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayE
     let tm = '';
     let rg: string;
     if (e.allDay) {
-      rg = e.days > 1 ? `${when} – ${dayFmt.format(e.end - DAY)}` : `${when} · All day`;
+      rg = e.days > 1 ? `${when} – ${dayFmt.format(e.end - DAY)}` : `${when} · ${allDay}`;
     } else {
       tm = compactTime(timeFmt.format(e.start));
       rg = `${when} · ${timeFmt.format(e.start)} – ${timeFmt.format(e.end)}`;
@@ -84,6 +88,7 @@ function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayE
       ...(e.url ? { u: e.url } : {}),
       ...(e.color && /^#[0-9a-f]{6}$/i.test(e.color) ? { k: e.color } : {}),
       ...(e.cancelled ? { x: 1 as const } : {}),
+      ...(e.moved && !e.cancelled ? { mv: fill(ew.dateMoved, { from: e.allDay ? dayFmt.format(e.moved.from.start) : `${dayFmt.format(e.moved.from.start)} · ${timeFmt.format(e.moved.from.start)}` }) } : {}),
     };
   });
 }
@@ -104,7 +109,7 @@ function indexByDay(events: DisplayEvent[]): Map<number, number[]> {
 
 const dotStyle = (e: DisplayEvent) => (e.k ? ` style="--cal-dot:${e.k}"` : '');
 const chipHtml = (e: DisplayEvent, i: number) =>
-  `<button type="button" class="pc-cal-event${e.x ? ' is-cancelled' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="t">${esc(e.tm)}</span><b>${esc(e.t)}</b></button>`;
+  `<button type="button" class="pc-cal-event${e.x ? ' is-cancelled' : ''}${e.mv ? ' is-moved' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="t">${esc(e.tm)}</span><b>${esc(e.t)}</b></button>`;
 
 function monthGridHtml(y: number, m: number, todayN: number, byDay: Map<number, number[]>, events: DisplayEvent[], dows: string[], monthsShort: string[], ws: number): string {
   const first = dayNum(y, m, 1);
@@ -132,11 +137,11 @@ function weekHtml(weekStart: number, todayN: number, byDay: Map<number, number[]
   return `<div class="pc-cal-week">${h}</div>`;
 }
 
-function upcomingHtml(events: DisplayEvent[], order: number[], limit: number): string {
-  if (!order.length) return `<p class="pc-cal-empty">No upcoming events.</p>`;
+function upcomingHtml(events: DisplayEvent[], order: number[], limit: number, w: EventStrings): string {
+  if (!order.length) return `<p class="pc-cal-empty">${esc(w.calendar.noUpcoming)}</p>`;
   const items = order.slice(0, limit).map((i) => {
     const e = events[i];
-    return `<li><button type="button" class="pc-cal-row${e.x ? ' is-cancelled' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="d">${esc(e.rg.split(' · ')[0])}</span><span class="ti">${esc(e.t)}</span><span class="t">${esc(e.tm) || 'All day'}</span></button></li>`;
+    return `<li><button type="button" class="pc-cal-row${e.x ? ' is-cancelled' : ''}${e.mv ? ' is-moved' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="d">${esc(e.rg.split(' · ')[0])}</span><span class="ti">${esc(e.t)}</span><span class="t">${esc(e.tm) || esc(w.allDay)}</span></button></li>`;
   });
   return `<ul class="pc-cal-agenda">${items.join('')}</ul>`;
 }
@@ -153,7 +158,7 @@ function fday(n){var d=new Date(n*D);return[d.getUTCFullYear(),d.getUTCMonth()+1
 function dow(n){return((n+4-(P.ws||0))%7+7)%7}
 var byDay={};P.events.forEach(function(e,i){var n0=dnum(e.d);for(var k=0;k<Math.min(e.n,60);k++){(byDay[n0+k]=byDay[n0+k]||[]).push(i)}});
 function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;')}
-function chip(i){var e=P.events[i];return '<button type="button" class="pc-cal-event'+(e.x?' is-cancelled':'')+'" data-ev="'+i+'" data-cal="'+e.c+'"'+(e.k?' style="--cal-dot:'+e.k+'"':'')+'><span class="t">'+esc(e.tm)+'</span><b>'+esc(e.t)+'</b></button>'}
+function chip(i){var e=P.events[i];return '<button type="button" class="pc-cal-event'+(e.x?' is-cancelled':'')+(e.mv?' is-moved':'')+'" data-ev="'+i+'" data-cal="'+e.c+'"'+(e.k?' style="--cal-dot:'+e.k+'"':'')+'><span class="t">'+esc(e.tm)+'</span><b>'+esc(e.t)+'</b></button>'}
 function chips(n){return(byDay[n]||[]).map(chip).join('')}
 var todayN=dnum(P.today),mY=P.month[0],mM=P.month[1],weekN=todayN-dow(todayN);
 function renderMonth(){
@@ -189,7 +194,7 @@ if(!hit||!root.contains(hit)){if(!t.closest('.pc-cal-pop'))closePop();return}
 var e=P.events[Number(hit.getAttribute('data-ev'))];if(!e)return;
 closePop();
 pop=document.createElement('div');pop.className='pc-cal-pop';
-pop.innerHTML='<button type="button" class="pc-cal-pop-x" aria-label="Close">&times;</button>'+(e.x?'<span class="pc-cal-pop-flag">'+esc(P.cancelled)+'</span>':'')+'<strong class="pc-cal-pop-title">'+esc(e.t)+'</strong><div class="pc-cal-pop-when">'+esc(e.rg)+'</div>'+(e.l?'<div class="pc-cal-pop-loc">'+esc(e.l)+'</div>':'')+(e.ds?'<p class="pc-cal-pop-desc">'+esc(e.ds)+'</p>':'')+(e.u?'<a class="pc-cal-pop-link" href="'+esc(e.u)+'">'+esc(P.details)+' &rarr;</a>':'');
+pop.innerHTML='<button type="button" class="pc-cal-pop-x" aria-label="'+esc(P.close)+'">&times;</button>'+(e.x?'<span class="pc-cal-pop-flag">'+esc(P.cancelled)+'</span>':'')+(e.mv?'<span class="pc-cal-pop-flag is-moved">'+esc(P.moved)+'</span>':'')+'<strong class="pc-cal-pop-title">'+esc(e.t)+'</strong><div class="pc-cal-pop-when">'+esc(e.rg)+'</div>'+(e.mv?'<div class="pc-cal-pop-moved">'+esc(e.mv)+'</div>':'')+(e.l?'<div class="pc-cal-pop-loc">'+esc(e.l)+'</div>':'')+(e.ds?'<p class="pc-cal-pop-desc">'+esc(e.ds)+'</p>':'')+(e.u?'<a class="pc-cal-pop-link" href="'+esc(e.u)+'">'+esc(P.details)+' &rarr;</a>':'');
 frame.appendChild(pop);
 var fr=frame.getBoundingClientRect(),cr=hit.getBoundingClientRect();
 pop.style.left=Math.max(8,Math.min(cr.left-fr.left,fr.width-pop.offsetWidth-8))+'px';
@@ -234,7 +239,9 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     (opts.title ? `<h3 class="pc-cal-heading">${esc(opts.title)}</h3>` : '') +
     (opts.subtitle ? `<p class="pc-cal-sub">${esc(opts.subtitle)}</p>` : '');
   const tz = settings.timezone || 'UTC';
+  // a page in another language passes its settings with that locale
   const locale = siteLocale(settings);
+  const w = eventStrings(locale);
   const today = tzParts(now, tz);
   const [minY, minM] = addMonths(today.y, today.m, -6);
   const [maxY, maxM] = addMonths(today.y, today.m, 6);
@@ -263,10 +270,10 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     titleText = `${monthsShort[wa.m - 1]} ${wa.d} – ${wa.m === wb.m ? '' : `${monthsShort[wb.m - 1]} `}${wb.d}, ${wb.y}`;
     bodyHtml = weekHtml(weekStart, todayN, byDay, events, dows);
   } else if (opts.view === 'upcoming') {
-    titleText = 'Upcoming';
+    titleText = w.calendar.upcoming;
     const startOfToday = zonedToUtc(today.y, today.m, today.d, 0, 0, 0, tz);
     const order = raw.map((e, i) => ({ e, i })).filter(({ e }) => e.end > startOfToday).map(({ i }) => i);
-    bodyHtml = upcomingHtml(events, order, Math.min(50, Math.max(1, opts.limit || 6)));
+    bodyHtml = upcomingHtml(events, order, Math.min(50, Math.max(1, opts.limit || 6)), w);
     if (!order.length && opts.emptyText) bodyHtml = `<p class="pc-cal-empty">${esc(opts.emptyText)}</p>`;
   } else {
     titleText = `${months[fm - 1]} ${fy}`;
@@ -276,9 +283,9 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
   const navButtons =
     opts.view === 'upcoming'
       ? ''
-      : `<button type="button" class="pc-cal-btn" data-nav="today">Today</button>` +
-        `<button type="button" class="pc-cal-btn" data-nav="prev" aria-label="Previous">‹</button>` +
-        `<button type="button" class="pc-cal-btn" data-nav="next" aria-label="Next">›</button>`;
+      : `<button type="button" class="pc-cal-btn" data-nav="today">${esc(w.calendar.today)}</button>` +
+        `<button type="button" class="pc-cal-btn" data-nav="prev" aria-label="${esc(w.calendar.previous)}">‹</button>` +
+        `<button type="button" class="pc-cal-btn" data-nav="next" aria-label="${esc(w.calendar.next)}">›</button>`;
 
   const footer = opts.footer
     ? `<div class="pc-cal-foot"><a class="pc-cal-open" href="${esc(opts.footer.href)}" target="_blank" rel="noopener">${esc(opts.footer.label)}</a></div>`
@@ -291,8 +298,8 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     min: [minY, minM],
     max: [maxY, maxM],
     months, monthsShort, dows, events, ws,
-    // the pop-up's flag in the dates' language, like event cards
-    details: 'Details', cancelled: eventStrings(locale).cancelled,
+    // the pop-up's words in the dates' language, like event cards
+    details: w.calendar.details, cancelled: w.cancelled, close: w.calendar.close, moved: w.moved,
   };
   const json = JSON.stringify(payload).replace(/</g, '\\u003c');
 
@@ -319,11 +326,12 @@ export async function renderCalendarBlock(
   const heading =
     (a.title ? `<h3 class="pc-cal-heading">${esc(a.title)}</h3>` : '') +
     (a.subtitle ? `<p class="pc-cal-sub">${esc(a.subtitle)}</p>` : '');
+  const w = eventStrings(siteLocale(settings)).calendar;
 
   const feeds = a.sources.filter((s) => s.startsWith('http'));
   const natives = repo ? a.sources.filter(isNativeSource) : [];
   if (!feeds.length && !natives.length) {
-    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">No calendar connected.</p></div></section>`;
+    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">${esc(w.noSource)}</p></div></section>`;
   }
 
   const win = calendarWindow(settings, now);
@@ -346,7 +354,7 @@ export async function renderCalendarBlock(
   const raw: ViewEvent[] = [...feedEvents, ...native].sort((x, y) => x.start - y.start || x.title.localeCompare(y.title));
 
   if (!raw.length && feeds.length && errors.length === feeds.length && !natives.length) {
-    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">Calendar unavailable right now.</p></div></section>`;
+    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">${esc(w.unavailable)}</p></div></section>`;
   }
 
   const pageUrl = a.showOpenLink ? feeds.map(calendarPageUrl).find(Boolean) ?? '' : '';
@@ -355,7 +363,7 @@ export async function renderCalendarBlock(
     title: a.title,
     subtitle: a.subtitle,
     limit: a.limit,
-    footer: pageUrl ? { href: pageUrl, label: 'Open in Google Calendar ↗' } : undefined,
+    footer: pageUrl ? { href: pageUrl, label: w.openGoogle } : undefined,
     // dots only mean something with 2+ calendars
     multi: feeds.length + nativeCalendars > 1,
   });