@lilaquadrat/studio 12.2.0 → 13.0.0

package/lib/tests/shiftPlanning.spec.js

@@ -19,6 +19,7 @@ import ParticipantsModel from '../src/models/listsParticipants.model.js';
 import CustomersModel from '../src/models/customers.model.js';
 import StructureModel from '../src/models/structure.model.js';
 import HistoryModel from '../src/models/history.model.js';
+import participantsService from '../src/services/listParticipants.service.js';
 const options = { company: 'hotel', project: 'hotel-project', user: 'planner', app: 'studio' };
 const listId = new ObjectId();
 const categoryId = new ObjectId();
@@ -169,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);
@@ -208,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);
@@ -256,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';
@@ -742,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();
@@ -831,5 +897,331 @@ describe('shift planning', () => {
                 }] }, options);
         expect(await HistoryModel.db.countDocuments({ 'history.parent': shift._id })).toBe(count);
     });
+    describe('read-only shift autofill', () => {
+        async function setupAutofill(changes = {}) {
+            const plan = await setupPlan();
+            const structureId = new ObjectId();
+            await StructureModel.db.insertOne({ _id: structureId, company: options.company, project: options.project,
+                model: 'listsParticipants', id: 's-boolean-preferred', type: 'boolean', question: 'Preferred' });
+            await ParticipantsModel.db.updateOne({ _id: secondParticipantId }, { $set: { 's-boolean-preferred': true } });
+            const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+                assignments: [], requiredPeople: 1,
+                structures: [{ structure: structureId.toHexString(), grade: 'very-positive' }], ...changes,
+            }), options);
+            return { plan, shift, structureId };
+        }
+        it('ranks suggestions deterministically, batches rule reads and changes no stored documents', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2 });
+            const before = await Promise.all(models.map(async (model) => JSON.stringify(await model.db.find({}).sort({ _id: 1 }).toArray())));
+            const settingsRead = jest.spyOn(settingsService, 'singleSettings');
+            const absencesRead = jest.spyOn(absencesService, 'absencesForPlanning');
+            try {
+                const expected = { shift: shift._id, users: [secondParticipantId, participantId] };
+                expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual(expected);
+                expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual(expected);
+                expect(settingsRead).toHaveBeenCalledTimes(2);
+                expect(absencesRead).toHaveBeenCalledTimes(2);
+                const after = await Promise.all(models.map(async (model) => JSON.stringify(await model.db.find({}).sort({ _id: 1 }).toArray())));
+                expect(after).toEqual(before);
+            }
+            finally {
+                settingsRead.mockRestore();
+                absencesRead.mockRestore();
+            }
+        });
+        it('keeps current assignments and only fills the remaining places', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2, assignments: [{ participant: participantId }] });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId, secondParticipantId] });
+            expect((await ShiftModel.db.findOne({ _id: shift._id })).assignments).toEqual(shift.assignments);
+        });
+        it('retains existing attention items without allowing new violations', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2, assignments: [{ participant: participantId }] });
+            await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { state: 'canceled' } });
+            await absencesService.createAbsence({ customer: customerId, type: 'sickness', start: `${day}T00:00:00+02:00`, end: `${nextDay}T00:00:00+02:00` }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId, secondParticipantId] });
+        });
+        it.each([undefined, 0, 1])('keeps an already assigned shift unchanged with target %p', async (requiredPeople) => {
+            const { plan, shift } = await setupAutofill({ requiredPeople, assignments: [{ participant: participantId }] });
+            const candidateRead = jest.spyOn(participantsService, 'planningParticipants');
+            try {
+                expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+                expect(candidateRead).not.toHaveBeenCalled();
+            }
+            finally {
+                candidateRead.mockRestore();
+            }
+        });
+        it('selects one list entry per person and returns a partial fill when the pool runs out', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 3 });
+            const duplicateParticipantId = new ObjectId();
+            await ParticipantsModel.db.insertOne({ ...participant, _id: duplicateParticipantId, 's-boolean-preferred': true });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId, duplicateParticipantId] });
+        });
+        it.each(['blocked', 'unchecked', 'notuseful', 'canceled'])('excludes a high-scoring %s person', async (state) => {
+            const { plan, shift } = await setupAutofill();
+            await ParticipantsModel.db.updateOne({ _id: secondParticipantId }, { $set: { state } });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('ignores entries without a person in the company', async () => {
+            const { plan, shift } = await setupAutofill();
+            await CustomersModel.db.updateOne({ _id: secondCustomerId }, { $set: { company: 'foreign' } });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('applies the plan default state and area-category binding together', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 3 });
+            const eventsCategoryId = new ObjectId();
+            const reservedCustomerId = new ObjectId();
+            const reservedParticipantId = new ObjectId();
+            await ListsModel.db.updateOne({ _id: listId }, { $set: { categories: [
+                        ...list.categories, { _id: eventsCategoryId, id: 'events', name: 'Events' },
+                    ] } });
+            await ParticipantsModel.db.updateOne({ _id: secondParticipantId }, { $set: { state: 'reserved', category: 'events' } });
+            await CustomersModel.db.insertOne({ ...customer, _id: reservedCustomerId, id: 'reserved', accounts: [] });
+            await ParticipantsModel.db.insertOne({ ...participant, _id: reservedParticipantId, user: reservedCustomerId, state: 'reserved' });
+            await plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: 'reserved',
+                workAreaCategories: [{ area: housekeepingAreaId, categoryIds: [categoryId] }],
+            }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [reservedParticipantId] });
+        });
+        it('ignores matchingPeople and fills only to requiredPeople', async () => {
+            const { plan, shift, structureId } = await setupAutofill({ requiredPeople: 2, matchingPeople: 2 });
+            await ShiftModel.db.updateOne({ _id: shift._id }, { $set: { structures: [
+                        { structure: structureId.toHexString(), constraint: 'required', value: true, grade: 'very-negative' },
+                    ] } });
+            // matchingPeople is a coverage concern only; autofill uses the ranked pool up to requiredPeople.
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id,
+                users: [secondParticipantId, participantId],
+            });
+        });
+        it('counts a retained assignment outside the candidate filter', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2, assignments: [{ participant: secondParticipantId }] });
+            await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { state: 'reserved' } });
+            await plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: 'reserved' }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId, participantId] });
+        });
+        it('does not reject matchingPeople above requiredPeople', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 1, matchingPeople: 2 });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId] });
+        });
+        it('skips an overlapping high-scoring person instead of double booking', async () => {
+            const { plan, shift } = await setupAutofill();
+            await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, { assignments: [{ participant: secondParticipantId }] }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it.each([true, false])('respects absence enforcement with plan override %p', async (absenceEnforcement) => {
+            const { plan, shift } = await setupAutofill();
+            await absencesService.createAbsence({ customer: secondCustomerId, type: 'sickness', start: `${day}T00:00:00+02:00`, end: `${nextDay}T00:00:00+02:00` }, options);
+            await plansService.changePlan(plan._id, planInput(listId, { settingsOverrides: { absenceEnforcement } }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id,
+                users: [absenceEnforcement ? participantId : secondParticipantId],
+            });
+        });
+        it.each(['rest', 'dailyHours', 'consecutiveDays'])('enforces the general %s rule', async (rule) => {
+            const { plan, shift } = await setupAutofill(rule === 'consecutiveDays'
+                ? { day: nextDay, start: `${nextDay}T08:00:00+02:00`, end: `${nextDay}T12:00:00+02:00` } : {});
+            await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [{ participant: secondParticipantId }],
+                ...(rule === 'consecutiveDays' ? {} : { start: `${day}T00:00:00+02:00`, end: `${day}T04:00:00+02:00` }),
+            }), options);
+            const settings = policy();
+            if (rule === 'rest')
+                settings.minimumRest = { enabled: true, minutes: 660 };
+            if (rule === 'dailyHours')
+                settings.maximumDailyWorkMinutes = { enabled: true, minutes: 420 };
+            if (rule === 'consecutiveDays')
+                settings.maximumConsecutiveWorkingDays = { enabled: true, days: 1 };
+            await settingsService.changeSettings({ settings }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('uses a plan override to relax the general daily hours limit', async () => {
+            const { plan, shift } = await setupAutofill();
+            await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [{ participant: secondParticipantId }], start: `${day}T00:00:00+02:00`, end: `${day}T04:00:00+02:00`,
+            }), options);
+            const settings = policy();
+            settings.maximumDailyWorkMinutes = { enabled: true, minutes: 420 };
+            await settingsService.changeSettings({ settings }, options);
+            await plansService.changePlan(plan._id, planInput(listId, { settingsOverrides: { maximumDailyWorkMinutes: { enabled: false, minutes: 420 } } }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId] });
+        });
+        it('protects a future shift governed by another project plan rest override', async () => {
+            const { plan, shift } = await setupAutofill({ start: `${day}T20:00:00+02:00`, end: `${day}T23:00:00+02:00` });
+            const otherListId = new ObjectId();
+            const otherParticipantId = new ObjectId();
+            const otherOptions = { ...options, project: 'other-project' };
+            await settingsService.changeSettings({ settings: policy() }, otherOptions);
+            await ListsModel.db.insertOne({ ...list, _id: otherListId, project: otherOptions.project });
+            await ParticipantsModel.db.insertOne({ ...participant, _id: otherParticipantId, user: secondCustomerId, project: otherOptions.project, list: otherListId });
+            const otherPlan = await otherProjectPlan(otherListId, otherOptions, { minimumRest: { enabled: true, minutes: 660 } });
+            await shiftsService.createShift(otherPlan._id, shiftInput(otherPlan, planAreas(otherPlan)[0].area, {
+                day: nextDay, assignments: [{ participant: otherParticipantId }],
+            }), otherOptions);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('requires a valid shared break template when break rules demand it', async () => {
+            const { plan, shift } = await setupAutofill({ end: `${day}T16:00:00+02:00` });
+            const settings = policy();
+            settings.breaks.enabled = true;
+            await settingsService.changeSettings({ settings }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [] });
+            const breaks = [{ start: `${day}T12:00:00+02:00`, end: `${day}T12:30:00+02:00` }];
+            const originalBreaks = JSON.stringify(breaks);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options, breaks)).toStrictEqual({ shift: shift._id, users: [secondParticipantId] });
+            expect(JSON.stringify(breaks)).toBe(originalBreaks);
+            expect((await ShiftModel.db.findOne({ _id: shift._id })).assignments).toEqual([]);
+            await expect(shiftsService.autofillShift(plan._id, shift._id, options, [{ start: `${day}T07:00:00+02:00`, end: `${day}T08:00:00+02:00` }])).rejects.toThrow('VALIDATION_FAILED');
+        });
+        it('requires effective settings but accepts complete plan overrides without general settings', async () => {
+            const created = await plansService.createPlan(planInput(), options);
+            await createDays(created._id, options, [{ date: day, areas: areaLinks() }]);
+            const plan = (await plansService.singlePlan(created._id, options));
+            const shift = await shiftsService.createShift(plan._id, {
+                day: dayId(plan, day), area: housekeepingAreaId, title: 'Empty', start: `${day}T08:00:00+02:00`, end: `${day}T12:00:00+02:00`,
+                requiredPeople: 1, assignments: [],
+            }, options);
+            await expect(shiftsService.autofillShift(plan._id, shift._id, options)).rejects.toThrow('SHIFT_PLANNING_SETTINGS_NOT_CONFIGURED');
+            await plansService.changePlan(plan._id, planInput(listId, { settingsOverrides: policy() }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('uses the current plan list rather than a stale shift list', async () => {
+            const { plan, shift } = await setupAutofill();
+            await plansService.changePlan(plan._id, { ...planInput(), list: undefined }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [] });
+        });
+        it('does not read a foreign tenant or another plan shift', async () => {
+            const { plan, shift } = await setupAutofill();
+            await expect(shiftsService.autofillShift(plan._id, shift._id, { ...options, company: 'foreign' })).rejects.toThrow('SHIFT_PLAN_NOT_FOUND');
+            await expect(shiftsService.autofillShift(plan._id, shift._id, { ...options, project: 'foreign' })).rejects.toThrow('SHIFT_PLAN_NOT_FOUND');
+            await expect(shiftsService.autofillShift(plan._id, new ObjectId(), options)).rejects.toThrow('SHIFT_NOT_FOUND');
+            const sibling = await setupPlan();
+            await expect(shiftsService.autofillShift(sibling._id, shift._id, options)).rejects.toThrow('SHIFT_NOT_FOUND');
+        });
+        it('returns the resolved suggestion as a report without persisting it', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2 });
+            const before = await ShiftModel.db.findOne({ _id: shift._id });
+            const report = await shiftsService.autofillShiftReport(plan._id, shift._id, options);
+            const suggested = [secondParticipantId.toHexString(), participantId.toHexString()];
+            expect(report._id.equals(shift._id)).toBe(true);
+            expect((report.assignments || []).map((assignment) => assignment.participant.toHexString())).toEqual(suggested);
+            expect(report.participants.map((participant) => participant.participant.toHexString())).toEqual(suggested);
+            // all scheduling rules run, so a clean suggestion has no violations
+            expect(report.violations).toEqual([]);
+            expect(await ShiftModel.db.findOne({ _id: shift._id })).toEqual(before);
+        });
+    });
+    describe('scope shift autofill', () => {
+        it('reuses preparation and reads the company conflict window only once', async () => {
+            const plan = await setupPlan();
+            await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const shiftReads = jest.spyOn(ShiftModel.db, 'find');
+            const settingsReads = jest.spyOn(settingsService, 'singleSettings');
+            const participantReads = jest.spyOn(ParticipantsModel.db, 'find');
+            const customerReads = jest.spyOn(CustomersModel.db, 'find');
+            const structureReads = jest.spyOn(StructureModel.db, 'find');
+            const reports = await shiftsService.autofill({ level: 'plan', plan: plan._id }, options);
+            expect(reports[0].assignments).toHaveLength(1);
+            expect(shiftReads.mock.calls.filter(([query]) => query && 'assignments.customer' in query)).toHaveLength(1);
+            expect(settingsReads).toHaveBeenCalledTimes(1);
+            expect(participantReads).toHaveBeenCalledTimes(2);
+            expect(customerReads).toHaveBeenCalledTimes(2);
+            expect(structureReads).toHaveBeenCalledTimes(2);
+        });
+        it('does not expand the conflict window around distant neighbours', async () => {
+            const plan = await setupPlan();
+            const target = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const storedPlan = (await ShiftPlanModel.db.findOne({ _id: plan._id }));
+            const storedShift = (await ShiftModel.db.findOne({ _id: target._id }));
+            const neighbourPlan = new ObjectId();
+            const distantPlan = new ObjectId();
+            await ShiftPlanModel.db.insertMany([{ ...storedPlan, _id: neighbourPlan }, { ...storedPlan, _id: distantPlan }]);
+            await ShiftModel.db.insertMany([
+                { ...storedShift, _id: new ObjectId(), plan: neighbourPlan, start: '2027-08-01T08:00:00.000Z', end: '2027-08-01T12:00:00.000Z',
+                    assignments: [{ participant: secondParticipantId, customer: secondCustomerId, breaks: [] }] },
+                { ...storedShift, _id: new ObjectId(), plan: distantPlan, start: '2028-05-01T08:00:00.000Z', end: '2028-05-01T12:00:00.000Z',
+                    assignments: [{ participant: secondParticipantId, customer: secondCustomerId, breaks: [] }] },
+            ]);
+            const planReads = jest.spyOn(plansService, 'plansForCompany');
+            const reports = await shiftsService.autofill({ level: 'plan', plan: plan._id }, options);
+            expect(reports[0].assignments).toHaveLength(1);
+            expect(reports[0].violations).toEqual([]);
+            expect(planReads).toHaveBeenCalledTimes(1);
+            expect(planReads.mock.calls[0][0].map((id) => id.toHexString())).toEqual([neighbourPlan.toHexString()]);
+        });
+        it('still protects a future shift governed by another project rest override', async () => {
+            const plan = await setupPlan();
+            const target = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+                assignments: [], requiredPeople: 2, start: `${day}T20:00:00+02:00`, end: `${day}T23:00:00+02:00`,
+            }), options);
+            const otherListId = new ObjectId();
+            const otherParticipantId = new ObjectId();
+            const otherOptions = { ...options, project: 'other-project' };
+            await settingsService.changeSettings({ settings: policy() }, otherOptions);
+            await ListsModel.db.insertOne({ ...list, _id: otherListId, project: otherOptions.project });
+            await ParticipantsModel.db.insertOne({ ...participant, _id: otherParticipantId, user: secondCustomerId, project: otherOptions.project, list: otherListId });
+            const otherPlan = await otherProjectPlan(otherListId, otherOptions, { minimumRest: { enabled: true, minutes: 660 } });
+            await shiftsService.createShift(otherPlan._id, shiftInput(otherPlan, planAreas(otherPlan)[0].area, {
+                day: nextDay, assignments: [{ participant: otherParticipantId }],
+            }), otherOptions);
+            const reports = await shiftsService.autofill({ level: 'shift', plan: plan._id, shift: target._id }, options);
+            expect(reports[0].assignments.map((assignment) => assignment.participant.toHexString())).toEqual([participantId.toHexString()]);
+            expect(reports[0].violations).toEqual([]);
+        });
+        it('fills every under-staffed shift of a plan without double booking a person', async () => {
+            const plan = await setupPlan();
+            const morning = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+                assignments: [], requiredPeople: 1, start: `${day}T08:00:00+02:00`, end: `${day}T16:00:00+02:00`,
+            }), options);
+            const evening = await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [], requiredPeople: 1, start: `${day}T12:00:00+02:00`, end: `${day}T20:00:00+02:00`,
+            }), options);
+            const reports = await shiftsService.autofill({ level: 'plan', plan: plan._id }, options);
+            const byId = new Map(reports.map((report) => [report._id.toHexString(), report]));
+            expect([...byId.keys()].sort()).toEqual([morning._id.toHexString(), evening._id.toHexString()].sort());
+            const morningAssignee = byId.get(morning._id.toHexString()).assignments.map((assignment) => assignment.participant.toHexString());
+            const eveningAssignee = byId.get(evening._id.toHexString()).assignments.map((assignment) => assignment.participant.toHexString());
+            expect(morningAssignee).toHaveLength(1);
+            expect(eveningAssignee).toHaveLength(1);
+            // The shifts overlap, so the shared allocation cannot reuse the same person.
+            expect(morningAssignee[0]).not.toBe(eveningAssignee[0]);
+        });
+        it('restricts a day scope to that day only', async () => {
+            const plan = await setupPlan();
+            const today = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const tomorrow = await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [], requiredPeople: 1, day: nextDay, start: `${nextDay}T08:00:00+02:00`, end: `${nextDay}T16:00:00+02:00`,
+            }), options);
+            const reports = await shiftsService.autofill({ level: 'day', plan: plan._id, day: dayId(plan, day) }, options);
+            expect(reports.map((report) => report._id.toHexString())).toEqual([today._id.toHexString()]);
+            expect((await ShiftModel.db.findOne({ _id: tomorrow._id })).assignments).toEqual([]);
+        });
+        it('restricts a work area scope to that area only', async () => {
+            const plan = await setupPlan();
+            const housekeeping = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const reception = await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const reports = await shiftsService.autofill({ level: 'workArea', plan: plan._id, workArea: housekeepingAreaId }, options);
+            expect(reports.map((report) => report._id.toHexString())).toEqual([housekeeping._id.toHexString()]);
+            expect((await ShiftModel.db.findOne({ _id: reception._id })).assignments).toEqual([]);
+        });
+        it('fills a single shift for a shift scope without persisting it', async () => {
+            const plan = await setupPlan();
+            const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const reports = await shiftsService.autofill({ level: 'shift', plan: plan._id, shift: shift._id }, options);
+            expect(reports).toHaveLength(1);
+            expect(reports[0]._id.equals(shift._id)).toBe(true);
+            expect(reports[0].assignments).toHaveLength(1);
+            expect(reports[0].violations).toEqual([]);
+            expect((await ShiftModel.db.findOne({ _id: shift._id })).assignments).toEqual([]);
+        });
+        it('treats an overlapping shift in another plan as a conflict neighbour', async () => {
+            const plan = await setupPlan();
+            const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const sibling = await setupPlan();
+            await shiftsService.createShift(sibling._id, shiftInput(sibling, housekeepingAreaId, {
+                assignments: [{ participant: secondParticipantId }], start: `${day}T08:00:00+02:00`, end: `${day}T16:00:00+02:00`,
+            }), options);
+            const reports = await shiftsService.autofill({ level: 'shift', plan: plan._id, shift: shift._id }, options);
+            expect(reports[0].assignments.map((assignment) => assignment.participant.toHexString())).toEqual([participantId.toHexString()]);
+        });
+    });
 });
 //# sourceMappingURL=shiftPlanning.spec.js.map