feat: platform backbone and field capture complete (checkpoint)

Platform backbone (plan 2026-10-13-plattform-rueckgrat), all tasks reviewed: - webhooks with delivery table, retries and stable delivery id - calendar handlers; a finished task removes its Outlook event - tasks, automations, inspections, varroa, treatments, feedings, harvests, colonies, wintering, stock and bottling record domain events in the same transaction; legacy post-commit calls removed - row locks through one helper (lockRowForUpdate, lockRowsForShare, lockRowsForUpdate) - job framework with JobRun, cli exit codes, cleanup, task templates, daily evaluation, hourly app-backup and the rekey job - system API and page "Verwaltung > System" with retry - @nestjs/schedule removed, guard tests against in-process schedulers Field capture T3 (plan 2026-10-13-t3-erfassung-am-stand), all tasks reviewed: - inspection photo offline without metadata - bulk capture for treatments, feedings and varroa (backend + frontend) - offline stand mode with service worker, offline pages and packs - offline session, cold start and logout on shared devices Docs: ARCHITECTURE.md assumptions and sections updated, TASKS.md. Gates: backend lint, typecheck, 1770 unit, 420 e2e, build, no schema drift; frontend lint, typecheck, 913 tests, build. Not rolled out. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-10-14 11:36:38 +02:00
1 parent c01a38835a
commit cdd30cf3ee
@@ -19,6 +19,11 @@ interface WithdrawalStatusBody {
  product: string;
 }

