@acms-subir/core 0.3.56 → 0.3.57

package/src/server/index.ts

@@ -256,6 +256,39 @@ export async function syncGoogleCalendar(repo: Repo, context: Pick<WriteContext,
   return syncGoogle(internal(repo), context.locals);
 }
 
+// ---- from this date on -------------------------------------------------------
+// A repeating event changed from one of its dates on (new times, weekday,
+// rule, rooms or place), the dates before it kept as they were. It stays one
+// event; the change is a segment on its row (CalEvent.segments). RSVPs,
+// cancelled and moved dates follow to the new date nearest them within half
+// a week (`npx acms docs calendar`). Staff and GOOGLE_SYNC only (room clashes
+// warn); hosts send requestFromDate. All are idempotent (`changed: false`);
+// `quiet` skips the member push, and RSVP emails still go.
+
+const segments = () => import('../lib/calendar/segments');
+export type { ChangeFromInput, ChangeFromResult } from '../lib/calendar/segments';
+export type { SeriesSegment } from '../lib/schema';
+
+/** Change the series from `fromKey` (an occurrence key) on: `input.start` is the new first date (wall-clock in the event's zone), `rrule` omitted = the rule in effect on the new weekday. */
+export async function changeFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, fromKey: string, input: import('../lib/calendar/segments').ChangeFromInput, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).changeFromDate(internal(repo), who, eventId, fromKey, input, { url: context.url, locals: context.locals }, opts);
+}
+
+/** Cancel every date from `fromKey` on: listed, struck through, holding no room; their RSVPs are cancelled (emailed). */
+export async function cancelFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, fromKey: string, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).cancelFromDate(internal(repo), who, eventId, fromKey, { url: context.url, locals: context.locals }, opts);
+}
+
+/** Undo cancelFromDate (from any date it covers). The dates are back; their RSVPs stay cancelled. */
+export async function restoreFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, fromKey: string, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).restoreFromDate(internal(repo), who, eventId, fromKey, { url: context.url, locals: context.locals }, opts);
+}
+
+/** Remove the change that took over at `from`: the rule before it carries on, RSVPs and dates following back. */
+export async function revertFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, from: string, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).revertFromDate(internal(repo), who, eventId, from, { url: context.url, locals: context.locals }, opts);
+}
+
 // ---- rooms -----------------------------------------------------------------
 // Events hold rooms (CalEvent.roomHold) while they happen. These find where
 // two things want the same room. They don't check permissions, and their
@@ -361,7 +394,7 @@ export async function setHostedOccurrence(repo: Repo, who: Who, eventId: string,
 // that staff who can publish approve or decline; both sides are emailed.
 
 const hostRequests = () => import('../lib/calendar/host-requests');
-export type { HostMoveResult, MoveRequestData } from '../lib/calendar/host-requests';
+export type { HostMoveResult, MoveRequestData, FromDateRequestData } from '../lib/calendar/host-requests';
 
 /** A host moves one date: `{ moved }` at once, or `{ request }` when moves need approval. Errors as moveOccurrence's, plus `code` room-not-allowed (a room the event doesn't use and nobody may request). */
 export async function moveHostedDate(repo: Repo, who: Who, eventId: string, occurrenceKey: string, input: import('../lib/calendar/moves').MoveInput, context: WriteContext): Promise<import('../lib/calendar/host-requests').HostMoveResult> {
@@ -383,6 +416,11 @@ export async function requestDateMove(repo: Repo, who: Who, eventId: string, occ
   return (await hostRequests()).requestDateMove(internal(repo), who, eventId, occurrenceKey, input, message, context);
 }
 
+/** A host asks staff to change their event from one date on (checked like changeFromDate; rooms among the event's and the requestable ones). Staff are emailed. */
+export async function requestFromDate(repo: Repo, who: Who, eventId: string, fromKey: string, input: Omit<import('../lib/calendar/segments').ChangeFromInput, 'location'>, message: string, context: WriteContext): Promise<import('../lib/schema').RequestRecord> {
+  return (await hostRequests()).requestFromDate(internal(repo), who, eventId, fromKey, input, message, context);
+}
+
 /** A host's own date requests (waiting, approved, declined and withdrawn), newest first. */
 export async function listMyDateRequests(repo: Repo, who: Who, eventId?: string): Promise<import('../lib/schema').RequestRecord[]> {
   if (!who) return [];
@@ -394,8 +432,13 @@ export async function withdrawDateRequest(repo: Repo, who: Who, requestId: strin
   return (await hostRequests()).withdrawDateRequest(internal(repo), who, requestId);
 }
 
-/** Staff ("Publish content"): approve a host's date move. It runs as them (room clashes come back as warnings) and is recorded as the host's. Pass `seen`, the request's `updatedAt` you showed. */
-export async function approveDateRequest(repo: Repo, who: Who, requestId: string, context: WriteContext, seen?: number): Promise<{ request: import('../lib/schema').RequestRecord; moved: import('../lib/calendar/moves').MoveResult }> {
+/**
+ * Staff ("Publish content"): approve a host's date request. A move runs as
+ * them (room clashes come back as warnings) and is recorded as the host's
+ * (`moved`); a change from a date on runs changeFromDate (`changed`). Pass
+ * `seen`, the request's `updatedAt` you showed.
+ */
+export async function approveDateRequest(repo: Repo, who: Who, requestId: string, context: WriteContext, seen?: number): Promise<{ request: import('../lib/schema').RequestRecord; moved?: import('../lib/calendar/moves').MoveResult; changed?: import('../lib/calendar/segments').ChangeFromResult }> {
   return (await hostRequests()).approveDateRequest(internal(repo), who, requestId, context, seen);
 }
 

package/src/styles/editor.css

@@ -1346,4 +1346,6 @@ html.pe-evr-lock { overflow: hidden; }
 .pe-evd-rooms legend { font-size: 12px; color: var(--text-2); margin-bottom: 4px; padding: 0; }
 .pe-evd-room { display: inline-flex; align-items: center; gap: 6px; cursor: pointer; }
 .pe-evd-formacts { display: flex; gap: 8px; }
+.pe-evd-segs { margin-bottom: 8px; padding-bottom: 4px; border-bottom: 1px solid var(--line); }
+.pe-evd-hint { margin: 0; font-size: 12.5px; color: var(--text-2); }
 .pe-ev-note.is-error { color: var(--red); }