@acms-subir/core 0.3.47 → 0.3.49

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

@@ -12,6 +12,7 @@ import { getCalendarEvents, tzParts, zonedToUtc } from './ics';
 import { calendarPageUrl } from './src';
 import { collectViewEvents, type ViewEvent } from './data';
 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,7 +67,8 @@ function compactTime(s: string): string {
 }
 
 function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayEvent[] {
-  const allDay = eventStrings(locale).allDay;
+  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) => {
@@ -85,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)}` }) } : {}),
     };
   });
 }
@@ -105,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);
@@ -137,7 +141,7 @@ function upcomingHtml(events: DisplayEvent[], order: number[], limit: number, w:
   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) || esc(w.allDay)}</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>`;
 }
@@ -154,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(){
@@ -190,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="'+esc(P.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';
@@ -295,7 +299,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     max: [maxY, maxM],
     months, monthsShort, dows, events, ws,
     // the pop-up's words in the dates' language, like event cards
-    details: w.calendar.details, cancelled: w.cancelled, close: w.calendar.close,
+    details: w.calendar.details, cancelled: w.cancelled, close: w.calendar.close, moved: w.moved,
   };
   const json = JSON.stringify(payload).replace(/</g, '\\u003c');
 

package/src/lib/calendar/schedule.ts

@@ -1,17 +1,19 @@
-// Writes behind the admin Schedule: quick add, drag to move (a whole series
-// or one occurrence), undo, duplicate. Everything goes through the same
+// Writes behind the admin Schedule: quick add, drag to move (a whole series,
+// or one date: a moved date, lib/calendar/moves.ts), undo, duplicate. Everything goes through the same
 // save/apply path as the event editor, so hooks, feeds, search and webhooks
 // see the same changes. A move applies at once, even on a published event —
 // the editor's "stage until Update" flow is for content edits, not dates.
 // Cancelling one date of a series applies at once too, without touching any
 // staged edits.
 import type { ContentRepository } from '../repo/types';
-import type { CalEvent } from '../schema';
+import type { CalEvent, MovedDate } from '../schema';
 import { EventLocation, slugify } from '../schema';
 import { defaultPlaceLocation } from '../maps/places';
 import { ApiError } from '../api';
 import { applyEventUpdate, eventSideEffects, flushEventHooks, saveEvent, type SaveHooks } from '../content-service';
-import { addWallDays, findOccurrence, formatWall, parseWall } from './events';
+import { addWallDays, addWallMinutes, findOccurrence, formatWall, parseWall, wallMinutesBetween } from './events';
+import { moveOccurrence, moveOccurrenceBack, type MoveActor } from './moves';
+import type { BusySlot } from '../booking/holds';
 import { rruleMap, WEEKDAY_CODES, weekdayOf } from './rrule';
 import { waitUntilFrom } from '../webhooks';
 import { kickEmail } from '../email/service';
@@ -91,78 +93,80 @@ export function shiftRrule(rrule: string, days: number, newStart: string): strin
   return Object.entries(p).sort(([a], [b]) => order.indexOf(a) - order.indexOf(b)).map(([k, v]) => `${k}=${v}`).join(';');
 }
 
