@acms-subir/core 0.3.56 → 0.3.58

package/src/pages/api/calendar/events/index.ts

@@ -106,8 +106,9 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
             from: { start: o.allDay ? isoWithOffset(o.moved.from.start, etz).slice(0, 10) : isoWithOffset(o.moved.from.start, etz), end: o.allDay ? isoWithOffset(o.moved.from.end - 86_400_000, etz).slice(0, 10) : isoWithOffset(o.moved.from.end, etz) },
             note: o.moved.note, location: o.moved.location ?? null,
           } : null,
-          // that date's rooms
+          // that date's rooms, and its own place (moved there, or from its segment; null = the event's)
           rooms: roomsToJson(o.roomIds, resources, full),
+          location: o.location ?? null,
           event: toJson(o.event.id),
         };
       }),

package/src/pages/members/events/index.astro

@@ -5,9 +5,11 @@ import { currentUser } from '../../../server';
 import { coded } from '../../../lib/api';
 import { readForm } from '../../../lib/forms/http';
 import { MEMBERS, memberEventsPath, hostedEvents, withdrawEventRequest, dismissEventRequest, setHostedOccurrence } from '../../../lib/calendar/requests';
-import { dismissDateRequest, moveHostedDate, moveHostedDateBack, myDateRequests, requestDateMove, withdrawDateRequest, type MoveRequestData } from '../../../lib/calendar/host-requests';
+import { dismissDateRequest, moveHostedDate, moveHostedDateBack, myDateRequests, requestDateMove, requestFromDate, withdrawDateRequest, type FromDateRequestData, type MoveRequestData } from '../../../lib/calendar/host-requests';
+import { changeFromDate, changeFromDefaults, type ChangeFromInput } from '../../../lib/calendar/segments';
+import { rruleMap, WEEKDAY_CODES, weekdayOf } from '../../../lib/calendar/rrule';
 import { eventUrl } from '../../../lib/calendar/config';
-import { eventIsPublic, eventRoomIds, eventTimeZone, expandEvents, featuredOccurrence, findOccurrence, formatOccurrence, type Occurrence } from '../../../lib/calendar/events';
+import { describeSeries, eventIsPublic, eventRoomIds, eventTimeZone, expandEvents, featuredOccurrence, findOccurrence, formatOccurrence, type Occurrence } from '../../../lib/calendar/events';
 import { tzParts } from '../../../lib/calendar/ics';
 import { describeRepeat } from '../../../lib/calendar/rrule';
 import { requestLabel } from '../../../lib/calendar/member-form';
@@ -15,6 +17,7 @@ import { mergeEventDraft } from '../../../lib/drafts';
 import { fill } from '../../../lib/live/words';
 import { localizeDoc } from '../../../lib/translations';
 import type { CalEvent, RequestRecord } from '../../../lib/schema';
+import { roomName as nameIn } from '../../../lib/schema';
 import type { MoveInput } from '../../../lib/calendar/moves';
 import { failure, keepPrivate, memberLanguage, notFound, redirectTo, signInRedirect } from '../_http';
 
@@ -57,6 +60,25 @@ function nextDay(day: string): string {
   return d.toISOString().slice(0, 10);
 }
 
+/**
+ * The "Change from this date on" form → ChangeFromInput: the first date and
+ * times as for a move, and a repeat choice worded around that first date
+ * ('same' keeps the rule in effect, moved to its weekday; the others end as
+ * that rule does).
+ */
+async function fromDateInput(form: FormData, e: CalEvent | null, key: string): Promise<ChangeFromInput> {
+  const base = moveInput(form, e);
+  const choice = String(form.get('repeat') ?? 'same');
+  if (choice === 'same' || !e) return base;
+  const date = String(form.get('date') ?? '').trim();
+  const wd = weekdayOf(date);
+  const code = WEEKDAY_CODES[wd.dow];
+  const kept = rruleMap((await changeFromDefaults(repo, e.id, key))?.rrule ?? '');
+  const ends = kept.COUNT ? `;COUNT=${kept.COUNT}` : kept.UNTIL ? `;UNTIL=${kept.UNTIL}` : '';
+  const rule = { weekly: `FREQ=WEEKLY;BYDAY=${code}`, biweekly: `FREQ=WEEKLY;INTERVAL=2;BYDAY=${code}`, monthly: `FREQ=MONTHLY;BYDAY=${wd.nth >= 5 ? -1 : wd.nth}${code}`, daily: 'FREQ=DAILY' }[choice];
+  return { ...base, rrule: choice === 'once' ? '' : rule ? rule + ends : undefined };
+}
+
 let error = '';
 // a move refused because a room is taken: shown under its date, with "Send as a request"
 let clash: { id: string; key: string; back: boolean; message: string; input: MoveInput | null } | null = null;
@@ -108,6 +130,16 @@ if (Astro.request.method === 'POST') {
         clash = { id, key, back: true, message: failure(err, w, lang).message, input: null };
         Astro.response.status = 409;
       }
