@acms-subir/core 0.3.53 → 0.3.55

package/src/server/index.ts

@@ -205,6 +205,55 @@ export async function moveOccurrenceBack(repo: Repo, who: Who | typeof GOOGLE_SY
   return back(internal(repo), who, eventId, occurrenceKey, { url: context.url, locals: context.locals }, opts);
 }
 
+// ---- Google Calendar sync ----------------------------------------------------
+// The two-way sync is set up in the admin (Calendar settings → Synced with
+// Google) and runs from the scheduler. These read what it did, for a site's
+// own pages (a "Synced with Google" badge, a staff report). They don't check
+// permissions and their results name Google calendars: show them to staff.
+
+/** The internal tag on appointments booked through a Google booking page (they come in titled "Booked"). Never shown publicly. */
+export const GOOGLE_BOOKING_TAG = '#google-booking';
+
+export interface GoogleCopy {
+  /** the Google calendar's name and id */
+  googleCalendar: string;
+  googleCalendarId: string;
+  /** the Google event's own page */
+  htmlLink: string;
+  /** when the pair last synced (ms) */
+  syncedAt: number;
+  /** created in Google and its description never edited on the site: Google's description is used */
+  descriptionFromGoogle: boolean;
+  /** a booked appointment from a Google booking page */
+  booking: boolean;
+  /** the latest field both sides changed (the site kept its value), until someone picks one */
+  clash: { field: string; site: string; google: string; at: number } | null;
+}
+
+/** The Google copies of one event (an event in two linked calendars has two). Empty when it isn't synced. */
+export async function googleCopies(repo: Repo, eventId: string): Promise<GoogleCopy[]> {
+  const r = internal(repo);
+  const items = (await r.gcal.itemsForEvent(eventId)).filter((i) => i.kind !== 'segment' && !i.gone);
+  if (!items.length) return [];
+  const links = new Map((await r.gcal.listLinks()).map((l) => [l.id, l]));
+  return items.map((i) => ({
+    googleCalendar: links.get(i.linkId)?.googleName ?? '', googleCalendarId: links.get(i.linkId)?.googleId ?? '', htmlLink: i.htmlLink, syncedAt: i.syncedAt,
+    descriptionFromGoogle: i.descGoogle, booking: i.booking, clash: i.conflict && { field: i.conflict.field, site: i.conflict.site, google: i.conflict.google, at: i.conflict.at },
+  }));
+}
+
+/** Recent changes the sync made (newest first, kept 90 days): direction in/out/clash/info, the event, and what changed in words. */
+export async function googleSyncHistory(repo: Repo, opts: { eventId?: string; limit?: number } = {}) {
+  return (await internal(repo).gcal.listLog({ eventId: opts.eventId, limit: opts.limit ?? 50 }))
+    .map(({ id, at, eventId, direction, action, title, summary, resolved }) => ({ id, at, eventId, direction, action, title, summary, resolved }));
+}
+
+/** Runs the sync once now, as the scheduler does every minute (changes out; each link reads Google every 2 minutes). Returns how many changes it handled. */
+export async function syncGoogleCalendar(repo: Repo, context: Pick<WriteContext, 'locals'>): Promise<number> {
+  const { syncGoogle } = await import('../lib/calendar/google/service');
+  return syncGoogle(internal(repo), context.locals);
+}
+
 // ---- 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
@@ -300,3 +349,56 @@ export async function declineEventRequest(repo: Repo, who: Who, eventId: string,
 export async function setHostedOccurrence(repo: Repo, who: Who, eventId: string, occurrenceKey: string, cancelled: boolean, context: WriteContext): Promise<CalEvent> {
   return (await requests()).setHostedOccurrence(internal(repo), who, eventId, occurrenceKey, cancelled, context);
 }
+
+// ---- hosts moving dates ------------------------------------------------------
+// A host moves one date of an event they host (no permission beyond being in
+// hostIds). acms({ members: { hostMoves } }) decides how: 'direct' (default)
+// moves it at once while its rooms are free (409 room-taken otherwise, and
+// the same move can then be sent with requestDateMove); 'approve' turns every
+// host move into a request. Requests are RequestRecord rows (kind 'move')
+// 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 { RequestRecord } from '../lib/schema';
+
+/** 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> {
+  return (await hostRequests()).moveHostedDate(internal(repo), who, eventId, occurrenceKey, input, context);
+}
+
+/** A host puts a date they moved back where the series has it: at once, or as a request. */
+export async function moveHostedDateBack(repo: Repo, who: Who, eventId: string, occurrenceKey: string, context: WriteContext): Promise<import('../lib/calendar/host-requests').HostMoveResult> {
+  return (await hostRequests()).moveHostedDateBack(internal(repo), who, eventId, occurrenceKey, context);
+}
+
+/**
+ * A host asks staff to move one date (`input`), or to move it back (null),
+ * with an optional `message` for staff. Checked like the move, except that a
+ * taken room is allowed: staff decide. Asking again about the same date
+ * replaces the waiting request. Staff are emailed.
+ */
+export async function requestDateMove(repo: Repo, who: Who, eventId: string, occurrenceKey: string, input: import('../lib/calendar/moves').MoveInput | null, message: string, context: WriteContext): Promise<import('../lib/schema').RequestRecord> {
+  return (await hostRequests()).requestDateMove(internal(repo), who, eventId, occurrenceKey, 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 [];
+  return (await hostRequests()).myDateRequests(internal(repo), who.id, eventId);
+}
+
+/** A host withdraws a waiting date request of theirs. */
+export async function withdrawDateRequest(repo: Repo, who: Who, requestId: string): Promise<void> {
+  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 }> {
+  return (await hostRequests()).approveDateRequest(internal(repo), who, requestId, context, seen);
+}
+
+/** Staff: decline a host's date request, with a note the host reads. */
+export async function declineDateRequest(repo: Repo, who: Who, requestId: string, reply: string, context: WriteContext, seen?: number): Promise<import('../lib/schema').RequestRecord> {
+  return (await hostRequests()).declineDateRequest(internal(repo), who, requestId, reply, context, seen);
+}

package/src/virtual.d.ts

@@ -22,7 +22,7 @@ declare module 'virtual:acms-config' {
     // resolved by integration.mjs (lib/roles.ts and lib/permissions/catalog.ts read them)
     roles?: { key: string; label: string; summary: string; admin: boolean; home: string }[];
     permissions?: { key: string; label: string; description: string; defaults: string[]; sensitive: boolean }[];
-    members?: { enabled: boolean; base: string; notify: string[] };
+    members?: { enabled: boolean; base: string; notify: string[]; hostMoves?: 'direct' | 'approve' };
     announcements?: { enabled: boolean; base: string; pages: boolean; topics: Partial<Record<'event' | 'registration' | 'help' | 'info', string>> };
     // set in astro:config:setup (lib/origin-check.ts): off only when the site turned security.checkOrigin off
     originCheck?: { enabled: boolean; signedRoutes: string[] };