-const shift = (wall: string, days: number) => {
+// a wall time moved by whole minutes (date-only walls by whole days)
+const shiftBy = (wall: string, minutes: number) => {
   const w = parseWall(wall);
-  return w ? formatWall(addWallDays(w, days)) : wall;
+  return w ? formatWall(addWallMinutes(w, w.dateOnly ? Math.round(minutes / 1440) * 1440 : minutes)) : wall;
+};
+const dayOf = (wall: string) => {
+  const w = parseWall(wall);
+  return w ? { ...w, hh: 0, mm: 0, dateOnly: true } : null;
 };
 
 export type MoveUndo =
-  | { kind: 'series'; id: string; days: number }
+  | { kind: 'series'; id: string; days: number; minutes?: number }
+  // one date moved (previous: where it was moved before, null = not moved)
+  | { kind: 'date'; id: string; key: string; previous: Pick<MovedDate, 'start' | 'end' | 'roomIds' | 'location' | 'note'> | null }
+  // undo tokens from before moved dates: the date was split off into a copy
   | { kind: 'split'; id: string; seriesId: string; occurrence: string };
 
-// Move a whole event (and every repeat) by `days`
-export async function moveSeries(repo: ContentRepository, id: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+// Move a whole event (and every repeat) by `days`, and `minutes` more (a drag
+// in the week view; all-day events move by whole days only)
+export async function moveSeries(repo: ContentRepository, id: string, days: number, hooks: SaveHooks, minutes = 0): Promise<{ event: CalEvent; undo: MoveUndo }> {
   const e = await repo.getEvent(id);
   if (!e) throw new ApiError(404, 'Event not found.');
-  if (!Number.isInteger(days) || Math.abs(days) > 3660) throw new ApiError(400, 'Pick a day to move it to.');
-  const start = shift(e.start, days);
+  if (!Number.isInteger(days) || Math.abs(days) > 3660 || !Number.isInteger(minutes) || Math.abs(minutes) > 1440 * 7) throw new ApiError(400, 'Pick a day to move it to.');
+  const total = days * 1440 + (e.allDay ? 0 : minutes);
+  const start = shiftBy(e.start, total);
+  // the rule's weekdays follow the start's new day
+  const from = dayOf(e.start), to = dayOf(start);
+  const dayShift = from && to ? Math.round(wallMinutesBetween(from, to) / 1440) : days;
   let event = await saveNow(repo, e, {
-    start, end: shift(e.end, days), allDay: e.allDay,
-    ...(e.rrule ? { rrule: shiftRrule(e.rrule, days, start), exdates: e.exdates.map((x) => shift(x, days)) } : {}),
+    start, end: shiftBy(e.end, total), allDay: e.allDay,
+    ...(e.rrule ? { rrule: shiftRrule(e.rrule, dayShift, start), exdates: e.exdates.map((x) => shiftBy(x, total)) } : {}),
   }, hooks);
-  // cancelled dates move with the series, like skipped ones
-  if (e.rrule && e.cancelledDates.length) {
-    await repo.setEventCancelledDates(id, e.cancelledDates.map((x) => shift(x, days)));
+  // cancelled dates move with the series, like skipped ones; a moved date
+  // keeps its new time and follows under its new key
+  if (e.rrule && (e.cancelledDates.length || Object.keys(e.movedDates).length)) {
+    const moved = Object.fromEntries(Object.entries(e.movedDates).map(([k, m]) => [shiftBy(k, total), m]));
+    await repo.setEventMovedDates(id, moved, e.cancelledDates.map((x) => shiftBy(x, total)));
     await flushEventHooks(repo, hooks);
     event = (await repo.getEvent(id))!;
   }
-  return { event, undo: { kind: 'series', id, days: -days } };
+  return { event, undo: { kind: 'series', id, days: -days, minutes: -minutes } };
 }
 
-// Move one occurrence of a repeating event: skip that date in the series and
-// add a one-off copy on the new date. No schema change, and the copy is a
-// normal event the editor can open. The copy keeps the series' hosts, room
-// hold and translations, and that date's RSVPs move to it (people get the
-// "new time" email).
-export async function moveOccurrence(repo: ContentRepository, id: string, occurrence: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+// Move one date of a repeating event by `minutes` (a drag on the Schedule):
+// a stored move (lib/calendar/moves.ts) that keeps its key, RSVPs and hosts,
+// and its length. A date already moved moves on from where it is. A one-off
+// event moves as a whole.
+export async function moveDateBy(repo: ContentRepository, actor: MoveActor, id: string, key: string, minutes: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo; clashes: BusySlot[] }> {
   const e = await repo.getEvent(id);
   if (!e) throw new ApiError(404, 'Event not found.');
-  if (!e.rrule) return moveSeries(repo, id, days, hooks);
-  const occ = parseWall(occurrence);
-  const first = parseWall(e.start);
-  if (!occ || !first) throw new ApiError(400, 'That date isn’t part of this event.');
-  if (e.exdates.includes(occurrence)) throw new ApiError(409, 'That date was already removed from the series.');
-  // keep the occurrence's own length (first occurrence's start → end)
-  const toMs = (w: { y: number; m: number; d: number; hh: number; mm: number }) => Date.UTC(w.y, w.m - 1, w.d, w.hh, w.mm);
-  const lenMs = toMs(parseWall(e.end) ?? first) - toMs(first);
-  const newStart = addWallDays(occ, days);
-  const t = new Date(toMs(newStart) + lenMs);
-  const pad = (n: number) => String(n).padStart(2, '0');
-  const endDay = `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}-${pad(t.getUTCDate())}`;
-  const endStr = e.allDay ? endDay : `${endDay}T${pad(t.getUTCHours())}:${pad(t.getUTCMinutes())}`;
-
-  const settings = await repo.getSettings();
-  const was = findOccurrence(e, occurrence, settings);
-  await saveNow(repo, e, { exdates: [...e.exdates, occurrence] }, hooks);
-  const copy = await repo.createEvent({
-    title: e.title, slug: await uniqueSlug(repo, e.title), start: formatWall(newStart), end: endStr, allDay: e.allDay,
-    timezone: e.timezone, status: 'draft', excerpt: e.excerpt, bodyJson: e.bodyJson, bodyHtml: e.bodyHtml, cover: e.cover, coverAlt: e.coverAlt,
-    seoTitle: e.seoTitle, seoDesc: e.seoDesc, location: e.location, cta: e.cta, calendarIds: e.calendarIds, fields: e.fields, tags: e.tags,
-    // a cancelled date stays cancelled on its new day
-    cancelled: e.cancelled || e.cancelledDates.includes(occurrence), rsvp: e.rsvp,
-    template: e.template, featured: false, roomHold: e.roomHold, hostIds: e.hostIds, translations: e.translations,
-  });
-  const event = live(e.status) ? await saveEvent(repo, copy.id, { status: 'published' }, hooks) : copy;
-  const now = findOccurrence(event, event.start, settings);
-  if (was && now && await repo.moveOccurrenceRsvps(e.id, was.start, { eventId: event.id, start: now.start, end: now.end })) {
-    await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals));
+  if (!e.rrule) {
+    const r = await moveSeries(repo, id, Math.trunc(minutes / 1440), hooks, minutes % 1440);
+    return { ...r, clashes: [] };
   }
-  return { event, undo: { kind: 'split', id: copy.id, seriesId: e.id, occurrence } };
+  if (!Number.isInteger(minutes) || Math.abs(minutes) > 1440 * 3660) throw new ApiError(400, 'Pick a day to move it to.');
+  const prior = e.movedDates[key];
+  const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
+  const k = parseWall(key);
+  if (!k || !es || !ee) throw new ApiError(400, 'That date isn’t part of this event.');
+  const startWall = prior?.start ?? key;
+  const endWall = prior?.end ?? formatWall(addWallMinutes(k, wallMinutesBetween(es, ee)));
+  const r = await moveOccurrence(repo, actor, id, key, { start: shiftBy(startWall, minutes), end: shiftBy(endWall, minutes) }, hooks);
+  const previous = prior ? { start: prior.start, end: prior.end, roomIds: prior.roomIds, location: prior.location, note: prior.note } : null;
+  return { event: r.event, clashes: r.clashes, undo: { kind: 'date', id, key, previous } };
 }
 
-export async function undoMove(repo: ContentRepository, undo: MoveUndo, hooks: SaveHooks): Promise<void> {
+export async function undoMove(repo: ContentRepository, actor: MoveActor, undo: MoveUndo, hooks: SaveHooks): Promise<void> {
   if (undo.kind === 'series') {
-    await moveSeries(repo, undo.id, undo.days, hooks);
+    await moveSeries(repo, undo.id, undo.days, hooks, undo.minutes ?? 0);
+    return;
+  }
+  if (undo.kind === 'date') {
+    if (undo.previous) await moveOccurrence(repo, actor, undo.id, undo.key, { ...undo.previous, roomIds: undo.previous.roomIds ?? [], location: undo.previous.location ?? null }, hooks);
+    else await moveOccurrenceBack(repo, actor, undo.id, undo.key, hooks);
     return;
   }
   let series = await repo.getEvent(undo.seriesId);
@@ -185,21 +189,29 @@ export async function undoMove(repo: ContentRepository, undo: MoveUndo, hooks: S
 // The date stays on the calendar struck through ("Cancelled"), its room holds
 // are released, feeds mark it STATUS:CANCELLED, and its RSVPs are cancelled
 // (each person gets the "cancelled" email; no reminder). Restoring the date
-// leaves those RSVPs cancelled: people sign up again. These do no permission
+// leaves those RSVPs cancelled: people sign up again. Cancelling a moved date
+// cancels it where it was moved to, and drops the move. These do no permission
 // checks: callers (admin actions, site code through @acms-subir/core/server)
 // decide who may do this.
 
 async function setOccurrenceCancelled(repo: ContentRepository, id: string, key: string, cancel: boolean, hooks: SaveHooks, now = Date.now()): Promise<CalEvent> {
   const e = await repo.getEvent(id);
   if (!e) throw new ApiError(404, 'Event not found.');
-  if (!e.rrule) throw new ApiError(400, 'Only a repeating event has single dates to cancel. Cancel the whole event instead.');
+  // error.code as for moves (lib/calendar/moves.ts MoveRefusal)
+  const refuse = (code: string, message: string) => Object.assign(new ApiError(400, message), { code });
+  if (!e.rrule) throw refuse('one-off', 'Only a repeating event has single dates to cancel. Cancel the whole event instead.');
   const settings = await repo.getSettings();
   const o = typeof key === 'string' && key.length <= 20 ? findOccurrence(e, key, settings) : null;
-  if (!o) throw new ApiError(400, 'That date isn’t part of this event.');
-  if (o.start <= now) throw new ApiError(400, 'That date has already started or passed.');
+  if (!o) throw refuse('not-a-date', 'That date isn’t part of this event.');
   const has = e.cancelledDates.includes(key);
-  if (has === cancel) return e; // already so: nothing to change
-  await repo.setEventCancelledDates(id, cancel ? [...e.cancelledDates, key].sort() : e.cancelledDates.filter((x) => x !== key));
+  if (has === cancel) return e; // already so: nothing to change (also once it has started)
+  if (o.start <= now) throw refuse('started', 'That date has already started or passed.');
+  const cancelledDates = cancel ? [...e.cancelledDates, key].sort() : e.cancelledDates.filter((x) => x !== key);
+  // a date is moved or cancelled, never both: cancelling a moved date drops its move (its RSVPs, at the new time, are cancelled below)
+  if (cancel && Object.hasOwn(e.movedDates, key)) {
+    const { [key]: _moved, ...moved } = e.movedDates;
+    await repo.setEventMovedDates(id, moved, cancelledDates);
+  } else await repo.setEventCancelledDates(id, cancelledDates);
   if (cancel && await repo.cancelOccurrenceRsvps(id, o.start)) await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals));
   const after = (await repo.getEvent(id))!;
   await eventSideEffects(repo, hooks, after);

package/src/lib/email/booking-words.ts

@@ -79,7 +79,8 @@ const STRINGS: Record<string, BookingStrings> = {
       offered: { subject: 'A spot opened: {title}', heading: 'A spot opened for {title}', intro: 'We’re holding it for you until {until}. Confirm it before then, or it goes to the next person in line.' },
       left: { subject: 'Off the waitlist: {title}', heading: 'You’re off the waitlist', intro: 'You’re no longer on the waitlist for this date.' },
     },
-    manage: 'View or change your booking', rsvp: { manage: 'View or change your booking' },
+    manage: 'View or change your booking',
+    rsvp: { manage: 'View or change your booking' },
     waitlist: { manage: 'See your place or leave the waitlist', confirm: 'Confirm my spot' },
     what: 'What', when: 'When', where: 'Where', seats: 'Seats', reference: 'Reference {ref}', icsManage: 'Manage: {url}',
     lateDecline: 'We weren’t able to confirm this booking in time. Please pick another time.',
@@ -118,6 +119,8 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Ver o cambiar su reservación',
     rsvp: {
       manage: 'Ver o cambiar su confirmación',
+      // one date of the event moved (its RSVPs go with it); staff's note follows
+      rescheduled: { subject: 'Nuevo horario: {title} — {when}', heading: 'Esta fecha cambió', intro: 'Tiene un nuevo horario y su lugar se mantiene. Importe el archivo de calendario adjunto para actualizar su calendario, o cancele con el botón de abajo si no puede asistir.' },
       confirmed: { subject: 'Confirmado: {title} — {when}', heading: 'Ya tiene su lugar', intro: 'Está confirmado. Importe el archivo adjunto para agregarlo a su calendario.' },
       declined: { intro: 'Lo sentimos, el organizador no pudo confirmar su lugar.' },
       cancelled: { subject: 'Cancelado: {title}', heading: 'Confirmación cancelada', intro: 'Esta confirmación se canceló.' },
@@ -163,6 +166,7 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Voir ou modifier votre réservation',
     rsvp: {
       manage: 'Voir ou modifier votre inscription',
+      rescheduled: { subject: 'Nouvel horaire : {title} — {when}', heading: 'Cette date a changé', intro: 'Elle a un nouvel horaire et votre place est conservée. Importez le fichier de calendrier joint pour mettre à jour votre calendrier, ou annulez avec le bouton ci-dessous si vous ne pouvez pas venir.' },
       confirmed: { heading: 'Votre place est réservée' },
       declined: { intro: 'Désolés, l’organisateur n’a pas pu confirmer votre inscription.' },
       cancelled: { heading: 'Inscription annulée', intro: 'Cette inscription a été annulée.' },
@@ -208,6 +212,7 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Buchung ansehen oder ändern',
     rsvp: {
       manage: 'Anmeldung ansehen oder ändern',
+      rescheduled: { subject: 'Neuer Termin: {title} — {when}', heading: 'Dieser Termin wurde verschoben', intro: 'Er hat eine neue Uhrzeit, und Ihr Platz bleibt reserviert. Importieren Sie die angehängte Kalenderdatei, um Ihren Kalender zu aktualisieren, oder sagen Sie über die Schaltfläche unten ab, wenn Sie nicht kommen können.' },
       confirmed: { heading: 'Ihr Platz ist reserviert' },
       declined: { intro: 'Leider konnte der Veranstalter Ihre Anmeldung nicht bestätigen.' },
       cancelled: { heading: 'Anmeldung storniert', intro: 'Diese Anmeldung wurde storniert.' },
@@ -253,6 +258,7 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Ver ou alterar sua reserva',
     rsvp: {
       manage: 'Ver ou alterar sua inscrição',
+      rescheduled: { subject: 'Novo horário: {title} — {when}', heading: 'Esta data mudou', intro: 'Ela tem um novo horário e sua vaga foi mantida. Importe o arquivo de calendário anexo para atualizar seu calendário ou cancele pelo botão abaixo se não puder ir.' },
       confirmed: { heading: 'Sua vaga está reservada' },
       declined: { intro: 'Desculpe, o organizador não pôde confirmar sua inscrição.' },
       cancelled: { heading: 'Inscrição cancelada', intro: 'Esta inscrição foi cancelada.' },

package/src/lib/email/service.ts

@@ -47,9 +47,14 @@ async function render(repo: ContentRepository, job: EmailJob, locals?: unknown,
     return accountMail(payload.purpose, job.recipient, settings.siteTitle, `${origin}/account/${payload.purpose}?token=${encodeURIComponent(raw)}`);
   }
   if (job.kind === 'event-request') {
-    const p = JSON.parse(job.payload) as { eventId: string; kind: 'staff-new' | 'staff-changes' | 'approved' | 'declined'; at: number; reply: string };
+    const p = JSON.parse(job.payload) as { eventId: string; kind: 'staff-new' | 'staff-changes' | 'staff-moved' | 'approved' | 'declined'; at: number; reply: string; by?: string; note?: string; when?: string };
     const e = await repo.getEvent(p.eventId);
     if (!e) return null;
+    // a host moved one date (lib/calendar/moves.ts): the words were fixed when it happened
+    if (p.kind === 'staff-moved') {
+      const by = p.by ? await repo.getUser(p.by) : null;
+      return eventRequestMail('staff-moved', job.recipient, settings.siteTitle, { title: e.title, when: p.when ?? '', by: by?.name ?? '', note: p.note ?? '' }, '', `${origin}/admin/calendar/events/${e.id}`);
+    }
     const staff = p.kind.startsWith('staff');
     // staff hear only about requests still waiting (not withdrawn or already answered)
     if (staff && (e.request?.state !== 'pending' || e.request.at !== p.at)) return null;