+    } else if (op === 'from-date') {
+      // staff who host apply it; other hosts send it to them
+      posted = { id, key, form };
+      const input = await fromDateInput(form, await repo.getEvent(id), key);
+      if (user.can('content.edit')) {
+        await changeFromDate(repo, user, id, key, input, hooks);
+        return redirectTo(`${home}?fromDateDone=1`);
+      }
+      await requestFromDate(repo, user, id, key, input, String(form.get('message') ?? ''), hooks);
+      return redirectTo(`${home}?fromDateSent=1`);
     } else if (op === 'withdraw-request') {
       await withdrawDateRequest(repo, user, String(form.get('request') ?? ''));
       return redirectTo(`${home}?withdrawn=1`);
@@ -122,7 +154,7 @@ if (Astro.request.method === 'POST') {
   }
 }
 
-const FLASH: [keyof typeof w.flash, string][] = (['sent', 'updated', 'changes', 'withdrawn', 'cancelled', 'restored', 'moved', 'movedBack', 'moveSent', 'fromDateSent'] as const).map((k) => [k, w.flash[k]]);
+const FLASH: [keyof typeof w.flash, string][] = (['sent', 'updated', 'changes', 'withdrawn', 'cancelled', 'restored', 'moved', 'movedBack', 'moveSent', 'fromDateSent', 'fromDateDone'] as const).map((k) => [k, w.flash[k]]);
 const flash = error || clash ? '' : FLASH.find(([k]) => Astro.url.searchParams.has(k))?.[1] ?? '';
 
 const DAY = 86_400_000;
@@ -147,14 +179,16 @@ const when = (o: Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days'>
 };
 const day = (ms: number) => format({ month: 'short', day: 'numeric' }, siteTz).format(ms);
 const meta = (...parts: string[]) => parts.filter(Boolean).join(' · ');
-const repeats = (e: CalEvent) => describeRepeat(e.rrule, e.start, undefined, lang);
+// the rule in effect, and a change from a date on still to come
+const repeats = (e: CalEvent) => describeSeries(e, settings, now, lang, undefined, dateLocale);
 const pad = (n: number) => String(n).padStart(2, '0');
 /** an instant as the move form's date and time, in the event's zone */
 const wallParts = (e: CalEvent, ms: number) => {
   const p = tzParts(ms, e.allDay ? siteTz : eventTimeZone(e, settings));
   return { date: `${p.y}-${pad(p.m)}-${pad(p.d)}`, time: `${pad(p.hh)}:${pad(p.mm)}` };
 };
-const roomName = new Map(resources.map((r) => [r.id, r.name]));
+// the rooms in the page's language (their main names without one)
+const roomName = new Map(resources.map((r) => [r.id, nameIn(r, lang)]));
 const requestable = resources.filter((r) => r.requestable).map((r) => r.id);
 /** the rooms a host may pick for a date: the event's own (and its dates'), and the requestable ones */
 const roomChoices = (e: CalEvent) => [...new Set([...eventRoomIds(e), ...requestable])].filter((id) => roomName.has(id)).map((id) => ({ id, name: roomName.get(id)! }));
