@lilaquadrat/studio 12.3.0 → 13.0.1

package/lib/tests/shiftPlanning.spec.js

@@ -170,6 +170,40 @@ describe('shift planning', () => {
         const cleared = await plansService.changePlan(created._id, { name: created.name, timeZone: created.timeZone, settingsOverrides: {} }, options);
         expect(cleared.list).toBeUndefined();
     });
+    it.each(['replace', 'remove'])('refuses to %s the employee list until existing assignments are cleared', async (change) => {
+        const plan = await setupPlan();
+        const otherListId = new ObjectId();
+        await ListsModel.db.insertOne({ ...list, _id: otherListId, name: 'Events' });
+        await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [] }), options);
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId), options);
+        const previousPlan = await ShiftPlanModel.db.findOne({ _id: plan._id });
+        const previousShift = await ShiftModel.db.findOne({ _id: shift._id });
+        const historyCount = await HistoryModel.db.countDocuments({});
+        const input = change === 'replace' ? planInput(otherListId) : planInput(listId, { list: undefined });
+        await expect(plansService.changePlan(plan._id, input, options)).rejects.toThrow('SHIFT_PLAN_REFERENCES_IN_USE');
+        expect(await ShiftPlanModel.db.findOne({ _id: plan._id })).toEqual(previousPlan);
+        expect(await ShiftModel.db.findOne({ _id: shift._id })).toEqual(previousShift);
+        expect(await HistoryModel.db.countDocuments({})).toBe(historyCount);
+        const cleared = await shiftsService.replaceAssignments(plan._id, shift._id, { assignments: [] }, options);
+        expect(cleared.assignments).toEqual([]);
+        const changed = await plansService.changePlan(plan._id, input, options);
+        expect(changed.list?.toHexString()).toBe(input.list?.toHexString());
+    });
+    it('does not let assignments in another plan, project or company prevent an employee-list change', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [] }), options);
+        const document = (await ShiftModel.db.findOne({ _id: shift._id }));
+        const assignments = [{ participant: participantId, customer: customerId, breaks: [] }];
+        await ShiftModel.db.insertMany([
+            { ...document, _id: new ObjectId(), plan: new ObjectId(), assignments },
+            { ...document, _id: new ObjectId(), project: 'foreign', assignments },
+            { ...document, _id: new ObjectId(), company: 'foreign', assignments },
+        ]);
+        const changed = await plansService.changePlan(plan._id, planInput(listId, { list: undefined }), options);
+        expect(changed.list).toBeUndefined();
+        expect(changed.shifts).toHaveLength(1);
+        expect(changed.shifts[0]._id.equals(shift._id)).toBe(true);
+    });
     it('resolves assignments against the linked plan list for a shift persisted before the link', async () => {
         await settingsService.changeSettings({ settings: policy() }, options);
         const created = await plansService.createPlan({ name: 'Unlinked', timeZone: 'Europe/Berlin', settingsOverrides: {} }, options);
@@ -209,11 +243,46 @@ describe('shift planning', () => {
         const bound = await plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [{ area, categoryIds: [categoryId] }] }), options);
         expect(bound.workAreaCategories).toHaveLength(1);
         expect(bound.workAreaCategories[0].categoryIds[0].equals(categoryId)).toBe(true);
+        const kept = await plansService.changePlan(plan._id, planInput(new ObjectId(listId.toHexString()), { name: 'Renamed' }), options);
+        expect(kept.workAreaCategories).toEqual(bound.workAreaCategories);
         const cleared = await plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [] }), options);
         expect(cleared.workAreaCategories).toEqual([]);
         const untouched = await plansService.changePlan(plan._id, planInput(listId), options);
         expect(untouched.workAreaCategories).toEqual([]);
     });
