diff --git a/app/database/migrations/20261119120000_add_event_origin/migration.sql b/app/database/migrations/20261119120000_add_event_origin/migration.sql new file mode 100644 index 00000000..94bc03fa --- /dev/null +++ b/app/database/migrations/20261119120000_add_event_origin/migration.sql @@ -0,0 +1,22 @@ +-- Who created an event: the recurring-events job (« job »), a person (« manual ») or a restore (« import »). Until now +-- an event without an author stood for one the job made; deleting an account will now clear the author of what it +-- created, and a hand-made event must never become an empty meeting a template moves or deletes. No change in what +-- anyone may do. +-- +-- 1. The column. The previous image creates events with the default during the rollout: its empty meetings stay +-- « manual » and do not move with their template until a later migration gives them « job ». That one must keep to +-- the events created during the rollout: run again as it is, step 2 would also take a hand-made event whose +-- author's account was deleted since. +ALTER TABLE "Event" ADD COLUMN IF NOT EXISTS "origin" TEXT NOT NULL DEFAULT 'manual'; + +ALTER TABLE "Event" DROP CONSTRAINT IF EXISTS "Event_origin_check"; +ALTER TABLE "Event" ADD CONSTRAINT "Event_origin_check" CHECK ("origin" IN ('job', 'manual', 'import')); + +-- 2. The job's events: no author, no part, no service, no attendance — exactly what an empty meeting was until now. +UPDATE "Event" AS event +SET "origin" = 'job' +WHERE event."createdById" IS NULL + AND event."origin" = 'manual' + AND NOT EXISTS (SELECT 1 FROM "EventPart" part WHERE part."eventId" = event."id") + AND NOT EXISTS (SELECT 1 FROM "EventServicePart" service WHERE service."eventId" = event."id") + AND NOT EXISTS (SELECT 1 FROM "Attendance" attendance WHERE attendance."eventId" = event."id"); diff --git a/app/database/migrations/add-event-origin.integration.test.ts b/app/database/migrations/add-event-origin.integration.test.ts new file mode 100644 index 00000000..47d8496c --- /dev/null +++ b/app/database/migrations/add-event-origin.integration.test.ts @@ -0,0 +1,116 @@ +import { readFileSync } from 'node:fs' +import { join } from 'node:path' +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, describe, expect, it } from 'vitest' +import { PrismaClient } from '~/database/generated/client' + +// Runs against DB_URL rather than DB_RUNTIME_URL: a migration executes as the schema owner. Its statements are read from +// the shipped file and run inside a rolled-back transaction. +const adapter = new PrismaPg({ connectionString: process.env.DB_URL, max: 3, connectionTimeoutMillis: 5000 }) +const testDb = new PrismaClient({ adapter }) + +const STATEMENTS = readFileSync(join(import.meta.dirname, '20261119120000_add_event_origin', 'migration.sql'), 'utf8') + .split('\n') + .filter(line => !line.trimStart().startsWith('--')) + .join('\n') + .split(';') + .map(statement => statement.trim()) + .filter(statement => statement.length > 0) + +class Rollback extends Error {} + +interface Result { + first: Record + second: Record + bogusRefused: boolean +} + +let memo: Promise | undefined + +/** Events in the shape the previous image leaves them: every one at the column's default, « manual ». */ +function snapshot(): Promise { + memo ??= (async () => { + let result: Result | undefined + try { + await testDb.$transaction(async tx => { + const stamp = `event-origin-${process.pid}-${globalThis.performance.now().toString().replace('.', '')}` + const congregationId = (await tx.congregation.create({ data: { name: stamp, slug: stamp, active: true } })).id + const author = await tx.userAccount.create({ + data: { email: `${stamp}@test.com`, password: 'x', congregationId }, + }) + const day = new Date('2026-12-03T18:00:00Z') + const event = (name: string, createdById: number | null) => + tx.event.create({ data: { name, startDate: day, endDate: day, createdById, congregationId } }) + + const ids = { + emptyJob: (await event('empty, no author', null)).id, + withPart: (await event('a part, no author', null)).id, + withService: (await event('a service, no author', null)).id, + withCounts: (await event('counts, no author', null)).id, + handMade: (await event('empty, an author', author.id)).id, + } + await tx.eventPart.create({ data: { name: 'Cantique', eventId: ids.withPart, congregationId } }) + await tx.eventServicePart.create({ data: { name: 'Sono', eventId: ids.withService, congregationId } }) + await tx.attendance.create({ data: { eventId: ids.withCounts, inPerson: 40, congregationId } }) + + const read = async () => { + const rows = await tx.event.findMany({ where: { congregationId }, select: { id: true, origin: true } }) + const byId = new Map(rows.map(row => [row.id, row.origin])) + return Object.fromEntries(Object.entries(ids).map(([name, id]) => [name, byId.get(id) ?? ''])) + } + + for (const statement of STATEMENTS) await tx.$executeRawUnsafe(statement) + const first = await read() + for (const statement of STATEMENTS) await tx.$executeRawUnsafe(statement) + const second = await read() + + let bogusRefused = false + try { + await tx.$executeRawUnsafe('SAVEPOINT bogus') + await tx.$executeRawUnsafe(`UPDATE "Event" SET "origin" = 'bogus' WHERE "id" = ${ids.handMade}`) + } catch { + bogusRefused = true + } finally { + await tx.$executeRawUnsafe('ROLLBACK TO SAVEPOINT bogus') + } + + result = { first, second, bogusRefused } + throw new Rollback() + }) + } catch (error) { + if (!(error instanceof Rollback)) throw error + } + return result as Result + })() + return memo +} + +afterAll(async () => { + await testDb.$disconnect() +}) + +describe('20261119120000_add_event_origin', () => { + it('marks as the job’s only the events that were empty meetings: no author, nothing on them', async () => { + const { first } = await snapshot() + + expect(first).toEqual({ + emptyJob: 'job', + withPart: 'manual', + withService: 'manual', + withCounts: 'manual', + handMade: 'manual', + }) + }) + + it('changes nothing when run twice', async () => { + const { first, second } = await snapshot() + + expect(second).toEqual(first) + }) + + it('refuses an origin it does not know', async () => { + const { bogusRefused } = await snapshot() + + expect(bogusRefused).toBe(true) + }) +}) diff --git a/app/database/schema.prisma b/app/database/schema.prisma index f131474e..c54dd78c 100644 --- a/app/database/schema.prisma +++ b/app/database/schema.prisma @@ -1026,11 +1026,16 @@ model Event { eventServiceParts EventServicePart[] attendance Attendance? - // Null = created by the recurring-events job. A day-off always has one: it is the absence's owner. onDelete is + // Who prepared it: null for a meeting the job created that nobody has prepared yet, or once its author's account is + // deleted (releaseAccountEvents clears it first). A day-off always has one: it is the absence's owner. onDelete is // written out because an optional relation defaults to SetNull, which would empty the owner of every day-off when // an account is deleted. createdBy UserAccount? @relation("createdBy", fields: [createdById], references: [id], onDelete: Restrict) createdById Int? + // Who created it: the recurring-events job (« job »), a person (« manual ») or a restore (« import »). Only the + // job's empty meetings move with their template or go with it; the author says who prepared it (for a day-off, whose + // absence it is). + origin String @default("manual") createdAt DateTime @default(now()) updatedAt DateTime @updatedAt diff --git a/app/features/events/index.server.ts b/app/features/events/index.server.ts index 6cfe443c..548706f8 100644 --- a/app/features/events/index.server.ts +++ b/app/features/events/index.server.ts @@ -1,10 +1,11 @@ // Public server-only surface of the events feature. +export { AccountHasAbsencesError, releaseAccountEvents } from './server/account-events.server' export { type LastWeekMeeting, listLastWeekAttendance, listMeetingsUnderWay } from './server/attendance.queries' export { getNextDaysOffs } from './server/days-off.server' export { deleteTemplate } from './server/delete-template.server' export { duplicateTemplate } from './server/duplicate-template.server' -export { countMeetingsToMove } from './server/empty-meetings.queries' +export { countMeetingsToMove, EMPTY_MEETING } from './server/empty-meetings.queries' export { deleteTemplatePart, deleteTemplateServicePart, diff --git a/app/features/events/index.ts b/app/features/events/index.ts index 13b70293..b3cb2ca5 100644 --- a/app/features/events/index.ts +++ b/app/features/events/index.ts @@ -17,6 +17,7 @@ export { parseAttendanceKind, } from './model/attendance-kind.type' export { dayLabel, dayLabelShort } from './model/day-label' +export { EVENT_ORIGINS, EventOrigin, isEventOrigin } from './model/event-origin.type' export { EventStatus } from './model/event-status.type' export { EventTemplateKey, isSystemTemplate } from './model/event-template.type' export { groupPartsBySlot } from './model/group-parts-by-slot' diff --git a/app/features/events/model/event-origin.type.ts b/app/features/events/model/event-origin.type.ts new file mode 100644 index 00000000..85ef2e37 --- /dev/null +++ b/app/features/events/model/event-origin.type.ts @@ -0,0 +1,21 @@ +// Who created an event (Event.origin). Only the job's events, while empty, move with their template or go with it: an +// event someone made or prepared stays where it is, whatever happens to its author's account. A meeting the job made +// becomes « manual » once someone gives it its programme or moves it; adding a part by hand leaves it the job's. + +export const EventOrigin = { + /** Created ahead by the recurring-events job. */ + Job: 'job', + /** Created by a person, or a job meeting someone prepared or moved. */ + Manual: 'manual', + /** Restored without a known origin: an older archive's event that was not an empty meeting, or an origin this + * version does not know. */ + Import: 'import', +} as const + +export type EventOrigin = (typeof EventOrigin)[keyof typeof EventOrigin] + +export const EVENT_ORIGINS: readonly EventOrigin[] = [EventOrigin.Job, EventOrigin.Manual, EventOrigin.Import] + +export function isEventOrigin(value: unknown): value is EventOrigin { + return typeof value === 'string' && (EVENT_ORIGINS as readonly string[]).includes(value) +} diff --git a/app/features/events/server/account-events.server.test.ts b/app/features/events/server/account-events.server.test.ts new file mode 100644 index 00000000..189d29c0 --- /dev/null +++ b/app/features/events/server/account-events.server.test.ts @@ -0,0 +1,52 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' + +const { releaseAccountEvents, AccountHasAbsencesError } = await import('./account-events.server') + +const db = { + event: { findMany: vi.fn(), deleteMany: vi.fn(), updateMany: vi.fn() }, +} + +const ABSENCE = { id: 31, startDate: new Date('2027-01-12T00:00:00Z'), endDate: new Date('2027-01-14T22:59:00Z') } + +beforeEach(() => { + vi.resetAllMocks() + db.event.findMany.mockResolvedValue([]) + db.event.deleteMany.mockResolvedValue({ count: 0 }) + db.event.updateMany.mockResolvedValue({ count: 0 }) +}) + +describe('releaseAccountEvents', () => { + it('deletes the absences of an account without a record and clears its author elsewhere', async () => { + db.event.findMany.mockResolvedValue([ABSENCE]) + db.event.deleteMany.mockResolvedValue({ count: 1 }) + db.event.updateMany.mockResolvedValue({ count: 2 }) + + const released = await releaseAccountEvents(db as never, { id: 7, memberId: null }, 10) + + expect(released).toEqual({ absencesDeleted: [ABSENCE], eventsUnattributed: 2 }) + expect(db.event.deleteMany).toHaveBeenCalledWith({ where: { congregationId: 10, id: { in: [31] } } }) + expect(db.event.updateMany).toHaveBeenCalledWith({ + where: { congregationId: 10, createdById: 7 }, + data: { createdById: null }, + }) + }) + + it('refuses, writing nothing, an account linked to a record that has absences', async () => { + db.event.findMany.mockResolvedValue([ABSENCE]) + + await expect(releaseAccountEvents(db as never, { id: 7, memberId: 42 }, 10)).rejects.toBeInstanceOf( + AccountHasAbsencesError, + ) + expect(db.event.deleteMany).not.toHaveBeenCalled() + expect(db.event.updateMany).not.toHaveBeenCalled() + }) + + it('only clears the author of an account linked to a record without absences', async () => { + db.event.updateMany.mockResolvedValue({ count: 1 }) + + const released = await releaseAccountEvents(db as never, { id: 7, memberId: 42 }, 10) + + expect(released).toEqual({ absencesDeleted: [], eventsUnattributed: 1 }) + expect(db.event.deleteMany).not.toHaveBeenCalled() + }) +}) diff --git a/app/features/events/server/account-events.server.ts b/app/features/events/server/account-events.server.ts new file mode 100644 index 00000000..9817c15b --- /dev/null +++ b/app/features/events/server/account-events.server.ts @@ -0,0 +1,47 @@ +import { EventTemplateKey } from '~/features/events/model/event-template.type' +import { ConflictError } from '~/shared/errors/app-error.server' +import type { TransactionClient } from '~/shared/infra/db.server' + +/** + * Refused: the account is linked to a record and has absences. They are the person's, not the login's: an + * administrator cannot delete someone else's absences, so the account stays until it can hand them to its record. + */ +export class AccountHasAbsencesError extends ConflictError {} + +export interface ReleasedAccountEvents { + /** The absences deleted with an account that has no record, for the audit trail. */ + absencesDeleted: { id: number; startDate: Date; endDate: Date }[] + /** How many of its other events lost their author. */ + eventsUnattributed: number +} + +/** + * Lets go of the events an account created, before the account is deleted (from Réglages, or by taking a login away + * from a record): `Event.createdBy` is Restrict, so the account could not go otherwise. + * + * Its absences go with an account that has no record — nobody else is away on them, and they flagged no assignment, + * since absences flag through the record. An account with a record and absences is refused (AccountHasAbsencesError). + * Its other events lose their author and keep their origin, so a hand-made one never becomes an empty meeting a + * template may move or delete. + */ +export async function releaseAccountEvents( + db: TransactionClient, + account: { id: number; memberId: number | null }, + congregationId: number, +): Promise { + const absences = await db.event.findMany({ + where: { congregationId, createdById: account.id, template: { key: EventTemplateKey.DayOff } }, + select: { id: true, startDate: true, endDate: true }, + orderBy: { id: 'asc' }, + }) + if (account.memberId != null && absences.length > 0) throw new AccountHasAbsencesError('The account has absences') + + if (absences.length > 0) { + await db.event.deleteMany({ where: { congregationId, id: { in: absences.map(absence => absence.id) } } }) + } + const unattributed = await db.event.updateMany({ + where: { congregationId, createdById: account.id }, + data: { createdById: null }, + }) + return { absencesDeleted: absences, eventsUnattributed: unattributed.count } +} diff --git a/app/features/events/server/create-meeting-programme.server.test.ts b/app/features/events/server/create-meeting-programme.server.test.ts index 3b8292c4..8f5bccf1 100644 --- a/app/features/events/server/create-meeting-programme.server.test.ts +++ b/app/features/events/server/create-meeting-programme.server.test.ts @@ -31,6 +31,7 @@ const MEETING = { templateId: 270, startDate: new Date('2026-11-19T23:30:00Z'), createdById: null, + origin: 'job', _count: { eventParts: 0, eventServiceParts: 0 }, } @@ -55,7 +56,7 @@ describe('createMeetingProgramme', () => { expect(db.event.update).toHaveBeenCalledWith({ where: { id_congregationId: { id: 55, congregationId: 7 } }, - data: { createdById: 42 }, + data: { createdById: 42, origin: 'manual' }, }) }) diff --git a/app/features/events/server/create-meeting-programme.server.ts b/app/features/events/server/create-meeting-programme.server.ts index 7afd254b..0c902e5a 100644 --- a/app/features/events/server/create-meeting-programme.server.ts +++ b/app/features/events/server/create-meeting-programme.server.ts @@ -1,3 +1,4 @@ +import { EventOrigin } from '~/features/events/model/event-origin.type' import { isSystemTemplate } from '~/features/events/model/event-template.type' import { giveProgramme, lockTemplates, TEMPLATE_INCLUDE } from '~/features/events/server/give-programme.server' import { @@ -33,6 +34,7 @@ export async function createMeetingProgramme( templateId: true, startDate: true, createdById: true, + origin: true, _count: { select: { eventParts: true, eventServiceParts: true } }, }, }) @@ -45,10 +47,14 @@ export async function createMeetingProgramme( if (template.parts.length === 0 && template.serviceParts.length === 0) return null if (event._count.eventParts > 0 || event._count.eventServiceParts > 0) throw new ProgrammeExistsError(event.id) - if (event.createdById == null) { + // Whoever gives it its programme prepares it when nobody is named; a meeting the job made is no longer the job's. + if (event.createdById == null || event.origin === EventOrigin.Job) { await db.event.update({ where: { id_congregationId: { id: event.id, congregationId } }, - data: { createdById: ctx.actorId }, + data: { + createdById: event.createdById ?? ctx.actorId, + ...(event.origin === EventOrigin.Job && { origin: EventOrigin.Manual }), + }, }) } return giveProgramme(db, template, event.id, dayOf(event.startDate, ctx.timezone), ctx, { reused: true }) diff --git a/app/features/events/server/days-off.queries.ts b/app/features/events/server/days-off.queries.ts index 6a803164..77602dd9 100644 --- a/app/features/events/server/days-off.queries.ts +++ b/app/features/events/server/days-off.queries.ts @@ -106,7 +106,8 @@ export async function listCongregationAbsences( orderBy: [{ startDate: 'asc' }, { id: 'asc' }], }) // Absences belong to the account that declared them; the person away is its member, when it has one. A day-off - // always has that account (Event.createdBy is Restrict); only events made by the recurring job have none. + // always has that account (Event.createdBy is Restrict, and deleting an account takes its absences with it or is + // refused); events without an author are never absences. const absences = rows.flatMap(({ createdBy, createdAt, ...row }) => createdBy == null ? [] diff --git a/app/features/events/server/delete-template.server.test.ts b/app/features/events/server/delete-template.server.test.ts index ef3632b6..0e38bfef 100644 --- a/app/features/events/server/delete-template.server.test.ts +++ b/app/features/events/server/delete-template.server.test.ts @@ -52,7 +52,7 @@ describe('deleteTemplate', () => { const result = await deleteTemplate(db, 7, 1, 9) const empty = { - createdById: null, + origin: 'job', eventParts: { none: {} }, eventServiceParts: { none: {} }, attendance: { is: null }, diff --git a/app/features/events/server/empty-meetings.integration.test.ts b/app/features/events/server/empty-meetings.integration.test.ts index c79ee3b3..5027c1b0 100644 --- a/app/features/events/server/empty-meetings.integration.test.ts +++ b/app/features/events/server/empty-meetings.integration.test.ts @@ -32,6 +32,7 @@ const { moveEmptyMeetings } = await import('./move-empty-meetings.server') const { createMeetingProgramme } = await import('./create-meeting-programme.server') const { listProgrammes } = await import('./programme-list.queries') const { ProgrammeExistsError } = await import('./programme-creation.server') +const { updateEvent } = await import('./event-parts.server') const PARIS = 'Europe/Paris' // Monday 16 November 2026, 10:00 in Paris. @@ -66,9 +67,18 @@ beforeAll(async () => { }, }) ).id + // The job's meetings: no author, nothing on them. const meeting = (day: string, extra: object = {}) => tx.event.create({ - data: { name: 'Réunion de semaine', templateId, status: 'draft', congregationId, ...tuesday(day), ...extra }, + data: { + name: 'Réunion de semaine', + templateId, + status: 'draft', + origin: 'job', + congregationId, + ...tuesday(day), + ...extra, + }, }) ids.week1 = (await meeting('2026-11-17')).id ids.week2 = (await meeting('2026-11-24')).id @@ -76,6 +86,8 @@ beforeAll(async () => { // Counted already: attendance keeps a meeting where it is. ids.counted = (await meeting('2026-12-08')).id await tx.attendance.create({ data: { eventId: ids.counted, inPerson: 80, congregationId } }) + // Made by hand, its author's account since deleted: empty and without an author, but nobody's to move or delete. + ids.handMade = (await meeting('2026-12-15', { origin: 'manual' })).id // The week of 30 November already has its programme on the Thursday. ids.prepared = ( await tx.event.create({ @@ -121,6 +133,45 @@ const days = () => ) describe('empty meetings against the database', () => { + // Made by hand, its author's account since deleted: « Créer le programme » names whoever prepares it, keeps its day. + it('names whoever gives a hand-made meeting without an author its programme, leaving it where it is', async () => { + const day = tuesday('2027-01-12') + const id = await withScope(congregationId, async tx => { + const meeting = await tx.event.create({ + data: { name: 'Réunion déplacée', templateId, status: 'draft', origin: 'manual', congregationId, ...day }, + }) + await createMeetingProgramme(tx, meeting.id, { congregationId, timezone: PARIS, actorId }) + return meeting.id + }) + + const prepared = await withScope(congregationId, tx => + tx.event.findFirst({ where: { id }, select: { name: true, startDate: true, createdById: true, origin: true } }), + ) + expect(prepared).toEqual({ + name: 'Réunion déplacée', + startDate: day.startDate, + createdById: actorId, + origin: 'manual', + }) + await withScope(congregationId, tx => tx.event.delete({ where: { id } })) + }) + + it('makes a meeting the job created someone’s once they move it by hand', async () => { + const id = await withScope(congregationId, async tx => { + const meeting = await tx.event.create({ + data: { name: 'Réunion', templateId, status: 'draft', origin: 'job', congregationId, ...tuesday('2027-01-05') }, + }) + await updateEvent(tx, meeting.id, congregationId, tuesday('2027-01-06'), actorId) + return meeting.id + }) + + const moved = await withScope(congregationId, tx => + tx.event.findFirst({ where: { id }, select: { origin: true, createdById: true } }), + ) + expect(moved).toEqual({ origin: 'manual', createdById: actorId }) + await withScope(congregationId, tx => tx.event.delete({ where: { id } })) + }) + it('lists the empty meetings as waiting for their programme, and not the prepared or counted ones', async () => { const rows = await withScope(congregationId, tx => listProgrammes(tx, { congregationId, from: NOW, to: new Date('2026-12-31T00:00:00Z') }), @@ -142,6 +193,7 @@ describe('empty meetings against the database', () => { expect(after[ids.week3]).toBeUndefined() expect(after[ids.counted]).toBe('2026-12-08') expect(after[ids.prepared]).toBe('2026-12-03') + expect(after[ids.handMade]).toBe('2026-12-15') expect(await withScope(congregationId, tx => countMeetingsToMove(tx, templateId, ctx()))).toBe(0) }) @@ -154,10 +206,11 @@ describe('empty meetings against the database', () => { const event = await withScope(congregationId, tx => tx.event.findFirst({ where: { id: ids.week1 }, - select: { createdById: true, _count: { select: { eventParts: true } } }, + select: { createdById: true, origin: true, _count: { select: { eventParts: true } } }, }), ) - expect(event).toEqual({ createdById: actorId, _count: { eventParts: 1 } }) + // Prepared by someone: theirs from now on, even emptied again or once their account goes. + expect(event).toEqual({ createdById: actorId, origin: 'manual', _count: { eventParts: 1 } }) await expect( withScope(congregationId, tx => diff --git a/app/features/events/server/empty-meetings.queries.ts b/app/features/events/server/empty-meetings.queries.ts index fa49fea5..d9aa78b8 100644 --- a/app/features/events/server/empty-meetings.queries.ts +++ b/app/features/events/server/empty-meetings.queries.ts @@ -1,14 +1,16 @@ import { planMeetingMoves } from '~/features/events/model/empty-meetings' +import { EventOrigin } from '~/features/events/model/event-origin.type' import { EventStatus } from '~/features/events/model/event-status.type' import type { TransactionClient } from '~/shared/infra/db.server' import { addDays, dayOf, startOfDay } from '~/shared/utils/calendar-day' /** - * An empty meeting the recurring-events job created ahead: no author, no part, no service, no attendance. Every - * recurring template has some; they are the only events that move with it, or go with it. + * An empty meeting the recurring-events job created ahead: origin « job », no part, no service, no attendance. Every + * recurring template has some; they are the only events that move with it, or go with it. Not its author: deleting an + * account clears the author of what it made, which must never turn into something a template may move or delete. */ export const EMPTY_MEETING = { - createdById: null, + origin: EventOrigin.Job, eventParts: { none: {} }, eventServiceParts: { none: {} }, attendance: { is: null }, diff --git a/app/features/events/server/event-parts.server.test.ts b/app/features/events/server/event-parts.server.test.ts index 80d22fdb..cdcb3d72 100644 --- a/app/features/events/server/event-parts.server.test.ts +++ b/app/features/events/server/event-parts.server.test.ts @@ -177,14 +177,14 @@ describe('updateEvent', () => { // A meeting created ahead that someone moves for one week is theirs now: the template's « Déplacer les réunions à // venir » never sends it back, and the recurring-events job's clean-ups leave it alone. - it('makes whoever moves a meeting nobody created its author, and leaves an author in place', async () => { + it('makes whoever moves a meeting the job created its author, and leaves an author in place', async () => { mockDb.event.update.mockResolvedValue({ id: 2 }) await updateEvent(mockDb as never, 2, 10, { startDate: new Date('2026-11-17T18:00:00Z') }, 99) expect(mockDb.event.updateMany).toHaveBeenCalledWith({ - where: { id: 2, congregationId: 10, createdById: null }, - data: { createdById: 99 }, + where: { id: 2, congregationId: 10, origin: 'job' }, + data: { origin: 'manual', createdById: 99 }, }) }) diff --git a/app/features/events/server/event-parts.server.ts b/app/features/events/server/event-parts.server.ts index 47f78264..c49ff21e 100644 --- a/app/features/events/server/event-parts.server.ts +++ b/app/features/events/server/event-parts.server.ts @@ -1,3 +1,4 @@ +import { EventOrigin } from '~/features/events/model/event-origin.type' import { EventTemplateKey } from '~/features/events/model/event-template.type' import { setPartAssignmentAllowedRoles, @@ -58,9 +59,12 @@ export async function updateEvent( actorId: number, ) { // A meeting created ahead that someone moves is theirs from then on: the template's offer to move its upcoming - // meetings, and the clean-ups of meetings nobody created, leave it where it was put. + // meetings, and the clean-ups of the job's empty meetings, leave it where it was put. if (data.startDate !== undefined || data.endDate !== undefined) { - await db.event.updateMany({ where: { id, congregationId, createdById: null }, data: { createdById: actorId } }) + await db.event.updateMany({ + where: { id, congregationId, origin: EventOrigin.Job }, + data: { origin: EventOrigin.Manual, createdById: actorId }, + }) } const event = await db.event.update({ where: { id_congregationId: { id, congregationId } }, data }) audit({ diff --git a/app/features/events/server/member-engagement.queries.integration.test.ts b/app/features/events/server/member-engagement.queries.integration.test.ts new file mode 100644 index 00000000..0f28c61d --- /dev/null +++ b/app/features/events/server/member-engagement.queries.integration.test.ts @@ -0,0 +1,84 @@ +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { PrismaClient } from '~/database/generated/client' + +// A publisher's record names their assignments: the coming ones, and the last one done. Several in one meeting are +// read in the programme's order — parts, then services — not in whatever order the table returns them, so the record +// reads the same every time. + +const adapter = new PrismaPg({ + connectionString: process.env.DB_RUNTIME_URL ?? process.env.DB_URL, + max: 3, + connectionTimeoutMillis: 5000, +}) +const testDb = new PrismaClient({ adapter }) + +type Tx = Parameters[0]>[0] + +function withScope(congregationId: number, fn: (tx: Tx) => Promise): Promise { + return testDb.$transaction(async tx => { + await tx.$executeRawUnsafe(`SET LOCAL app.congregation_id = '${String(congregationId)}'`) + return fn(tx) + }) +} + +const { findLastAssignmentsForMembers, findUpcomingAssignmentsForMember } = await import('./member-engagement.queries') + +const ts = Date.now() +const ids = { cong: 0, member: 0 } +const NOW = new Date('2027-03-03T09:00:00Z') + +beforeAll(async () => { + ids.cong = ( + await testDb.congregation.create({ data: { name: `Engagement ${ts}`, slug: `engagement-${ts}`, active: true } }) + ).id + await withScope(ids.cong, async tx => { + const congregationId = ids.cong + ids.member = (await tx.member.create({ data: { firstname: 'Paul', lastname: 'MARTIN', congregationId } })).id + // One meeting done, one to come; each with two parts and a service created in an order the programme does not + // follow. + for (const day of ['2027-02-23T18:00:00Z', '2027-03-09T18:00:00Z']) { + const startDate = new Date(day) + const event = await tx.event.create({ + data: { name: 'Réunion', startDate, endDate: startDate, status: 'released', congregationId }, + }) + const held = { eventId: event.id, assigneeId: ids.member, congregationId } + await tx.eventServicePart.create({ data: { name: 'Sono', order: 0, ...held } }) + await tx.eventPart.create({ data: { name: 'Cantique de conclusion', order: 20, ...held } }) + await tx.eventPart.create({ data: { name: 'Cantique et prière', order: 0, ...held } }) + } + }) +}) + +afterAll(async () => { + if (ids.cong) { + await withScope(ids.cong, async tx => { + await tx.event.deleteMany({}) + await tx.member.deleteMany({}) + }) + await testDb.congregation.deleteMany({ where: { id: ids.cong } }) + } + await testDb.$disconnect() +}) + +describe('a publisher’s assignments within one meeting', () => { + it('lists the coming ones in the programme’s order: parts, then services', async () => { + const upcoming = await withScope(ids.cong, tx => + findUpcomingAssignmentsForMember(tx, ids.member as never, ids.cong as never, NOW), + ) + + expect(upcoming.map(assignment => assignment.partName)).toEqual([ + 'Cantique et prière', + 'Cantique de conclusion', + 'Sono', + ]) + }) + + it('names the first of the meeting’s parts as the last assignment done', async () => { + const last = await withScope(ids.cong, tx => + findLastAssignmentsForMembers(tx, [ids.member as never], ids.cong as never, NOW), + ) + + expect(last.get(ids.member as never)?.partName).toBe('Cantique et prière') + }) +}) diff --git a/app/features/events/server/member-engagement.queries.ts b/app/features/events/server/member-engagement.queries.ts index 5e2fe90e..0cacf058 100644 --- a/app/features/events/server/member-engagement.queries.ts +++ b/app/features/events/server/member-engagement.queries.ts @@ -1,3 +1,4 @@ +import type { Prisma } from '~/database/generated/client' import { EventStatus } from '~/features/events/model/event-status.type' import { EventTemplateKey } from '~/features/events/model/event-template.type' import type { MemberAbsence, MemberAssignment } from '~/features/events/model/member-engagement.type' @@ -6,6 +7,16 @@ import type { CongregationId, MemberId } from '~/shared/types/branded' const MAX_ASSIGNMENTS = 5 +/** + * One meeting's assignments in the programme's order, so a record reads the same every time. Coming ones: the date sort + * is stable, so parts then services, each in theirs. Last done: `keep` only replaces on a later date, so the meeting's + * first assignment wins. + */ +const PROGRAMME_ORDER = [{ event: { startDate: 'asc' } }, { order: 'asc' }, { id: 'asc' }] as const satisfies ( + | Prisma.EventPartOrderByWithRelationInput + | Prisma.EventServicePartOrderByWithRelationInput +)[] + /** * Upcoming released parts and service parts a member holds (as assignee or * assistant), for the publisher record page. Read-only companion to the @@ -34,13 +45,13 @@ export async function findUpcomingAssignmentsForMember( db.eventPart.findMany({ where: { OR: [{ assigneeId: memberId }, { assistantId: memberId }], event: eventFilter }, select, - orderBy: { event: { startDate: 'asc' } }, + orderBy: PROGRAMME_ORDER, take: MAX_ASSIGNMENTS, }), db.eventServicePart.findMany({ where: { assigneeId: memberId, event: eventFilter }, select, - orderBy: { event: { startDate: 'asc' } }, + orderBy: PROGRAMME_ORDER, take: MAX_ASSIGNMENTS, }), ]) @@ -118,10 +129,12 @@ export async function findLastAssignmentsForMembers( db.eventPart.findMany({ where: { OR: [{ assigneeId: { in: memberIds } }, { assistantId: { in: memberIds } }], event }, select: { name: true, assigneeId: true, assistantId: true, event: { select: { startDate: true } } }, + orderBy: PROGRAMME_ORDER, }), db.eventServicePart.findMany({ where: { assigneeId: { in: memberIds }, event }, select: { name: true, assigneeId: true, event: { select: { startDate: true } } }, + orderBy: PROGRAMME_ORDER, }), ]) diff --git a/app/features/events/server/programme-creation.server.test.ts b/app/features/events/server/programme-creation.server.test.ts index cec5796e..a5ee9ff2 100644 --- a/app/features/events/server/programme-creation.server.test.ts +++ b/app/features/events/server/programme-creation.server.test.ts @@ -105,7 +105,7 @@ const WITH_PART = { }, ], } -const BARE = { createdById: null, attendance: null, _count: { eventParts: 0, eventServiceParts: 0 } } +const BARE = { createdById: null, origin: 'job', attendance: null, _count: { eventParts: 0, eventServiceParts: 0 } } describe('bare events', () => { it('gives a bare event of the series its programme instead of creating a second one', async () => { @@ -168,11 +168,31 @@ describe('bare events, edge cases', () => { CTX, ) - expect(db.event.deleteMany).toHaveBeenCalledWith({ where: { id: 55, congregationId: 7 } }) + expect(db.event.deleteMany).toHaveBeenCalledWith({ + where: expect.objectContaining({ id: 55, congregationId: 7, origin: 'job' }), + }) expect(db.eventPart.create).not.toHaveBeenCalled() expect(result).toMatchObject({ created: [], skipped: 1 }) }) + // Made by hand, its author's account since deleted: empty and without an author, but not the job's to delete. + it('leaves a hand-made meeting on a day the series passes on purpose', async () => { + vi.mocked(db.eventTemplate.findMany).mockResolvedValue([WITH_PART] as never) + vi.mocked(db.event.findMany).mockResolvedValue([ + { id: 55, templateId: 270, startDate: new Date('2026-11-19T23:00:00Z'), ...BARE, origin: 'manual' }, + ] as never) + recordEvents() + + const result = await createProgrammeSeries( + db, + { templateIds: [270], from: '2026-11-16', to: '2026-11-22', skip: ['270:2026-11-19'] }, + CTX, + ) + + expect(db.event.deleteMany).not.toHaveBeenCalled() + expect(result).toMatchObject({ created: [], skipped: 1 }) + }) + it('sets a reused meeting’s hours and name from the template again', async () => { vi.mocked(db.eventTemplate.findMany).mockResolvedValue([WITH_PART] as never) vi.mocked(db.event.findMany).mockResolvedValue([ @@ -184,7 +204,7 @@ describe('bare events, edge cases', () => { expect(vi.mocked(db.event.update).mock.calls[0]?.[0]).toMatchObject({ where: { id_congregationId: { id: 55, congregationId: 7 } }, - data: { name: 'Réunion de semaine', createdById: 42 }, + data: { name: 'Réunion de semaine', createdById: 42, origin: 'manual' }, }) expect(hour(vi.mocked(db.event.update).mock.calls[0]?.[0]?.data?.startDate as Date)).toBe('19:00') }) @@ -193,7 +213,14 @@ describe('bare events, edge cases', () => { it('fills a meeting whose programme was removed, and one with counts, when asked for the series', async () => { vi.mocked(db.eventTemplate.findMany).mockResolvedValue([WITH_PART] as never) vi.mocked(db.event.findMany).mockResolvedValue([ - { id: 55, templateId: 270, startDate: new Date('2026-11-19T23:00:00Z'), ...BARE, createdById: 9 }, + { + id: 55, + templateId: 270, + startDate: new Date('2026-11-19T23:00:00Z'), + ...BARE, + createdById: 9, + origin: 'manual', + }, { id: 56, templateId: 270, startDate: new Date('2026-11-26T23:00:00Z'), ...BARE, attendance: { id: 1 } }, ] as never) recordEvents() @@ -204,10 +231,32 @@ describe('bare events, edge cases', () => { expect(result.existing).toBe(0) }) + // Made by hand, its author's account since deleted: whoever fills it prepares it, as « Créer le programme » does. + it('names whoever fills a hand-made meeting without an author, leaving its name and hours', async () => { + vi.mocked(db.eventTemplate.findMany).mockResolvedValue([WITH_PART] as never) + vi.mocked(db.event.findMany).mockResolvedValue([ + { id: 55, templateId: 270, startDate: new Date('2026-11-19T23:00:00Z'), ...BARE, origin: 'manual' }, + ] as never) + recordEvents() + + await createProgrammeSeries(db, { templateIds: [270], from: '2026-11-16', to: '2026-11-22' }, CTX) + + expect(vi.mocked(db.event.update).mock.calls.map(([args]) => args)).toEqual([ + { where: { id_congregationId: { id: 55, congregationId: 7 } }, data: { createdById: 42 } }, + ]) + }) + it('keeps the author, name and hours of a meeting someone prepared before', async () => { vi.mocked(db.eventTemplate.findMany).mockResolvedValue([WITH_PART] as never) vi.mocked(db.event.findMany).mockResolvedValue([ - { id: 55, templateId: 270, startDate: new Date('2026-11-19T23:00:00Z'), ...BARE, createdById: 9 }, + { + id: 55, + templateId: 270, + startDate: new Date('2026-11-19T23:00:00Z'), + ...BARE, + createdById: 9, + origin: 'manual', + }, ] as never) recordEvents() @@ -238,7 +287,7 @@ describe('bare events, edge cases', () => { it('fills a counted meeting without a programme when created on its day', async () => { vi.mocked(db.eventTemplate.findFirst).mockResolvedValue(WITH_PART as never) vi.mocked(db.event.findMany).mockResolvedValue([ - { id: 56, ...BARE, createdById: 9, attendance: { id: 1 } }, + { id: 56, ...BARE, createdById: 9, origin: 'manual', attendance: { id: 1 } }, ] as never) recordEvents() diff --git a/app/features/events/server/programme-creation.server.ts b/app/features/events/server/programme-creation.server.ts index 162bbe40..0a32f276 100644 --- a/app/features/events/server/programme-creation.server.ts +++ b/app/features/events/server/programme-creation.server.ts @@ -1,5 +1,7 @@ +import { EventOrigin } from '~/features/events/model/event-origin.type' import { SYSTEM_TEMPLATE_KEYS } from '~/features/events/model/event-template.type' import { daysOnWeekday, programmeKey } from '~/features/events/model/programme-dates' +import { EMPTY_MEETING } from '~/features/events/server/empty-meetings.queries' import { giveProgramme, lockTemplates, @@ -135,7 +137,8 @@ function hasProgramme(template: TemplateWithRelations): boolean { /** Deletes an empty meeting created ahead on a day the series passes on purpose. */ async function removeEmptyMeeting(db: TransactionClient, eventId: number, ctx: CreationContext) { - await db.event.deleteMany({ where: { id: eventId, congregationId: ctx.congregationId } }) + // Checked again in the query: only the job's empty meeting goes, whatever the caller read. + await db.event.deleteMany({ where: { id: eventId, congregationId: ctx.congregationId, ...EMPTY_MEETING } }) await auditInTransaction(db, { action: AuditAction.EventDeleted, congregationId: ctx.congregationId, @@ -148,25 +151,37 @@ async function removeEmptyMeeting(db: TransactionClient, eventId: number, ctx: C /** * Gives a meeting without a programme its template's programme. One the recurring-events job created ahead gets its * hours and name from the template and the congregation's zone first — they may have changed since — and the person as - * its author. One someone prepared before, then emptied, keeps its author, name and hours. + * its author. One made by hand, or prepared before and then emptied, keeps its name and hours, and its author unless + * it has none. */ async function fillMeeting( db: TransactionClient, template: TemplateWithRelations, - event: { id: number; createdById?: number | null }, + event: { id: number; createdById?: number | null; origin?: string }, day: string, ctx: CreationContext, ): Promise { const eventId = event.id - if (event.createdById != null) return giveProgramme(db, template, eventId, day, ctx, { reused: true }) + if (event.origin !== EventOrigin.Job) { + // Not the job's (made by hand or restored): its name and hours stay. Whoever fills it prepares it when nobody is + // named — its author's account may have gone — as « Créer le programme » does. + if (event.createdById == null) { + await db.event.update({ + where: { id_congregationId: { id: eventId, congregationId: ctx.congregationId } }, + data: { createdById: ctx.actorId }, + }) + } + return giveProgramme(db, template, eventId, day, ctx, { reused: true }) + } await db.event.update({ where: { id_congregationId: { id: eventId, congregationId: ctx.congregationId } }, data: { name: template.name, startDate: combineLocalDateTime(day, template.startTime, ctx.timezone), endDate: combineLocalDateTime(day, template.endTime, ctx.timezone), - // Whoever gives it its programme prepares it: the meeting is no longer one nobody created. + // Whoever gives it its programme prepares it: the meeting is no longer the job’s. createdById: ctx.actorId, + origin: EventOrigin.Manual, }, }) return giveProgramme(db, template, eventId, day, ctx, { reused: true }) @@ -212,12 +227,14 @@ export async function createProgrammeOnDay( const EVENT_STATE = { id: true, createdById: true, + origin: true, attendance: { select: { id: true } }, _count: { select: { eventParts: true, eventServiceParts: true } }, } as const interface EventState { createdById?: number | null + origin?: string attendance?: { id: number } | null _count?: { eventParts: number; eventServiceParts: number } } @@ -228,11 +245,11 @@ function hasParts(event: EventState): boolean { } /** - * An empty meeting the recurring-events job created ahead: no author, no programme, no attendance. Only those may be - * deleted when a series passes their day — one someone prepared, or one with counts, stays. + * An empty meeting the recurring-events job created ahead (EMPTY_MEETING): origin « job », no programme, no attendance. Only + * those may be deleted when a series passes their day — one someone made or prepared, or one with counts, stays. */ function isEmptyMeeting(event: EventState): boolean { - return event.createdById === null && event.attendance == null && !hasParts(event) + return event.origin === EventOrigin.Job && event.attendance == null && !hasParts(event) } /** The events the templates already have between two days, by `programmeKey`: whether each has a programme, and whether @@ -240,6 +257,7 @@ function isEmptyMeeting(event: EventState): boolean { interface ExistingEvent { id: number createdById: number | null + origin: string /** It has parts or services. */ programme: boolean /** An empty meeting created ahead, which a passed day deletes. */ @@ -271,6 +289,7 @@ async function existingProgrammes( byDay.set(key, { id: event.id, createdById: event.createdById, + origin: event.origin, programme: hasParts(event), empty: isEmptyMeeting(event), }) diff --git a/app/features/events/server/recurring-events.server.test.ts b/app/features/events/server/recurring-events.server.test.ts index 9df36dd1..bfbc2098 100644 --- a/app/features/events/server/recurring-events.server.test.ts +++ b/app/features/events/server/recurring-events.server.test.ts @@ -64,6 +64,7 @@ describe('extendRecurringEvents', () => { endDate: new Date('2027-01-07T19:45:00Z'), status: 'draft', createdById: null, + origin: 'job', congregationId: 1, }, { @@ -73,6 +74,7 @@ describe('extendRecurringEvents', () => { endDate: new Date('2027-01-14T19:45:00Z'), status: 'draft', createdById: null, + origin: 'job', congregationId: 1, }, ]) @@ -182,7 +184,7 @@ describe('reanchorEmptyMeetings', () => { const [[{ where }]] = mockDb.event.findMany.mock.calls expect(where).toMatchObject({ congregationId: 1, - createdById: null, + origin: 'job', eventParts: { none: {} }, eventServiceParts: { none: {} }, attendance: { is: null }, diff --git a/app/features/events/server/recurring-events.server.ts b/app/features/events/server/recurring-events.server.ts index 66c22386..984113e0 100644 --- a/app/features/events/server/recurring-events.server.ts +++ b/app/features/events/server/recurring-events.server.ts @@ -1,6 +1,8 @@ +import { EventOrigin } from '~/features/events/model/event-origin.type' import { EventStatus } from '~/features/events/model/event-status.type' import { SYSTEM_TEMPLATE_KEYS } from '~/features/events/model/event-template.type' import { planRecurringEvents } from '~/features/events/model/recurring-events' +import { EMPTY_MEETING } from '~/features/events/server/empty-meetings.queries' import { AuditAction, auditInTransaction } from '~/shared/domain/audit.server' import type { TransactionClient } from '~/shared/infra/db.server' import { createLogger } from '~/shared/infra/logger.server' @@ -19,7 +21,8 @@ interface MeetingTemplate { /** * Creates empty meetings of a template on the given local days: its name and hours in the congregation's zone, draft, - * no author — a meeting nobody has prepared yet. Shared by the job and by a series that starts beyond the horizon. + * no author, origin « job » — a meeting nobody has prepared yet. Shared by the job and by a series that starts beyond + * the horizon. */ export async function createEmptyMeetings( db: TransactionClient, @@ -36,6 +39,7 @@ export async function createEmptyMeetings( endDate: combineLocalDateTime(day, template.endTime, timeZone), status: EventStatus.Draft, createdById: null, + origin: EventOrigin.Job, congregationId, })), }) @@ -146,10 +150,7 @@ export async function reanchorEmptyMeetings( const meetings = await db.event.findMany({ where: { congregationId, - createdById: null, - eventParts: { none: {} }, - eventServiceParts: { none: {} }, - attendance: { is: null }, + ...EMPTY_MEETING, templateId: { not: null }, startDate: { gte: input.now }, }, diff --git a/app/features/publishers/routes/publishers/unlink-login.tsx b/app/features/publishers/routes/publishers/unlink-login.tsx index c95a08a2..504d3edc 100644 --- a/app/features/publishers/routes/publishers/unlink-login.tsx +++ b/app/features/publishers/routes/publishers/unlink-login.tsx @@ -1,5 +1,6 @@ import { redirect } from 'react-router' import { commitSession, getSession } from '~/features/authentication/index.server' +import { AccountHasAbsencesError } from '~/features/events/index.server' import { unlinkAccountFromMember } from '~/features/publishers/server/unlink-account-from-member.server' import * as m from '~/i18n/paraglide/messages' import { currentAccountContext, permissionsContext, withScopeFromContext } from '~/shared/auth/route-context.server' @@ -18,6 +19,7 @@ export function loader() { function unlinkRefusal(error: OwnAccountError | GrantBeyondActorError | ConflictError): string { if (error instanceof OwnAccountError) return m.settings_user_own_account() if (error instanceof GrantBeyondActorError) return m.settings_user_admin_only() + if (error instanceof AccountHasAbsencesError) return m.settings_user_has_absences() return m.settings_user_last_admin() } diff --git a/app/features/publishers/server/unlink-account-from-member.server.integration.test.ts b/app/features/publishers/server/unlink-account-from-member.server.integration.test.ts new file mode 100644 index 00000000..51422f04 --- /dev/null +++ b/app/features/publishers/server/unlink-account-from-member.server.integration.test.ts @@ -0,0 +1,111 @@ +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { PrismaClient } from '~/database/generated/client' + +// « Retirer la connexion » on a record deletes the login, by the same rules as deleting it from Réglages: it must not +// end in a foreign-key error on the events the login created. A record's absences are the person's, so a login whose +// record has some is refused; its other events lose their author and stay what they were. + +const adapter = new PrismaPg({ + connectionString: process.env.DB_RUNTIME_URL ?? process.env.DB_URL, + max: 3, + connectionTimeoutMillis: 5000, +}) +const testDb = new PrismaClient({ adapter }) + +type Tx = Parameters[0]>[0] + +function withScope(congregationId: number, fn: (tx: Tx) => Promise): Promise { + return testDb.$transaction(async tx => { + await tx.$executeRawUnsafe(`SET LOCAL app.congregation_id = '${String(congregationId)}'`) + return fn(tx) + }) +} + +const { unlinkAccountFromMember } = await import('./unlink-account-from-member.server') +const { AccountHasAbsencesError } = await import('~/features/events/index.server') +const { Permission } = await import('~/shared/types/permission') + +const ADMIN = new Set([Permission.CanDoAnything]) +const ts = Date.now() +const ids = { cong: 0, admin: 0, dayOffTemplate: 0, meetingTemplate: 0 } +const DAY = new Date('2027-01-12T18:00:00Z') + +beforeAll(async () => { + ids.cong = ( + await testDb.congregation.create({ data: { name: `Unlink ${ts}`, slug: `unlink-${ts}`, active: true } }) + ).id + await withScope(ids.cong, async tx => { + const congregationId = ids.cong + const adminRole = await tx.role.create({ data: { key: 'admin', isBuiltIn: true, congregationId } }) + ids.admin = ( + await tx.userAccount.create({ data: { email: `admin-${ts}@test.com`, password: 'x', congregationId } }) + ).id + await tx.userRoleAssignment.create({ data: { userId: ids.admin, roleId: adminRole.id, congregationId } }) + ids.dayOffTemplate = ( + await tx.eventTemplate.create({ data: { name: 'Absence', key: 'day-off', congregationId } }) + ).id + ids.meetingTemplate = ( + await tx.eventTemplate.create({ data: { name: 'Réunion de semaine', key: 'midweek-meeting', congregationId } }) + ).id + }) +}) + +afterAll(async () => { + if (ids.cong) { + await withScope(ids.cong, async tx => { + await tx.event.deleteMany({}) + await tx.eventTemplate.deleteMany({}) + await tx.userRoleAssignment.deleteMany({}) + await tx.userAccount.deleteMany({}) + await tx.member.deleteMany({}) + await tx.role.deleteMany({}) + }) + await testDb.auditLog.deleteMany({ where: { congregationId: ids.cong } }) + await testDb.congregation.deleteMany({ where: { id: ids.cong } }) + } + await testDb.$disconnect() +}) + +/** A record with a login, an absence when asked, and an empty meeting the login made by hand. */ +function personWithLogin(name: string, { absence }: { absence: boolean }) { + return withScope(ids.cong, async tx => { + const congregationId = ids.cong + const memberId = (await tx.member.create({ data: { firstname: name, lastname: 'TEST', congregationId } })).id + const accountId = ( + await tx.userAccount.create({ + data: { email: `${name}-${ts}@test.com`, password: 'x', memberId, congregationId }, + }) + ).id + const event = (templateId: number) => + tx.event.create({ + data: { name, startDate: DAY, endDate: DAY, templateId, createdById: accountId, congregationId }, + }) + const absenceId = absence ? (await event(ids.dayOffTemplate)).id : null + const meetingId = (await event(ids.meetingTemplate)).id + return { memberId, accountId, absenceId, meetingId } + }) +} + +const unlink = (memberId: number) => + withScope(ids.cong, tx => unlinkAccountFromMember(tx, memberId as never, ids.cong, ids.admin, ADMIN)) + +const event = (id: number) => + withScope(ids.cong, tx => tx.event.findFirst({ where: { id }, select: { createdById: true, origin: true } })) + +describe('unlinkAccountFromMember and the events the login created', () => { + it('removes a login that made a programme, clearing its author', async () => { + const { memberId, accountId, meetingId } = await personWithLogin('Retrait', { absence: false }) + + expect(await unlink(memberId)).toEqual({ accountId, email: `Retrait-${ts}@test.com` }) + expect(await event(meetingId)).toEqual({ createdById: null, origin: 'manual' }) + }) + + it('refuses a login whose record has absences, changing nothing', async () => { + const { memberId, accountId, absenceId, meetingId } = await personWithLogin('Absent', { absence: true }) + + await expect(unlink(memberId)).rejects.toBeInstanceOf(AccountHasAbsencesError) + expect(await event(absenceId as number)).toEqual({ createdById: accountId, origin: 'manual' }) + expect(await event(meetingId)).toEqual({ createdById: accountId, origin: 'manual' }) + }) +}) diff --git a/app/features/publishers/server/unlink-account-from-member.server.test.ts b/app/features/publishers/server/unlink-account-from-member.server.test.ts index 6c6815ff..18f49dfa 100644 --- a/app/features/publishers/server/unlink-account-from-member.server.test.ts +++ b/app/features/publishers/server/unlink-account-from-member.server.test.ts @@ -8,6 +8,9 @@ vi.mock('~/shared/domain/audit.server', () => ({ audit: vi.fn(), })) vi.mock('~/shared/infra/db.server', () => ({ unscopedDb: { auditLog: { create: vi.fn() } } })) +vi.mock('~/features/events/index.server', () => ({ + releaseAccountEvents: vi.fn(async () => ({ absencesDeleted: [], eventsUnattributed: 0 })), +})) vi.mock('~/shared/auth/permissions.server', async () => { const { ConflictError } = await import('~/shared/errors/app-error.server') return { @@ -103,7 +106,7 @@ describe('unlinkAccountFromMember', () => { actorId: 99, entityType: 'UserAccount', entityId: 42, - metadata: { memberId: 1, email: 'a@b.test' }, + metadata: { memberId: 1, email: 'a@b.test', eventsUnattributed: 0 }, }), ) }) diff --git a/app/features/publishers/server/unlink-account-from-member.server.ts b/app/features/publishers/server/unlink-account-from-member.server.ts index 2e3ffd91..a43ab3fb 100644 --- a/app/features/publishers/server/unlink-account-from-member.server.ts +++ b/app/features/publishers/server/unlink-account-from-member.server.ts @@ -1,3 +1,4 @@ +import { releaseAccountEvents } from '~/features/events/index.server' import { requireNotLastAdmin } from '~/shared/auth/permissions.server' import { assertMayActOnAccount } from '~/shared/domain/account-protection.server' import { AuditAction, audit } from '~/shared/domain/audit.server' @@ -34,6 +35,8 @@ export async function unlinkAccountFromMember( // Taking a login away deletes the account: the same rules as deleting it from Réglages. await assertMayActOnAccount({ accountId, actorId, congregationId, actorPermissions, action: 'delete' }) await requireNotLastAdmin(accountId, congregationId) + // A record's absences refuse it; the login's other events lose their author. + const released = await releaseAccountEvents(db, { id: accountId, memberId }, congregationId) await db.userAccount.delete({ where: { id_congregationId: { id: accountId, congregationId } } }) audit({ @@ -42,7 +45,7 @@ export async function unlinkAccountFromMember( actorId, entityType: 'UserAccount', entityId: accountId, - metadata: { memberId, email }, + metadata: { memberId, email, eventsUnattributed: released.eventsUnattributed }, }) return { accountId, email } diff --git a/app/features/settings/routes/_account-refusal.server.test.ts b/app/features/settings/routes/_account-refusal.server.test.ts index 3799e5b8..424bf28b 100644 --- a/app/features/settings/routes/_account-refusal.server.test.ts +++ b/app/features/settings/routes/_account-refusal.server.test.ts @@ -1,4 +1,5 @@ import { describe, expect, it } from 'vitest' +import { AccountHasAbsencesError } from '~/features/events/index.server' import { LastAdminError } from '~/shared/auth/permissions.server' import { OwnAccountError } from '~/shared/domain/account-protection.server' import { GrantBeyondActorError } from '~/shared/domain/role-grant-limits.server' @@ -6,9 +7,14 @@ import { accountRefusal } from './_account-refusal.server' describe('accountRefusal', () => { it('says why an action on an account was refused', () => { - const refusals = [new OwnAccountError(), new LastAdminError(), new GrantBeyondActorError()].map(accountRefusal) + const refusals = [ + new OwnAccountError(), + new LastAdminError(), + new GrantBeyondActorError(), + new AccountHasAbsencesError(), + ].map(accountRefusal) expect(refusals.every(text => typeof text === 'string' && text.length > 0)).toBe(true) - expect(new Set(refusals).size).toBe(3) + expect(new Set(refusals).size).toBe(4) }) it('says nothing for an error that is not a refusal', () => { diff --git a/app/features/settings/routes/_account-refusal.server.ts b/app/features/settings/routes/_account-refusal.server.ts index 44bbcc74..80674193 100644 --- a/app/features/settings/routes/_account-refusal.server.ts +++ b/app/features/settings/routes/_account-refusal.server.ts @@ -1,3 +1,4 @@ +import { AccountHasAbsencesError } from '~/features/events/index.server' import * as m from '~/i18n/paraglide/messages' import { LastAdminError } from '~/shared/auth/permissions.server' import { OwnAccountError } from '~/shared/domain/account-protection.server' @@ -8,5 +9,6 @@ export function accountRefusal(error: unknown): string | null { if (error instanceof OwnAccountError) return m.settings_user_own_account() if (error instanceof LastAdminError) return m.settings_user_last_admin() if (error instanceof GrantBeyondActorError) return m.settings_user_admin_only() + if (error instanceof AccountHasAbsencesError) return m.settings_user_has_absences() return null } diff --git a/app/features/settings/server/data-transfer.integration.test.ts b/app/features/settings/server/data-transfer.integration.test.ts index 0196bdf5..ccdf12e4 100644 --- a/app/features/settings/server/data-transfer.integration.test.ts +++ b/app/features/settings/server/data-transfer.integration.test.ts @@ -638,11 +638,12 @@ async function importFromZip(buffer: Buffer, congregationId: number): Promise { } }) }) + +// v2.18 carries each event's `origin`. An older archive has none: an event without an author and with nothing on it — +// what an empty meeting was — comes back as the job's, so it still moves with its template; any other as « import ». +describe('the origin of restored events', () => { + it('keeps a 2.18 archive’s origin and gives an older one’s by the migration’s rule', async () => { + const { importEvents, importEventParts, importEventServiceParts, settleImportedEventOrigins } = await import( + './import-events.server' + ) + const { importAttendance } = await import('./import-attendance.server') + const cong = await testDb.congregation.create({ + data: { name: `Origins ${ts}`, slug: `origins-${ts}`, active: true }, + }) + try { + const origins = await withScope(cong.id, async tx => { + const author = await tx.userAccount.create({ + data: { email: `origins-${ts}@test.com`, password: 'x', congregationId: cong.id }, + }) + const idMap = new EntityIdMap() + idMap.set('user-accounts', 70, author.id) + const day = '2027-02-02T18:00:00.000Z' + const event = (id: number, name: string, extra: object = {}) => ({ + id, + name, + description: '', + startDate: day, + endDate: day, + templateId: null, + createdById: null, + createdAt: day, + status: 'draft', + ...extra, + }) + const zip = new JsZip() + const dataDir = zip.folder('data')! + dataDir.file( + 'events.ndjson', + [ + event(1, 'old, empty, no author'), + event(2, 'old, an author', { createdById: 70 }), + event(3, 'old, a part'), + event(7, 'old, a service'), + event(8, 'old, counts'), + event(4, 'new, made by hand', { origin: 'manual' }), + event(5, 'new, the job’s', { origin: 'job' }), + event(6, 'new, unknown', { origin: 'bogus' }), + ] + .map(row => `${JSON.stringify(row)}\n`) + .join(''), + ) + dataDir.file( + 'programme-part-assignments.ndjson', + `${JSON.stringify({ + ...{ id: 1, topic: '', note: '', hasConflict: false, name: 'Cantique', section: '', track: '' }, + ...{ order: 0, durationMin: null, eventId: 3, partId: null, assigneeId: null, assistantId: null }, + })}\n`, + ) + + dataDir.file( + 'programme-service-role-assignments.ndjson', + `${JSON.stringify({ id: 1, note: '', hasConflict: false, name: 'Sono', eventId: 7, servicePartId: null, assigneeId: null })}\n`, + ) + dataDir.file( + 'attendance.ndjson', + `${JSON.stringify({ eventId: 8, inPerson: 40, inPersonById: null, inPersonAt: null, online: null, onlineById: null, onlineAt: null })}\n`, + ) + + // In runImport's order: the events, their counts, parts and services, then the origins left to decide. + const withoutOrigin = await importEvents(zip, tx, idMap, cong.id) + await importAttendance(zip, tx, idMap, cong.id) + await importEventParts(zip, tx, idMap, cong.id) + await importEventServiceParts(zip, tx, idMap, cong.id) + await settleImportedEventOrigins(tx, withoutOrigin, cong.id) + + const rows = await tx.event.findMany({ select: { name: true, origin: true } }) + return Object.fromEntries(rows.map(row => [row.name, row.origin])) + }) + + expect(origins).toEqual({ + 'old, empty, no author': 'job', + 'old, an author': 'import', + 'old, a part': 'import', + 'old, a service': 'import', + 'old, counts': 'import', + 'new, made by hand': 'manual', + 'new, the job’s': 'job', + 'new, unknown': 'import', + }) + } finally { + await withScope(cong.id, async tx => { + await tx.event.deleteMany({}) + await tx.userAccount.deleteMany({}) + }) + await testDb.congregation.delete({ where: { id: cong.id } }) + } + }) +}) diff --git a/app/features/settings/server/data-transfer.type.test.ts b/app/features/settings/server/data-transfer.type.test.ts index 37460418..5bc433ee 100644 --- a/app/features/settings/server/data-transfer.type.test.ts +++ b/app/features/settings/server/data-transfer.type.test.ts @@ -75,12 +75,12 @@ describe('EntityIdMap', () => { }) describe('ARCHIVE_VERSION', () => { - it('is the current 2.17 schema version', () => { - expect(ARCHIVE_VERSION).toBe('2.17') + it('is the current 2.18 schema version', () => { + expect(ARCHIVE_VERSION).toBe('2.18') }) - it('still imports 2.16 archives', () => { - expect(SUPPORTED_ARCHIVE_VERSIONS).toContain('2.16') + it('still imports 2.17 archives', () => { + expect(SUPPORTED_ARCHIVE_VERSIONS).toContain('2.17') }) }) diff --git a/app/features/settings/server/data-transfer.type.ts b/app/features/settings/server/data-transfer.type.ts index f273b147..a1590717 100644 --- a/app/features/settings/server/data-transfer.type.ts +++ b/app/features/settings/server/data-transfer.type.ts @@ -1,4 +1,4 @@ -export const ARCHIVE_VERSION = '2.17' +export const ARCHIVE_VERSION = '2.18' // Older archive versions an import will still accept. v1.0 archives miss every // post-shipping feature table (custom roles, allowed-roles, external speakers, @@ -64,6 +64,9 @@ export const ARCHIVE_VERSION = '2.17' // v2.17 gives services an order: `programme-template-service-roles.ndjson` and // `programme-service-role-assignments.ndjson` gain `order`. Pre-2.17 services are numbered by their id in the archive // (the order they were created in, the migration's rule), each template and each event from 0 in steps of 5. +// v2.18 carries who created each event: `events.ndjson` gains `origin` (`job`, `manual` or `import`). A pre-2.18 +// event without an author and with nothing on it comes back as the job's, by the migration's rule; any other as +// `import`, and so does one whose origin this version does not know. // v1.x archives are listed here so the import path reports them with a warning rather than rejecting outright; // `migrateLegacyUsersNdjson` splits their `users.ndjson` before the import runs. export const SUPPORTED_ARCHIVE_VERSIONS = [ @@ -87,6 +90,7 @@ export const SUPPORTED_ARCHIVE_VERSIONS = [ '2.15', '2.16', '2.17', + '2.18', ] as const export interface ManifestJson { diff --git a/app/features/settings/server/delete-account.server.integration.test.ts b/app/features/settings/server/delete-account.server.integration.test.ts new file mode 100644 index 00000000..4f9c444b --- /dev/null +++ b/app/features/settings/server/delete-account.server.integration.test.ts @@ -0,0 +1,164 @@ +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { PrismaClient } from '~/database/generated/client' + +// Deleting an account must not end in a foreign-key error on the events it created. Its absences go with it when it +// has no record: they belong to nobody else. An account linked to a record keeps them, so it is refused until they can +// be handed to the record. Its other events lose their author and stay what they were: a hand-made event never becomes +// an empty meeting a template may move or delete. + +const adapter = new PrismaPg({ + connectionString: process.env.DB_RUNTIME_URL ?? process.env.DB_URL, + max: 3, + connectionTimeoutMillis: 5000, +}) +const testDb = new PrismaClient({ adapter }) + +type Tx = Parameters[0]>[0] + +function withScope(congregationId: number, fn: (tx: Tx) => Promise): Promise { + return testDb.$transaction(async tx => { + await tx.$executeRawUnsafe(`SET LOCAL app.congregation_id = '${String(congregationId)}'`) + return fn(tx) + }) +} + +const { deleteAccount } = await import('./delete-account.server') +const { AccountHasAbsencesError, countMeetingsToMove, deleteTemplate, moveEmptyMeetings } = await import( + '~/features/events/index.server' +) +const { Permission } = await import('~/shared/types/permission') + +const ADMIN = new Set([Permission.CanDoAnything]) +const ts = Date.now() +const ids = { cong: 0, admin: 0, dayOffTemplate: 0, meetingTemplate: 0 } +const DAY = new Date('2027-01-12T18:00:00Z') + +beforeAll(async () => { + ids.cong = ( + await testDb.congregation.create({ data: { name: `Delete ${ts}`, slug: `delete-${ts}`, active: true } }) + ).id + await withScope(ids.cong, async tx => { + const congregationId = ids.cong + const adminRole = await tx.role.create({ data: { key: 'admin', isBuiltIn: true, congregationId } }) + ids.admin = ( + await tx.userAccount.create({ data: { email: `admin-${ts}@test.com`, password: 'x', congregationId } }) + ).id + await tx.userRoleAssignment.create({ data: { userId: ids.admin, roleId: adminRole.id, congregationId } }) + ids.dayOffTemplate = ( + await tx.eventTemplate.create({ data: { name: 'Absence', key: 'day-off', congregationId } }) + ).id + ids.meetingTemplate = ( + await tx.eventTemplate.create({ + data: { name: 'Réunion de semaine', key: 'midweek-meeting', weekDay: 2, congregationId }, + }) + ).id + }) +}) + +afterAll(async () => { + if (ids.cong) { + await withScope(ids.cong, async tx => { + await tx.event.deleteMany({}) + await tx.eventTemplate.deleteMany({}) + await tx.userRoleAssignment.deleteMany({}) + await tx.userAccount.deleteMany({}) + await tx.member.deleteMany({}) + await tx.role.deleteMany({}) + }) + await testDb.auditLog.deleteMany({ where: { congregationId: ids.cong } }) + await testDb.congregation.deleteMany({ where: { id: ids.cong } }) + } + await testDb.$disconnect() +}) + +/** An account, with a record when asked, an absence when asked, and an empty meeting it made by hand. */ +async function account(name: string, { record, absence }: { record: boolean; absence: boolean }) { + return withScope(ids.cong, async tx => { + const congregationId = ids.cong + const memberId = record + ? (await tx.member.create({ data: { firstname: name, lastname: 'TEST', congregationId } })).id + : null + const accountId = ( + await tx.userAccount.create({ + data: { email: `${name}-${ts}@test.com`, password: 'x', memberId, congregationId }, + }) + ).id + const event = (templateId: number, extra: object = {}) => + tx.event.create({ + data: { name, startDate: DAY, endDate: DAY, templateId, createdById: accountId, congregationId, ...extra }, + }) + const absenceId = absence ? (await event(ids.dayOffTemplate, { status: 'released' })).id : null + const meetingId = (await event(ids.meetingTemplate)).id + return { accountId, absenceId, meetingId } + }) +} + +const remove = (accountId: number) => + withScope(ids.cong, tx => deleteAccount(tx, accountId as never, ids.cong, ids.admin, ADMIN)) + +const eventsOf = (eventIds: (number | null)[]) => + withScope(ids.cong, tx => + tx.event.findMany({ + where: { id: { in: eventIds.filter((id): id is number => id != null) } }, + select: { id: true, createdById: true, origin: true }, + }), + ) + +describe('deleteAccount and the events the account created', () => { + it('deletes an account without a record with its absences, and clears its author elsewhere', async () => { + const { accountId, absenceId, meetingId } = await account('Sans-fiche', { record: false, absence: true }) + + await remove(accountId) + + const left = await withScope(ids.cong, tx => tx.userAccount.findFirst({ where: { id: accountId } })) + expect(left).toBeNull() + expect(await eventsOf([absenceId, meetingId])).toEqual([{ id: meetingId, createdById: null, origin: 'manual' }]) + }) + + it('refuses an account linked to a record that has absences, changing nothing', async () => { + const { accountId, absenceId, meetingId } = await account('Avec-fiche', { record: true, absence: true }) + + await expect(remove(accountId)).rejects.toBeInstanceOf(AccountHasAbsencesError) + + const left = await withScope(ids.cong, tx => tx.userAccount.findFirst({ where: { id: accountId } })) + expect(left).not.toBeNull() + expect(await eventsOf([absenceId, meetingId])).toHaveLength(2) + }) + + it('deletes an account linked to a record without absences, clearing its author', async () => { + const { accountId, meetingId } = await account('Fiche-sans-absence', { record: true, absence: false }) + + const result = await remove(accountId) + + expect(result.memberId).not.toBeNull() + expect(await eventsOf([meetingId])).toEqual([{ id: meetingId, createdById: null, origin: 'manual' }]) + }) + + // The bug this guards: an event without an author used to read as the job's. Once their accounts are gone, the + // hand-made meetings above have none — they must still not move with their template, nor go with it. + it('leaves the meetings the deleted accounts made where they are when their template changes day or goes', async () => { + const ctx = { congregationId: ids.cong, timeZone: 'Europe/Paris', now: new Date('2027-01-01T09:00:00Z') } + const before = await withScope(ids.cong, tx => + tx.event.findMany({ where: { templateId: ids.meetingTemplate, createdById: null }, select: { id: true } }), + ) + expect(before.length).toBeGreaterThan(0) + + await withScope(ids.cong, tx => + tx.eventTemplate.update({ where: { id: ids.meetingTemplate }, data: { weekDay: 4 } }), + ) + const toMove = await withScope(ids.cong, tx => countMeetingsToMove(tx, ids.meetingTemplate, ctx)) + const moved = await withScope(ids.cong, tx => + moveEmptyMeetings(tx, ids.meetingTemplate, { ...ctx, actorId: ids.admin }), + ) + const removal = await withScope(ids.cong, tx => deleteTemplate(tx, ids.meetingTemplate, ids.cong, ids.admin)) + + expect(toMove).toBe(0) + expect(moved).toEqual({ moved: 0, removed: 0 }) + expect(removal).toMatchObject({ ok: false, reason: 'in-use' }) + const after = await withScope(ids.cong, tx => + tx.event.findMany({ where: { id: { in: before.map(event => event.id) } }, select: { startDate: true } }), + ) + expect(after.map(event => event.startDate)).toEqual(before.map(() => DAY)) + }) +}) diff --git a/app/features/settings/server/delete-account.server.test.ts b/app/features/settings/server/delete-account.server.test.ts index ac89c71a..87f01d8e 100644 --- a/app/features/settings/server/delete-account.server.test.ts +++ b/app/features/settings/server/delete-account.server.test.ts @@ -8,6 +8,9 @@ vi.mock('~/shared/domain/audit.server', () => ({ audit: vi.fn(), })) vi.mock('~/shared/infra/db.server', () => ({ unscopedDb: { auditLog: { create: vi.fn() } } })) +vi.mock('~/features/events/index.server', () => ({ + releaseAccountEvents: vi.fn(async () => ({ absencesDeleted: [], eventsUnattributed: 0 })), +})) vi.mock('~/shared/auth/permissions.server', () => ({ requireNotLastAdmin: vi.fn(), isAccountAdmin: vi.fn() })) const ADMIN = new Set(['can-do-anything']) @@ -64,7 +67,7 @@ describe('deleteAccount', () => { actorId: 99, entityType: 'UserAccount', entityId: 1, - metadata: { email: 'a@b.test', memberId: 42 }, + metadata: { email: 'a@b.test', memberId: 42, absencesDeleted: [], eventsUnattributed: 0 }, }), ) }) diff --git a/app/features/settings/server/delete-account.server.ts b/app/features/settings/server/delete-account.server.ts index cc0e525e..bdf489dc 100644 --- a/app/features/settings/server/delete-account.server.ts +++ b/app/features/settings/server/delete-account.server.ts @@ -1,3 +1,4 @@ +import { releaseAccountEvents } from '~/features/events/index.server' import { requireNotLastAdmin } from '~/shared/auth/permissions.server' import { assertMayActOnAccount } from '~/shared/domain/account-protection.server' import { AuditAction, audit } from '~/shared/domain/audit.server' @@ -12,6 +13,8 @@ import type { AccountId } from '~/shared/types/branded' * lose their login. Tokens, permissions, and `UserRoleAssignment` rows * cascade via FK `onDelete`. * + * The events it created are let go of first (releaseAccountEvents): an account with a record and absences is refused. + * * For anonymization (keep the row, scrub PII) call `anonymizeAccount` instead. * This service is the destructive variant. */ @@ -32,6 +35,8 @@ export async function deleteAccount( await assertMayActOnAccount({ accountId, actorId, congregationId, actorPermissions, action: 'delete' }) await requireNotLastAdmin(accountId, congregationId) + const released = await releaseAccountEvents(db, { id: accountId, memberId: account.memberId }, congregationId) + await db.userAccount.delete({ where: { id_congregationId: { id: accountId, congregationId } } }) audit({ @@ -40,7 +45,7 @@ export async function deleteAccount( actorId, entityType: 'UserAccount', entityId: accountId, - metadata: { email: account.email, memberId: account.memberId }, + metadata: { email: account.email, memberId: account.memberId, ...released }, }) return { accountId, memberId: account.memberId } diff --git a/app/features/settings/server/export-congregation.server.ts b/app/features/settings/server/export-congregation.server.ts index 5851528f..afa57d80 100644 --- a/app/features/settings/server/export-congregation.server.ts +++ b/app/features/settings/server/export-congregation.server.ts @@ -582,6 +582,7 @@ export function buildExportSteps(db: TransactionClient, congregationId: number, createdById: true, createdAt: true, status: true, + origin: true, }, }), }, diff --git a/app/features/settings/server/import-congregation.server.ts b/app/features/settings/server/import-congregation.server.ts index 37fe7f37..a8170223 100644 --- a/app/features/settings/server/import-congregation.server.ts +++ b/app/features/settings/server/import-congregation.server.ts @@ -45,6 +45,7 @@ import { importEventServicePartAllowedRoles, importEventServiceParts, importEvents, + settleImportedEventOrigins, } from './import-events.server' import * as speakers from './import-external-speakers.server' import { importPartPresets } from './import-part-presets.server' @@ -151,9 +152,8 @@ export async function runImport(job: Job): Promise { const zip = await JsZip.loadAsync(buffer) const manifest = await readManifest(zip) - // v1.x → v2.0 shim: split legacy users.ndjson into members + user-accounts - // so the rest of runImport reads the v2.0 layout. Idempotent if the - // archive is already v2.0. + // v1.x → v2.0 shim: split legacy users.ndjson into members + user-accounts so the rest of runImport reads the v2.0 + // layout. Idempotent if the archive is already v2.0. const shimWarnings = await migrateLegacyUsersNdjson(zip, manifest.version) if (shimWarnings.length > 0) { logger.info(`Imported legacy v${manifest.version} archive`, { congregationId, warnings: shimWarnings }) @@ -263,8 +263,7 @@ export async function runImport(job: Job): Promise { await importAttributions(zip, db, idMap, congregationId) await progress() - // Before the template parts and event parts, which carry a presetId that - // resolves through the map this fills. + // Before the template and event parts: their presetId resolves through the map this fills. await importPartPresets(zip, db, idMap, congregationId) await progress() @@ -286,7 +285,7 @@ export async function runImport(job: Job): Promise { await importTemplateResponsibles(zip, db, idMap, congregationId) await progress() - await importEvents(zip, db, idMap, congregationId) + const withoutOrigin = await importEvents(zip, db, idMap, congregationId) await importAttendance(zip, db, idMap, congregationId) await progress() @@ -297,6 +296,7 @@ export async function runImport(job: Job): Promise { await progress() await importEventServiceParts(zip, db, idMap, congregationId) + await settleImportedEventOrigins(db, withoutOrigin, congregationId) await progress() await importEventServicePartAllowedRoles(zip, db, idMap, congregationId) diff --git a/app/features/settings/server/import-events.server.test.ts b/app/features/settings/server/import-events.server.test.ts index 0c998340..a607911c 100644 --- a/app/features/settings/server/import-events.server.test.ts +++ b/app/features/settings/server/import-events.server.test.ts @@ -69,7 +69,7 @@ describe('importEvents', () => { expect(db.event.deleteMany).toHaveBeenCalledWith({ where: { congregationId: 1, - createdById: null, + origin: 'job', eventParts: { none: {} }, eventServiceParts: { none: {} }, attendance: { is: null }, diff --git a/app/features/settings/server/import-events.server.ts b/app/features/settings/server/import-events.server.ts index bfc3a77c..663271d6 100644 --- a/app/features/settings/server/import-events.server.ts +++ b/app/features/settings/server/import-events.server.ts @@ -1,5 +1,6 @@ import type JsZip from 'jszip' -import { EventStatus, EventTemplateKey } from '~/features/events' +import { EventOrigin, EventStatus, EventTemplateKey, isEventOrigin } from '~/features/events' +import { EMPTY_MEETING } from '~/features/events/index.server' import type { TransactionClient } from '~/shared/infra/db.server' import { createLogger } from '~/shared/infra/logger.server' import type { EntityIdMap } from './data-transfer.type' @@ -22,7 +23,7 @@ export async function importEvents( db: TransactionClient, idMap: EntityIdMap, congregationId: number, -): Promise { +): Promise { const records = await readNdjsonFile<{ id: number name: string @@ -34,8 +35,10 @@ export async function importEvents( createdAt: string // Since v2.16. status?: string + // Since v2.18. + origin?: string }>(zip, 'events') - if (records.length === 0) return + if (records.length === 0) return [] const dayOff = await db.eventTemplate.findFirst({ where: { key: EventTemplateKey.DayOff, congregationId }, @@ -46,18 +49,16 @@ export async function importEvents( // replace them all — never one with attendance — and every template's mark is reset, so the recurring-events job // starts again after the last imported meeting, on the archive's own weekdays. await db.event.deleteMany({ - where: { - congregationId, - createdById: null, - eventParts: { none: {} }, - eventServiceParts: { none: {} }, - attendance: { is: null }, - }, + where: { congregationId, ...EMPTY_MEETING }, }) await db.eventTemplate.updateMany({ where: { congregationId }, data: { generatedUntil: null } }) let ownerless = 0 let unknownStatus = 0 + // Restored from an archive without origins (before v2.18): settleImportedEventOrigins decides them once their parts, + // services and counts are in. One whose origin this version does not know stays « import ». + let unknownOrigin = 0 + const withoutOrigin: number[] = [] for (const record of records) { const templateId = idMap.getOptional('programme-templates', record.templateId) const createdById = idMap.getOptional('user-accounts', record.createdById) @@ -76,10 +77,16 @@ export async function importEvents( templateId, createdById, status: importedStatus(record.status, () => unknownStatus++), + origin: isEventOrigin(record.origin) ? record.origin : EventOrigin.Import, congregationId, }, }) idMap.set('events', record.id, created.id) + if (record.origin == null) withoutOrigin.push(created.id) + else if (!isEventOrigin(record.origin)) unknownOrigin++ + } + if (unknownOrigin > 0) { + logger.warn(`Imported ${unknownOrigin} event(s) with an unknown origin as restored`, { congregationId }) } if (unknownStatus > 0) { logger.warn(`Imported ${unknownStatus} event(s) with an unknown status as drafts`, { congregationId }) @@ -87,6 +94,32 @@ export async function importEvents( if (ownerless > 0) { logger.warn(`Skipped ${ownerless} absence(s) whose owner was not imported`, { congregationId }) } + return withoutOrigin +} + +/** + * The origin of events an archive did not give one (before v2.18), by the migration's rule, once their parts, services + * and counts are in: one without an author and with nothing on it was an empty meeting, the job's — it still moves with + * its template. The others stay « import ». + */ +export async function settleImportedEventOrigins( + db: TransactionClient, + eventIds: number[], + congregationId: number, +): Promise { + if (eventIds.length === 0) return + await db.event.updateMany({ + where: { + id: { in: eventIds }, + congregationId, + origin: EventOrigin.Import, + createdById: null, + eventParts: { none: {} }, + eventServiceParts: { none: {} }, + attendance: { is: null }, + }, + data: { origin: EventOrigin.Job }, + }) } /** The status an event takes: the archive's when this version knows it, a draft otherwise. */ diff --git a/app/features/settings/server/template-page.queries.test.ts b/app/features/settings/server/template-page.queries.test.ts index 20dfc0d9..e06cf729 100644 --- a/app/features/settings/server/template-page.queries.test.ts +++ b/app/features/settings/server/template-page.queries.test.ts @@ -1,6 +1,10 @@ import { beforeEach, describe, expect, it, vi } from 'vitest' -vi.mock('~/features/events/index.server', () => ({ getTemplateById: vi.fn(), listPartPresets: vi.fn() })) +vi.mock('~/features/events/index.server', async () => ({ + EMPTY_MEETING: (await import('~/features/events/server/empty-meetings.queries')).EMPTY_MEETING, + getTemplateById: vi.fn(), + listPartPresets: vi.fn(), +})) vi.mock('~/shared/domain/roles.server', () => ({ listRoles: vi.fn(), listDelegatableRoles: vi.fn() })) vi.mock('~/shared/auth/permissions.server', () => ({ findMembersWithAnyRole: vi.fn() })) diff --git a/app/features/settings/server/template-page.queries.ts b/app/features/settings/server/template-page.queries.ts index 903801aa..2ef08173 100644 --- a/app/features/settings/server/template-page.queries.ts +++ b/app/features/settings/server/template-page.queries.ts @@ -1,5 +1,5 @@ import { findResponsible, ResponsibilityScope } from '~/features/events' -import { getTemplateById, listPartPresets } from '~/features/events/index.server' +import { EMPTY_MEETING, getTemplateById, listPartPresets } from '~/features/events/index.server' import { findMembersWithAnyRole } from '~/shared/auth/permissions.server' import { listDelegatableRoles, listRoles } from '~/shared/domain/roles.server' import type { TransactionClient } from '~/shared/infra/db.server' @@ -69,7 +69,7 @@ export async function getTemplatePage( where: { templateId, congregationId, - NOT: { createdById: null, eventParts: { none: {} }, eventServiceParts: { none: {} }, attendance: { is: null } }, + NOT: EMPTY_MEETING, }, }), listRoles(db, congregationId), diff --git a/app/i18n/messages/en.json b/app/i18n/messages/en.json index 618926e6..f2b3f231 100644 --- a/app/i18n/messages/en.json +++ b/app/i18n/messages/en.json @@ -5587,6 +5587,7 @@ "settings_user_admin_only": "An administrator’s account is handled by an administrator.", "settings_user_own_account": "You cannot do this to your own account: ask another manager.", "settings_user_last_admin": "This is the congregation’s last administrator: give the role to someone else first.", + "settings_user_has_absences": "This account has absences: they stay with the person, so it cannot be deleted for now.", "settings_users_views": "Accounts", "settings_users_view_all": "All", "settings_users_view_active": "Active", diff --git a/app/i18n/messages/fr.json b/app/i18n/messages/fr.json index 322694ae..25cfca32 100644 --- a/app/i18n/messages/fr.json +++ b/app/i18n/messages/fr.json @@ -5587,6 +5587,7 @@ "settings_user_admin_only": "Le compte d’un administrateur se gère par un administrateur.", "settings_user_own_account": "Vous ne pouvez pas faire cela sur votre propre compte : demandez-le à un autre gestionnaire.", "settings_user_last_admin": "C’est le dernier administrateur de l’assemblée : donnez d’abord le rôle à quelqu’un d’autre.", + "settings_user_has_absences": "Ce compte a des absences : elles restent avec la personne, il ne peut pas être supprimé pour l’instant.", "settings_users_views": "Comptes", "settings_users_view_all": "Tous", "settings_users_view_active": "Actifs", diff --git a/app/i18n/messages/pt-PT.json b/app/i18n/messages/pt-PT.json index 26e13f6c..25453d81 100644 --- a/app/i18n/messages/pt-PT.json +++ b/app/i18n/messages/pt-PT.json @@ -5587,6 +5587,7 @@ "settings_user_admin_only": "A conta de um administrador tem de ser gerida por um administrador.", "settings_user_own_account": "Não pode fazer isto na sua própria conta: peça a outro responsável.", "settings_user_last_admin": "É o último administrador da congregação: atribua primeiro essa função a outra pessoa.", + "settings_user_has_absences": "Esta conta tem ausências: ficam com a pessoa, por isso não pode ser eliminada por agora.", "settings_users_views": "Contas", "settings_users_view_all": "Todos", "settings_users_view_active": "Ativo", diff --git a/app/tests/fixtures/events-reference.ts b/app/tests/fixtures/events-reference.ts index c0cba71f..f92c7f60 100644 --- a/app/tests/fixtures/events-reference.ts +++ b/app/tests/fixtures/events-reference.ts @@ -245,14 +245,14 @@ export async function buildReferenceCongregation(suffix: string): Promise = {} for (const event of all) { const name = names.get(event.templateId) if (!name) throw new Error(`the fixture did not expect an event of template ${event.templateId}`) - const prefix = event.createdById == null ? `${name}-ahead` : name + const prefix = event.origin === 'job' ? `${name}-ahead` : name counters[prefix] = (counters[prefix] ?? 0) + 1 label('event', event.id, `${prefix}-${counters[prefix]}`) } diff --git a/app/tests/reference/__references__/archive-after-import.json b/app/tests/reference/__references__/archive-after-import.json index 586d642a..3e2022a6 100644 --- a/app/tests/reference/__references__/archive-after-import.json +++ b/app/tests/reference/__references__/archive-after-import.json @@ -577,7 +577,8 @@ "templateId": "", "createdById": "", "createdAt": "