@@ -169,12 +203,21 @@ const requestTarget = (e: CalEvent, r: RequestRecord) => {
 // …worded for its card: "Thu, Jan 10 · 6:00 – 7:00 PM → Wed, Jan 9 · 5:00 – 6:00 PM" while it waits, else the date as it is
 const requestWhen = (r: RequestRecord) => {
   const e = byId.get(r.eventId);
+  if (e && r.kind === 'from-date') {
+    // the date it changes from (while it's still there), then the new first date and its repeat
+    const f = r.data as FromDateRequestData;
+    const first = findOccurrence({ ...e, start: f.start, end: f.end, rrule: f.rrule, segments: [], movedDates: {}, cancelledDates: [], exdates: [] }, f.start, settings);
+    const from = r.state === 'pending' ? findOccurrence({ ...e, movedDates: {} }, r.key, settings) : null;
+    const to = [first ? when(first) : '', describeRepeat(f.rrule, f.start, undefined, lang)].filter(Boolean).join(' · ');
+    return from ? `${when(from)} → ${to}` : to;
+  }
   const at = e && findOccurrence(e, r.key, settings);
   if (!e || !at) return '';
   const to = r.state === 'pending' ? requestTarget(e, r) : null;
   return to ? `${when(at)} → ${when(to)}` : when(at);
 };
 const waitingMove = new Map(dateRequests.filter((r) => r.kind === 'move' && r.state === 'pending').map((r) => [`${r.eventId}|${r.key}`, r]));
+const waitingFrom = new Set(dateRequests.filter((r) => r.kind === 'from-date' && r.state === 'pending').map((r) => `${r.eventId}|${r.key}`));
 
 // requests: waiting ones first, newest first; shown as they'd be once approved
 const requests = [
@@ -294,13 +337,16 @@ function moveValues(e: CalEvent, o: Occurrence) {
               <ul class="pc-mem-dates">
                 {dates.map((o) => {
                   const off = e.cancelledDates.includes(o.key);
-                  const open = e.rrule && !e.cancelled && o.start > now;
+                  // a date cancelled with every date after it (a cancelled part) is the team's to restore
+                  const open = e.rrule && !e.cancelled && o.start > now && (!o.cancelled || off);
                   const waiting = waitingMove.get(`${e.id}|${o.key}`);
                   const ownMove = o.moved && e.movedDates[o.key]?.by === user.id;
                   const clashHere = clash && clash.id === e.id && clash.key === o.key ? clash : null;
                   const target = waiting && requestTarget(e, waiting);
                   const v = moveValues(e, o);
-                  const reopen = Boolean(posted && posted.id === e.id && posted.key === o.key && error);
+                  const failed = Boolean(posted && posted.id === e.id && posted.key === o.key && error);
+                  const reopen = failed && posted!.form.get('op') !== 'from-date';
+                  const reopenFrom = failed && posted!.form.get('op') === 'from-date';
                   return (
                     <li class={o.cancelled ? 'is-cancelled' : undefined}>
                       <span>
@@ -308,6 +354,7 @@ function moveValues(e: CalEvent, o: Occurrence) {
                         {o.cancelled && <em>{w.cancelledDate}</em>}
                         {o.moved && !o.cancelled && <em class="is-moved" title={o.moved.note || undefined}>{fill(w.movedFrom, { when: when({ ...o, start: o.moved.from.start, end: o.moved.from.end }) })}</em>}
                         {waiting && <em class="is-pending">{(waiting.data as MoveRequestData).back ? w.moveBackRequested : fill(w.moveRequested, { when: target ? when(target) : '' })}</em>}
+                        {waitingFrom.has(`${e.id}|${o.key}`) && <em class="is-pending">{fill(w.changeFromRequested, { when: day(o.start) })}</em>}
                       </span>
                       {open && (
                         <span class="pc-mem-date-acts">
@@ -377,6 +424,39 @@ function moveValues(e: CalEvent, o: Occurrence) {
                           </form>
                         </details>
                       )}
+                      {open && !off && !clashHere && (
+                        <details class="pc-mem-move" open={reopenFrom}>
+                          <summary class="pc-mem-btn is-small" aria-label={fill(w.changeFromLabel, { title: ev.title, when: when(o) })}>{w.changeFrom}</summary>
+                          <form method="post">
+                            <input type="hidden" name="op" value="from-date" />
+                            <input type="hidden" name="id" value={e.id} />
+                            <input type="hidden" name="key" value={o.key} />
+                            <p class="pc-mem-hint">{w.changeFromHint}</p>
+                            <div class="pc-mem-row">
+                              <label class="pc-bk-field"><span>{w.firstDate}</span><input type="date" name="date" required value={reopenFrom ? v.date : wallParts(e, o.start).date} /></label>
+                              {!e.allDay && <label class="pc-bk-field"><span>{w.starts}</span><input type="time" name="startTime" required value={reopenFrom ? v.startTime : wallParts(e, o.start).time} /></label>}
+                              {!e.allDay && <label class="pc-bk-field"><span>{w.ends}</span><input type="time" name="endTime" value={reopenFrom ? v.endTime : wallParts(e, o.end).time} /></label>}
+                            </div>
+                            <label class="pc-bk-field"><span>{w.form.repeats}</span>
+                              <select name="repeat">
+                                {([['same', w.sameRepeat], ['weekly', w.form.repeat.weekly], ['biweekly', w.form.repeat.biweekly], ['monthly', w.form.repeat.monthly], ['daily', w.form.repeat.daily], ['once', w.justThisDate]] as const)
+                                  .map(([value, label]) => <option value={value} selected={reopenFrom && posted!.form.get('repeat') === value}>{label}</option>)}
+                              </select>
+                            </label>
+                            {rooms.length > 0 && (
+                              <fieldset>
+                                <legend>{w.rooms}</legend>
+                                <input type="hidden" name="rooms" value="1" />
+                                {rooms.map((r) => <label class="pc-bk-check"><input type="checkbox" name="roomIds" value={r.id} checked={(reopenFrom ? v.roomIds : o.roomIds).includes(r.id)} /> <span>{r.name}</span></label>)}
+                                <p class="pc-mem-hint" style="flex-basis:100%">{w.roomsHint}</p>
+                              </fieldset>
+                            )}
+                            <label class="pc-bk-field"><span>{w.publicNote} <em>{w.form.optional}</em></span><input name="note" maxlength="500" value={reopenFrom ? v.note : ''} /><small>{w.publicNoteHint}</small></label>
+                            {!user.can('content.edit') && <label class="pc-bk-field"><span>{w.messageForTeam} <em>{w.form.optional}</em></span><textarea name="message" rows="2" maxlength="1000">{reopenFrom ? v.message : ''}</textarea></label>}
+                            <div class="pc-mem-actions"><button class="pc-mem-btn is-small is-primary" type="submit">{user.can('content.edit') ? w.changeFrom.replace(/…$/, '') : w.sendForApproval}</button></div>
+                          </form>
+                        </details>
+                      )}
                     </li>
                   );
                 })}

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); }