+    it.each(['replace', 'remove'])('clears omitted category bindings when an unassigned plan changes its list through %s', async (change) => {
+        const plan = await setupPlan();
+        await plansService.changePlan(plan._id, planInput(listId, {
+            workAreaCategories: [{ area: housekeepingAreaId, categoryIds: [categoryId] }],
+        }), options);
+        await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [] }), options);
+        const otherListId = new ObjectId();
+        const otherCategoryId = new ObjectId();
+        await ListsModel.db.insertOne({ ...list, _id: otherListId, categories: [{ _id: otherCategoryId, id: 'events', name: 'Events' }] });
+        const input = change === 'replace' ? planInput(otherListId) : planInput(listId, { list: undefined });
+        const changed = await plansService.changePlan(plan._id, input, options);
+        expect(changed.list?.toHexString()).toBe(input.list?.toHexString());
+        expect(changed.workAreaCategories).toEqual([]);
+        expect(changed.days).toEqual(plan.days);
+        expect(changed.workAreas).toEqual(plan.workAreas);
+        expect(changed.shifts).toHaveLength(1);
+    });
+    it('validates explicit replacement bindings against the new employee list before changing the plan', async () => {
+        const plan = await setupPlan();
+        const bindings = [{ area: housekeepingAreaId, categoryIds: [categoryId] }];
+        await plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: bindings }), options);
+        const otherListId = new ObjectId();
+        const otherCategoryId = new ObjectId();
+        await ListsModel.db.insertOne({ ...list, _id: otherListId, categories: [{ _id: otherCategoryId, id: 'events', name: 'Events' }] });
+        const previous = await ShiftPlanModel.db.findOne({ _id: plan._id });
+        await expect(plansService.changePlan(plan._id, planInput(otherListId, { workAreaCategories: bindings }), options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(plansService.changePlan(plan._id, planInput(listId, { list: undefined, workAreaCategories: bindings }), options)).rejects.toThrow('VALIDATION_FAILED');
+        expect(await ShiftPlanModel.db.findOne({ _id: plan._id })).toEqual(previous);
+        const replacement = [{ area: housekeepingAreaId, categoryIds: [otherCategoryId] }];
+        const changed = await plansService.changePlan(plan._id, planInput(otherListId, { workAreaCategories: replacement }), options);
+        expect(changed.list.equals(otherListId)).toBe(true);
+        expect(changed.workAreaCategories).toEqual(replacement);
+    });
     it('stores, preserves and clears the default participant state', async () => {
         const plan = await setupPlan();
         const set = await plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: 'confirmed' }), options);
@@ -257,6 +326,38 @@ describe('shift planning', () => {
         const history = await HistoryModel.db.findOne({ 'history.parent': shift._id });
         expect(history).toMatchObject({ assignments: [{ customer: customerId }, { customer: secondCustomerId }], history: { model: 'shifts', reason: 'create', user: options.user } });
     });
