@acms-subir/core 0.3.56 → 0.3.58

package/src/lib/calendar/moves.ts

@@ -20,7 +20,7 @@ import type { ContentRepository } from '../repo/types';
 import { EventLocation, type CalEvent, type MovedDate } from '../schema';
 import { ApiError, coded } from '../api';
 import { eventSideEffects, type SaveHooks } from '../content-service';
-import { addWallDays, addWallMinutes, eventRoomIds, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence } from './events';
+import { addWallDays, addWallMinutes, eventRoomIds, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence, partOf, partMinutes, type SeriesPart } from './events';
 import { holdsFromEvents, roomBusy, type BusySlot } from '../booking/holds';
 import { kickEmail } from '../email/service';
 import { waitUntilFrom } from '../webhooks';
@@ -103,14 +103,14 @@ const started = () => refuse(400, 'started', 'That date has already started or p
 
 // 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 } {
+function newTimes(e: CalEvent, input: MoveInput, part: SeriesPart): { 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;
+    // the length of its part's dates (a change from a date on may have its own)
+    const length = partMinutes(part);
     end = formatWall(e.allDay ? addWallDays(s, Math.round(length / 1440)) : addWallMinutes(s, Math.max(1, length)));
   }
   try {
@@ -162,7 +162,9 @@ async function planMove(repo: ContentRepository, actor: MoveActor | null, id: st
   const settings = await repo.getSettings();
   const current = dateToChange(e, key, settings);
   const prior = e.movedDates[key];
-  const times = newTimes(e, input);
+  // its part of the series (CalEvent.segments): the length, rooms and place it has without a move
+  const part = partOf(e, current);
+  const times = newTimes(e, input, part);
 
   let roomIds = input.roomIds === undefined ? prior?.roomIds : [...new Set(input.roomIds)];
   if (roomIds !== undefined) {
@@ -175,11 +177,11 @@ async function planMove(repo: ContentRepository, actor: MoveActor | null, id: st
       if (roomIds.some((r) => !allowed.has(r))) throw refuse(403, 'room-not-allowed', 'Pick from the rooms this event uses, or ask the team for another room.');
     }
     // the event's own rooms aren't an override
-    if (sameRooms(roomIds, e.roomHold.resourceIds)) roomIds = undefined;
+    if (sameRooms(roomIds, part.roomIds)) 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;
+  if (location && JSON.stringify(location) === JSON.stringify(part.location ?? 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: by || actorId(actor!), at: now };
@@ -306,6 +308,8 @@ export interface DateRow {
   /** "Thu, Jan 10 · 6:00 – 7:00 PM" */
   when: string;
   cancelled: boolean;
+  /** cancelled because every date from some date on is (a cancelled part, CalEvent.segments) */
+  partCancelled: boolean;
   /** moved: "Thu, Jan 10 · 6:00 PM" (where it was) and the note */
   moved: { from: string; note: string } | null;
   roomIds: string[];
@@ -319,19 +323,21 @@ export function upcomingDates(e: CalEvent, settings: Awaited<ReturnType<ContentR
   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)!;
+      const part = partOf(e, o);
+      const length = partMinutes(part);
       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,
+        // cancelled with the rest of its part (cancelFromDate): restored from the change, not one by one
+        partCancelled: part.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/request-admin.ts

@@ -110,7 +110,8 @@ export async function requestRows(repo: ContentRepository, settings: Settings, t
           ? { taken: true, text: `${found[0].room} on ${f.slot(found[0].start, found[0].end)}${found[0].title ? ` (${found[0].title})` : ''}${found.length > 1 ? ` and ${found.length - 1} more` : ''}` }
           : { taken: false, text: `${names} ${d.roomIds.length > 1 ? 'are' : 'is'} free then` };
       }
-    } else if (q.kind === 'move') {
+    } else if (q.kind === 'move' || q.kind === 'from-date') {
+      // a host's date move, or change from a date on ("Thu, Jan 17, 6:00 PM → Wed, Jan 16, 5:00 PM · Weekly on Wednesday")
       title = e?.title ?? 'A deleted event';
       line = await dateRequestWhen(repo, q);
       if (tab === 'pending' && e) {

package/src/lib/calendar/request-mail.ts

@@ -1,5 +1,6 @@
 import type { ContentRepository } from '../repo/types';
 import type { RequestRecord, Settings } from '../schema';
+import { roomName } from '../schema';
 import type { Mail } from '../email/types';
 import { siteLang, siteLocale } from '../dates';
 import { I18N, localeName } from '../i18n';
@@ -66,7 +67,7 @@ async function personSummary(repo: ContentRepository, q: RequestRecord, settings
   const parts = [
     requestWhen(d.start, d.end, settings, locale),
     ...(d.repeat === 'weekly' ? [w.weekly] : []),
-    d.roomIds.map((id) => rooms.find((r) => r.id === id)?.name).filter(Boolean).join(', '),
+    d.roomIds.map((id) => rooms.find((r) => r.id === id)).filter((r) => r !== undefined).map((r) => roomName(r, lang)).join(', '),
     d.people ? fill(w.aboutPeople, { count: String(d.people) }) : '',
     type ? (lang && type.translations[lang]) || type.label : '',
   ].filter(Boolean);

package/src/lib/calendar/request-page.ts

@@ -1,5 +1,6 @@
 import type { ContentRepository } from '../repo/types';
 import type { RequestRecord, Settings } from '../schema';
+import { roomName } from '../schema';
 import { requestWhen } from './request-mail';
 import { requestSettings, type NewEventDetails, type RequestInput } from './request-service';
 import { requestStrings } from './request-words';
@@ -44,7 +45,7 @@ export async function sentSummary(repo: ContentRepository, q: RequestRecord, set
   const line = [
     requestWhen(d.start, d.end, settings, locale),
     d.repeat === 'weekly' ? w.weekly : d.repeat === 'other' ? d.repeatText : '',
-    d.roomIds.map((id) => rooms.find((r) => r.id === id)?.name).filter(Boolean).join(', '),
+    d.roomIds.map((id) => rooms.find((r) => r.id === id)).filter((r) => r !== undefined).map((r) => roomName(r, lang)).join(', '),
     d.people ? fill(w.aboutPeople, { count: String(d.people) }) : '',
     type ? (lang && type.translations[lang]) || type.label : '',
   ].filter(Boolean).join(' · ');

package/src/lib/calendar/request-service.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ContentRepository } from '../repo/types';
-import { RequestRecord, RoomHold, type CalEvent, type RequestSettings, type Resource, type Settings } from '../schema';
+import { RequestRecord, RoomHold, roomName, type CalEvent, type RequestSettings, type Resource, type Settings } from '../schema';
 import { ApiError, coded } from '../api';
 import { sha256Hex } from '../api-keys';
 import { validAddress } from '../email/config';
@@ -139,7 +139,7 @@ export async function requestOptions(repo: ContentRepository, locale = '', now =
   return {
     open: rq.open,
     types: rq.types.map((t) => ({ id: t.id, label: typeLabel(t, lang) })),
-    rooms: (await requestableRooms(repo)).map((r) => ({ slug: r.slug, name: r.name, color: /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : '' })),
+    rooms: (await requestableRooms(repo)).map((r) => ({ slug: r.slug, name: roomName(r, lang), color: /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : '' })),
     replyTime: words?.replyTime || rq.replyTime,
     notice: words?.notice || rq.notice,
     phone: rq.phone,
@@ -429,11 +429,11 @@ export async function approveRequest(repo: ContentRepository, who: Actor | null,
     if (!event) throw new ApiError(409, 'That event was deleted. Decline the request, or reply to the person.');
     done = await decide(repo, q, answer);
     next = `/admin/calendar/events/${event.id}${q.key ? `?move=${encodeURIComponent(q.key)}` : ''}`;
-  } else if (q.kind === 'move') {
-    // a host's date move (lib/calendar/host-requests.ts): it runs, and the host hears about it there
+  } else if (q.kind === 'move' || q.kind === 'from-date') {
+    // a host's date move or change from a date on (lib/calendar/host-requests.ts): it runs, and the host hears about it there
     const { approveDateRequest } = await import('./host-requests');
-    const { request, moved } = await approveDateRequest(repo, who, id, hooks, seen);
-    return { request, event: moved.event, next: `/admin/calendar/events/${request.eventId}` };
+    const { request, moved, changed } = await approveDateRequest(repo, who, id, hooks, seen);
+    return { request, event: (moved ?? changed)!.event, next: `/admin/calendar/events/${request.eventId}` };
   } else {
     throw new ApiError(400, 'Open the event to answer this request.');
   }
@@ -464,7 +464,7 @@ async function draftFrom(repo: ContentRepository, q: RequestRecord, hooks: SaveH
 export async function declineRequest(repo: ContentRepository, who: Actor | null, id: string, reply: string, hooks: SaveHooks, seen?: number, opts: { email?: boolean } = {}): Promise<RequestRecord> {
   requireAnswerer(who);
   const q = await pendingRequest(repo, id, seen);
-  if (q.kind === 'move') return (await import('./host-requests')).declineDateRequest(repo, who, id, reply, hooks, seen);
+  if (q.kind === 'move' || q.kind === 'from-date') return (await import('./host-requests')).declineDateRequest(repo, who, id, reply, hooks, seen);
   if (q.kind !== 'new' && q.kind !== 'change') throw new ApiError(400, 'Open the event to answer this request.');
   const reason = text(reply, REQUEST_LIMITS.message);
   const done = await decide(repo, q, { state: 'declined', reviewedBy: who.id, reviewedAt: Date.now(), reply: reason });

package/src/lib/calendar/schedule.ts

@@ -6,12 +6,12 @@
 // Cancelling one date of a series applies at once too, without touching any
 // staged edits.
 import type { ContentRepository } from '../repo/types';
-import type { CalEvent, MovedDate } from '../schema';
+import type { CalEvent, MovedDate, SeriesSegment } 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, addWallMinutes, findOccurrence, formatWall, parseWall, wallMinutesBetween } from './events';
+import { addWallDays, addWallMinutes, findOccurrence, formatWall, parseWall, wallMinutesBetween, partOf, partMinutes } from './events';
 import { moveOccurrence, moveOccurrenceBack, type MoveActor } from './moves';
 import type { BusySlot } from '../booking/holds';
 import { rruleMap, WEEKDAY_CODES, weekdayOf } from './rrule';
@@ -105,6 +105,8 @@ const dayOf = (wall: string) => {
 
 export type MoveUndo =
   | { kind: 'series'; id: string; days: number; minutes?: number }
+  // this and following dates (lib/calendar/segments.ts): the segments as they were, and where the change took over
+  | { kind: 'following'; id: string; from: string; previous: SeriesSegment[] }
   // 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
@@ -126,10 +128,16 @@ export async function moveSeries(repo: ContentRepository, id: string, days: numb
     ...(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; a moved date
-  // keeps its new time and follows under its new key
-  if (e.rrule && (e.cancelledDates.length || Object.keys(e.movedDates).length)) {
+  // keeps its new time and follows under its new key; a change from a date on
+  // (segments) moves as a whole: its change point, first date and rule
+  if (e.rrule && (e.cancelledDates.length || Object.keys(e.movedDates).length || e.segments.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)));
+    const segments = e.segments.map((g) => {
+      const gs = shiftBy(g.start, total);
+      const shift = ((a, b) => (a && b ? Math.round(wallMinutesBetween(a, b) / 1440) : days))(dayOf(g.start), dayOf(gs));
+      return { ...g, from: shiftBy(g.from, total), start: gs, end: shiftBy(g.end, total), rrule: shiftRrule(g.rrule, shift, gs) };
+    });
+    await repo.setEventDates(id, { movedDates: moved, cancelledDates: e.cancelledDates.map((x) => shiftBy(x, total)), segments });
     await flushEventHooks(repo, hooks);
     event = (await repo.getEvent(id))!;
   }
@@ -149,21 +157,47 @@ export async function moveDateBy(repo: ContentRepository, actor: MoveActor, id:
   }
   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 at = k && findOccurrence({ ...e, movedDates: {} }, key, await repo.getSettings());
+  if (!k || !at) throw new ApiError(400, 'That date isn’t part of this event.');
+  // its length is its part's (a change from a date on may have its own)
   const startWall = prior?.start ?? key;
-  const endWall = prior?.end ?? formatWall(addWallMinutes(k, wallMinutesBetween(es, ee)));
+  const endWall = prior?.end ?? formatWall(addWallMinutes(k, partMinutes(partOf(e, at))));
   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 } };
 }
 
+// Move one date of a repeating event and every date after it by `minutes`
+// (a drag on the Schedule, "This and following dates"): a change from that
+// date on (lib/calendar/segments.ts) whose rule follows the new weekday or
+// day, keeping each date's length. The dates before it stay where they are.
+export async function moveFollowingBy(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 (!Number.isInteger(minutes) || Math.abs(minutes) > 1440 * 3660) throw new ApiError(400, 'Pick a day to move it to.');
+  const { changeFromDate, changeFromDefaults } = await import('./segments');
+  const from = await changeFromDefaults(repo, id, key);
+  if (!from) throw new ApiError(400, 'That date isn’t part of this event.');
+  // a moved date was dragged from where it is now
+  const moved = e.movedDates[key];
+  const r = await changeFromDate(repo, actor, id, key, { start: shiftBy(moved?.start ?? from.start, minutes), end: shiftBy(moved?.end ?? from.end, minutes) }, hooks);
+  // undo puts the segments back, from the earliest one that changed
+  const same = (a: SeriesSegment, list: SeriesSegment[]) => list.some((x) => JSON.stringify(x) === JSON.stringify(a));
+  const changed = [...r.event.segments.filter((g) => !same(g, e.segments)), ...e.segments.filter((g) => !same(g, r.event.segments))].map((g) => g.from).sort();
+  return { event: r.event, clashes: r.clashes, undo: { kind: 'following', id, from: changed[0] ?? key, previous: e.segments } };
+}
+
 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, undo.minutes ?? 0);
     return;
   }
+  if (undo.kind === 'following') {
+    const { restoreSegments } = await import('./segments');
+    await restoreSegments(repo, actor, undo.id, undo.from, undo.previous, hooks);
+    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);