+interface BulkTreatmentBody {
+  bulkId: string;
+  records: (TreatmentBody & { apiaryId: string; batchNumber: string })[];
+}
+
 describe('Treatments (e2e)', () => {
  let app: INestApplication<App>;
  let prisma: PrismaService;
@@ -74,6 +79,15 @@ describe('Treatments (e2e)', () => {
  });

  afterAll(async () => {
+    const treatmentIds = (
+      await prisma.treatment.findMany({
+        where: { colonyId },
+        select: { id: true },
+      })
+    ).map((treatment) => treatment.id);
+    await prisma.domainEvent.deleteMany({
+      where: { aggregateType: 'Treatment', aggregateId: { in: treatmentIds } },
+    });
    await prisma.treatment.deleteMany({ where: { colonyId } });
    await prisma.colony.deleteMany({ where: { id: colonyId } });
    await prisma.apiary.deleteMany({ where: { id: apiaryId } });
@@ -116,6 +130,30 @@ describe('Treatments (e2e)', () => {
    expect(treatmentId).toEqual(expect.any(String));
  });

+  it('wrote the audit entry and TreatmentRecorded together with the treatment', async () => {
+    expect(
+      await prisma.auditLog.count({
+        where: {
+          entityType: 'Treatment',
+          entityId: treatmentId,
+          action: 'CREATE',
+          userId: beekeeperId,
+        },
+      }),
+    ).toBe(1);
+    const events = await prisma.domainEvent.findMany({
+      where: { aggregateType: 'Treatment', aggregateId: treatmentId },
+    });
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual(
+      expect.objectContaining({
+        type: 'TreatmentRecorded',
+        actorUserId: beekeeperId,
+        payload: { colonyId },
+      }),
+    );
+  });
+
  it('lists treatments for the colony', async () => {
    const response = await request(app.getHttpServer())
      .get(`/api/v1/colonies/${colonyId}/treatments`)
@@ -126,6 +164,14 @@ describe('Treatments (e2e)', () => {
  });

  it('clears start and end date on null and audits the edit', async () => {
+    const correctionWhere = {
+      aggregateType: 'Treatment',
+      aggregateId: treatmentId,
+      type: 'TreatmentCorrected',
+    } as const;
+    const correctionsBefore = await prisma.domainEvent.count({
+      where: correctionWhere,
+    });
    await request(app.getHttpServer())
      .patch(`/api/v1/treatments/${treatmentId}`)
      .set('Authorization', `Bearer ${beekeeperToken}`)
@@ -152,6 +198,17 @@ describe('Treatments (e2e)', () => {
    expect(auditEntry?.afterData).toEqual(
      expect.objectContaining({ startDate: null, endDate: null }),
    );
+    // Two edits in this test, one event each.
+    const corrections = await prisma.domainEvent.findMany({
+      where: correctionWhere,
+    });
+    expect(corrections).toHaveLength(correctionsBefore + 2);
+    expect(
+      corrections.every(
+        (event) =>
+          (event.payload as { colonyId: string }).colonyId === colonyId,
+      ),
+    ).toBe(true);
  });

  it.each(['date', 'product'])('rejects null for the required %s', (field) =>
@@ -350,4 +407,236 @@ describe('Treatments (e2e)', () => {
    it('rejects a role without treatments:create', () =>
      lastByProduct(staffToken, productName).expect(403));
  });
+
+  describe('POST /treatments/bulk', () => {
+    const suffix = Date.now();
+    const shared = {
+      date: '2026-08-15',
+      product: 'Oxalsäure',
+      batchNumber: 'CH-1',
+      withdrawalPeriodDays: 0,
+    };
+    let secondApiaryId: string;
+    // Two colonies at the first apiary, one at the second.
+    let bulkColonyIds: string[];
+    let endedColonyId: string;
+
+    const postBulk = (token: string, body: object, idempotencyKey?: string) => {
+      const call = request(app.getHttpServer())
+        .post('/api/v1/treatments/bulk')
+        .set('Authorization', `Bearer ${token}`);
+      return (
+        idempotencyKey === undefined
+          ? call
+          : call.set('Idempotency-Key', idempotencyKey)
+      ).send(body);
+    };
+
+    const storedTreatments = () =>
+      prisma.treatment.count({
+        where: { colonyId: { in: [...bulkColonyIds, endedColonyId] } },
+      });
+
+    beforeAll(async () => {
+      const secondApiary = await prisma.apiary.create({
+        data: { name: `Stand B ${suffix}` },
+      });
+      secondApiaryId = secondApiary.id;
+      const colonyAt = async (
+        code: string,
+        atApiaryId: string,
+        status: 'ACTIVE' | 'WEAK' | 'DISSOLVED' = 'ACTIVE',
+      ) =>
+        (
+          await prisma.colony.create({
+            data: {
+              code: `${code}-${suffix}`,
+              apiaryId: atApiaryId,
+              colonyType: 'PRODUCTION_COLONY',
+              status,
+            },
+          })
+        ).id;
+      bulkColonyIds = [
+        await colonyAt('TB-1', apiaryId),
+        await colonyAt('TB-2', apiaryId, 'WEAK'),
+        await colonyAt('TB-3', secondApiaryId),
+      ];
+      endedColonyId = await colonyAt('TB-X', apiaryId, 'DISSOLVED');
+    });
+
+    afterAll(async () => {
+      const colonyIds = [...bulkColonyIds, endedColonyId];
+      const treatmentIds = (
+        await prisma.treatment.findMany({
+          where: { colonyId: { in: colonyIds } },
+          select: { id: true },
+        })
+      ).map((treatment) => treatment.id);
+      await prisma.domainEvent.deleteMany({
+        where: {
+          aggregateType: 'Treatment',
+          aggregateId: { in: treatmentIds },
+        },
+      });
+      await prisma.treatment.deleteMany({
+        where: { colonyId: { in: colonyIds } },
+      });
+      await prisma.colony.deleteMany({ where: { id: { in: colonyIds } } });
+      await prisma.apiary.deleteMany({ where: { id: secondApiaryId } });
+      await prisma.idempotencyRecord.deleteMany({
+        where: { userId: beekeeperId },
+      });
+    });
+
+    it("bulk creates one treatment per colony with the shared fields and each colony's apiary", async () => {
+      const response = await postBulk(beekeeperToken, {
+        ...shared,
+        colonyIds: bulkColonyIds,
+      }).expect(201);
+
+      const body = response.body as BulkTreatmentBody;
+      expect(body.bulkId).toEqual(expect.any(String));
+      expect(body.records).toHaveLength(3);
+      expect(body.records.map((record) => record.colonyId)).toEqual(
+        bulkColonyIds,
+      );
+      expect(
+        body.records.every((record) => record.batchNumber === 'CH-1'),
+      ).toBe(true);
+      expect(body.records.map((record) => record.apiaryId)).toEqual([
+        apiaryId,
+        apiaryId,
+        secondApiaryId,
+      ]);
+    });
+
+    it('bulk writes one TreatmentRecorded event and one audit entry per record', async () => {
+      const response = await postBulk(beekeeperToken, {
+        ...shared,
+        colonyIds: bulkColonyIds,
+      }).expect(201);
+      const { bulkId, records } = response.body as BulkTreatmentBody;
+      const ofThisBulk = {
+        type: 'TreatmentRecorded',
+        payload: { path: ['bulkId'], equals: bulkId },
+      };
+
+      expect(await prisma.domainEvent.count({ where: ofThisBulk })).toBe(3);
+      const events = await prisma.domainEvent.findMany({ where: ofThisBulk });
+      expect(
+        events
+          .map((event) => ({
+            aggregateId: event.aggregateId,
+            actorUserId: event.actorUserId,
+            payload: event.payload,
+          }))
+          .sort((a, b) => a.aggregateId.localeCompare(b.aggregateId)),
+      ).toEqual(
+        records
+          .map((record) => ({
+            aggregateId: record.id,
+            actorUserId: beekeeperId,
+            payload: { colonyId: record.colonyId, bulkId },
+          }))
+          .sort((a, b) => a.aggregateId.localeCompare(b.aggregateId)),
+      );
+      expect(
+        await prisma.auditLog.count({
+          where: {
+            entityType: 'Treatment',
+            action: 'CREATE',
+            userId: beekeeperId,
+            entityId: { in: records.map((record) => record.id) },
+          },
+        }),
+      ).toBe(3);
+    });
+
+    it('bulk rejects the whole batch when one colony has ended and names it', async () => {
+      const before = await storedTreatments();
+
+      const response = await postBulk(beekeeperToken, {
+        ...shared,
+        colonyIds: [...bulkColonyIds, endedColonyId],
+      }).expect(400);
+
+      expect(
+        (response.body as { invalidColonyIds: string[] }).invalidColonyIds,
+      ).toEqual([endedColonyId]);
+      expect(await storedTreatments()).toBe(before);
+    });
+
+    it.each([
+      [
+        'an unknown id',
+        () => [bulkColonyIds[0], `unknown-${suffix}`],
+        'Einige Völker sind nicht (mehr) erfassbar',
+      ],
+      ['no id', () => [], 'colonyIds braucht mindestens ein Volk'],
+      [
+        '101 ids',
+        () => [
+          ...bulkColonyIds,
+          ...Array.from({ length: 98 }, (_, index) => `cl-${suffix}-${index}`),
+        ],
+        'colonyIds darf höchstens 100 Völker enthalten',
+      ],
+      [
+        'a duplicate id',
+        () => [bulkColonyIds[0], bulkColonyIds[0]],
+        'colonyIds enthält ein Volk doppelt',
+      ],
+      [
+        'an empty id',
+        () => [bulkColonyIds[0], ''],
+        'colonyIds enthält eine leere Volk-ID',
+      ],
+    ])(
+      'bulk rejects unknown ids, 0 or 101 ids and duplicates: %s',
+      async (_label, colonyIds, message) => {
+        const before = await storedTreatments();
+
+        const response = await postBulk(beekeeperToken, {
+          ...shared,
+          colonyIds: colonyIds(),
+        }).expect(400);
+
+        expect(JSON.stringify(response.body)).toContain(message);
+        expect(await storedTreatments()).toBe(before);
+      },
+    );
+
+    it('bulk names an unknown id like an ended colony', async () => {
+      const unknownId = `unknown-${suffix}`;
+
+      const response = await postBulk(beekeeperToken, {
+        ...shared,
+        colonyIds: [bulkColonyIds[0], unknownId],
+      }).expect(400);
+
+      expect(
+        (response.body as { invalidColonyIds: string[] }).invalidColonyIds,
+      ).toEqual([unknownId]);
+    });
+
+    it('bulk replays with the same Idempotency-Key', async () => {
+      const key = `treatments-bulk-${suffix}`;
+      const body = { ...shared, colonyIds: bulkColonyIds };
+      const before = await storedTreatments();
+
+      const first = await postBulk(beekeeperToken, body, key).expect(201);
+      const replay = await postBulk(beekeeperToken, body, key).expect(201);
+
+      expect((replay.body as BulkTreatmentBody).bulkId).toBe(
+        (first.body as BulkTreatmentBody).bulkId,
+      );
+      expect(await storedTreatments()).toBe(before + bulkColonyIds.length);
+    });
+
+    it('bulk rejects a role without treatments:create', () =>
+      postBulk(staffToken, { ...shared, colonyIds: bulkColonyIds }).expect(
+        403,
+      ));
+  });
 });