+    it('returns the complete scoped schedule in plan details while keeping standalone shift lists paginated', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+            start: `${day}T16:00:00+02:00`, end: `${day}T18:00:00+02:00`,
+        }), options);
+        const document = (await ShiftModel.db.findOne({ _id: shift._id }));
+        const additionalShifts = Array.from({ length: 30 }, (_, index) => ({
+            ...document, _id: new ObjectId(), assignments: [],
+            start: new Date(Date.parse(`${day}T06:00:00Z`) + index * 60000).toISOString(),
+            end: new Date(Date.parse(`${day}T07:00:00Z`) + index * 60000).toISOString(),
+        }));
+        await ShiftModel.db.insertMany([
+            ...additionalShifts,
+            { ...document, _id: new ObjectId(), project: 'foreign', assignments: [] },
+            { ...document, _id: new ObjectId(), company: 'foreign', assignments: [] },
+            { ...document, _id: new ObjectId(), plan: new ObjectId() },
+        ]);
+        const detail = (await plansService.singlePlan(plan._id, options));
+        expect(detail.shifts.map((entry) => entry._id)).toEqual([...additionalShifts.map((entry) => entry._id), shift._id]);
+        expect(detail.shifts[30]).toMatchObject({
+            _id: shift._id, participants: [{ participant: participantId, customer: customerId }],
+            violations: [], workingTime: [{ customer: customerId.toHexString(), daytimeMinutes: 120, nighttimeMinutes: 0, breakMinutes: 0 }],
+        });
+        const firstPage = await shiftsService.listShifts(plan._id, {}, options);
+        const secondPage = await shiftsService.listShifts(plan._id, { site: 2 }, options);
+        expect(firstPage).toMatchObject({ all: 31, count: 30 });
+        expect(secondPage).toMatchObject({ all: 31, count: 1 });
+        expect(secondPage.data[0]._id.equals(shift._id)).toBe(true);
+        await expect(plansService.changePlan(plan._id, planInput(listId, { list: undefined }), options)).rejects.toThrow('SHIFT_PLAN_REFERENCES_IN_USE');
+        expect(await plansService.singlePlan(plan._id, { ...options, company: 'foreign' })).toBeNull();
+        expect(await plansService.singlePlan(plan._id, { ...options, project: 'foreign' })).toBeNull();
+    });
     it('stores shift structures and people requirements and replaces them on change', async () => {
         const plan = await setupPlan();
         const structureId = '507f1f77bcf86cd799439011';
@@ -743,44 +844,8 @@ describe('shift planning', () => {
         expect(member.data[0].area).not.toHaveProperty('company');
         expect(member.data[0].area).not.toHaveProperty('project');
     });
-    it('searches plans by name while escaping regex metacharacters', async () => {
-        await setupPlan();
-        await plansService.createPlan(planInput(listId, { name: 'Events [October]' }), options);
-        const matched = await plansService.listPlans({ search: 'events' }, options);
-        expect(matched.all).toBe(1);
-        expect(matched.data[0].name).toBe('Events [October]');
-        const escaped = await plansService.listPlans({ search: '[October]' }, options);
-        expect(escaped.all).toBe(1);
-        expect((await plansService.listPlans({ search: 'missing' }, options)).all).toBe(0);
-    });
-    it('lists weekly plans by planning dates and keeps both bounds on the same day', async () => {
-        const first = await setupPlan();
-        const futureCreated = await plansService.createPlan(planInput(listId), options);
-        await createDays(futureCreated._id, options, [{ date: '2026-10-12', areas: areaLinks() }]);
-        const disjointCreated = await plansService.createPlan(planInput(listId), options);
-        await createDays(disjointCreated._id, options, [{ date: '2026-10-01', areas: areaLinks() }, { date: '2026-10-20', areas: areaLinks() }]);
-        // mongo-mock has no distinct implementation; reproduce the day-date range query over the stored day documents.
-        const storedDays = await DayModel.db.find({ company: options.company, project: options.project }).toArray();
-        const distinctSpy = jest.spyOn(DayModel.db, 'distinct').mockImplementation((async (_field, filter) => {
-            const range = (filter.date ?? {});
-            const plans = storedDays
-                .filter((entry) => (!range.$gte || entry.date >= range.$gte) && (!range.$lt || entry.date < range.$lt))
-                .map((entry) => entry.plan.toHexString());
-            return [...new Set(plans)].map((hex) => new ObjectId(hex));
-        }));
-        try {
-            const filtered = await plansService.listPlans({ list: listId, from: '2026-10-10', to: '2026-10-15' }, options);
-            expect(filtered.all).toBe(1);
-            expect(filtered.data[0]._id.equals(futureCreated._id)).toBe(true);
-            const ordered = await plansService.listPlans({ list: listId, from: day, to: '2026-10-13' }, options);
-            expect(ordered.all).toBe(2);
-            expect(ordered.data[0]._id.equals(first._id)).toBe(true);
-            await expect(plansService.listPlans({ list: listId, from: day, to: day }, options)).rejects.toThrow('VALIDATION_FAILED');
-            expect(await plansService.singlePlan(new ObjectId(), options)).toBeNull();
-        }
-        finally {
-            distinctSpy.mockRestore();
-        }
+    it('returns null for a missing plan', async () => {
+        expect(await plansService.singlePlan(new ObjectId(), options)).toBeNull();
     });
     it('permits overlapping departments in one area while keeping shift operations bound to their plan', async () => {
         const restaurant = await setupPlan();