@lilaquadrat/studio 12.1.0 → 12.3.0

package/lib/src/services/shiftPlans.service.d.ts

@@ -0,0 +1,24 @@
+import { ObjectId, WithId } from 'mongodb';
+import type { ShiftPlan, ShiftPlanChangeInput, ShiftPlanCreateInput, ShiftPlanFilters, ShiftPlanResponse, ShiftPlanningPage, ShiftPlanningProjectOptions, ShiftPlanningCompanyOptions } from '@lilaquadrat/interfaces';
+import Immutable from '../Immutable.class.js';
+/** A plan is the top-level scheduling unit; its employee list is an optional, reusable reference. Days are separate documents. */
+export declare class ShiftPlansService extends Immutable<ShiftPlan> {
+    model: import("../classes/shiftPlanningModel.class.js").default<ShiftPlan>;
+    private employeeList;
+    /** One binding per work area, each category must belong to the linked employee list. */
+    private workAreaCategories;
+    private configuration;
+    /** Name/date overlap is intentional: departments and successive weeks may reuse the same pool. */
+    createPlan(input: ShiftPlanCreateInput, options: ShiftPlanningProjectOptions): Promise<ShiftPlanResponse>;
+    singlePlan(plan: ObjectId, options: ShiftPlanningProjectOptions): Promise<ShiftPlanResponse | null>;
+    changePlan(plan: ObjectId, input: ShiftPlanChangeInput, options: ShiftPlanningProjectOptions): Promise<ShiftPlanResponse>;
+    listPlans(filters: ShiftPlanFilters, options: ShiftPlanningProjectOptions): Promise<ShiftPlanningPage<ShiftPlanResponse>>;
+    planForScheduling(plan: ObjectId, options: ShiftPlanningProjectOptions): Promise<WithId<ShiftPlan>>;
+    planForScheduling(plan: ObjectId, options: ShiftPlanningProjectOptions, required: false): Promise<WithId<ShiftPlan> | null>;
+    plansForProject(options: ShiftPlanningProjectOptions, list?: ObjectId): Promise<WithId<ShiftPlan>[]>;
+    /** Labor checks may span projects; callers return only diagnostics, never these other plans' details. */
+    plansForCompany(plans: ObjectId[], options: ShiftPlanningCompanyOptions): Promise<WithId<ShiftPlan>[]>;
+    private responses;
+}
+declare const _default: ShiftPlansService;
+export default _default;

package/lib/src/services/shiftPlans.service.js

@@ -0,0 +1,139 @@
+import Immutable from '../Immutable.class.js';
+import ImmutableError from '../classes/errors/Immutable.error.js';
+import PlanModel from '../models/shiftPlan.model.js';
+import ListsService from './lists.service.js';
+import WorkAreasService from './workAreas.service.js';
+import ShiftPlanDaysService from './shiftPlanDays.service.js';
+import ShiftsService from './shifts.service.js';
+import SettingsService from './shiftPlanningSettings.service.js';
+import { effectivePolicy, localFormatter, normalizeDate, planningValidation, validatePolicy } from '../helpers/shiftPlanningTime.js';
+import { assertUniquePlanningIds, planningPage, planningPagination, planningSearch } from '../helpers/shiftPlanningValidation.js';
+/** A plan is the top-level scheduling unit; its employee list is an optional, reusable reference. Days are separate documents. */
+export class ShiftPlansService extends Immutable {
+    constructor() {
+        super(...arguments);
+        this.model = PlanModel;
+    }
+    async employeeList(list, options) {
+        if (!list)
+            return undefined;
+        const result = await ListsService.singleForPlanning(list, options);
+        if (!result)
+            throw new ImmutableError('LIST_NOT_FOUND');
+        return result;
+    }
+    /** One binding per work area, each category must belong to the linked employee list. */
+    async workAreaCategories(input, list, options) {
+        if (input.workAreaCategories === undefined)
+            return undefined;
+        const entries = input.workAreaCategories.filter((entry) => (entry.categoryIds ?? []).length);
+        if (!entries.length)
+            return [];
+        const areaIds = entries.map((entry) => entry.area);
+        assertUniquePlanningIds(areaIds.map((area) => area.toHexString()), '/workAreaCategories');
+        const areas = await WorkAreasService.areasForPlanning(areaIds, options);
+        if (areas.length !== new Set(areaIds.map((area) => area.toHexString())).size)
+            planningValidation('/workAreaCategories', 'work areas must exist in this project');
+        const listCategoryIds = new Set((list?.categories ?? []).map((category) => category._id.toHexString()));
+        entries.forEach((entry) => {
+            const ids = entry.categoryIds ?? [];
+            assertUniquePlanningIds(ids.map((category) => category.toHexString()), '/workAreaCategories/categoryIds');
+            if (!list)
+                planningValidation('/workAreaCategories/categoryIds', 'categories require a linked employee list');
+            if (ids.some((category) => !listCategoryIds.has(category.toHexString())))
+                planningValidation('/workAreaCategories/categoryIds', 'categories must belong to this employee list');
+        });
+        return entries;
+    }
+    async configuration(input, list, options) {
+        localFormatter(input.timeZone);
+        const settings = await SettingsService.singleSettings(options);
+        const overrides = input.settingsOverrides ?? {};
+        validatePolicy({ ...settings?.settings, ...overrides });
+        const workAreaCategories = await this.workAreaCategories(input, list, options);
+        if (input.workHours !== undefined && input.workHours.start >= input.workHours.end)
+            planningValidation('/workHours/end', 'end must be after start');
+        return {
+            name: input.name, timeZone: input.timeZone, settingsOverrides: overrides,
+            ...(workAreaCategories !== undefined ? { workAreaCategories } : {}),
+            ...(input.defaultParticipantState !== undefined ? { defaultParticipantState: input.defaultParticipantState } : {}),
+            ...(input.workHours !== undefined ? { workHours: input.workHours } : {}),
+        };
+    }
+    /** Name/date overlap is intentional: departments and successive weeks may reuse the same pool. */
+    async createPlan(input, options) {
+        const { list } = input;
+        const listDocument = await this.employeeList(list, options);
+        const configuration = await this.configuration(input, listDocument, options);
+        const created = await this.create({ company: options.company, project: options.project, ...(list ? { list } : {}), ...configuration }, options.user, options.app);
+        return (await this.singlePlan(created._id, options));
+    }
+    async singlePlan(plan, options) {
+        const document = await this.planForScheduling(plan, options, false);
+        if (!document)
+            return null;
+        const response = (await this.responses([document], options))[0];
+        // The plan detail is edited as a whole, so one request carries its schedule instead of a separate shifts list.
+        const shifts = await ShiftsService.listShifts(plan, {}, options);
+        return { ...response, shifts: shifts.data };
+    }
+    async changePlan(plan, input, options) {
+        await this.planForScheduling(plan, options);
+        const { list } = input;
+        const listDocument = await this.employeeList(list, options);
+        const configuration = await this.configuration(input, listDocument, options);
+        await ShiftsService.assertPlanTimeZone(plan, configuration.timeZone, options);
+        await this.immutable({ _id: plan, company: options.company, project: options.project }, { ...configuration, ...(list ? { list } : {}) }, options.user, 'change', options.app);
+        return (await this.singlePlan(plan, options));
+    }
+    async listPlans(filters, options) {
+        const from = filters.from ? normalizeDate(filters.from) : undefined;
+        const to = filters.to ? normalizeDate(filters.to) : undefined;
+        if (from && to && from >= to)
+            planningValidation('/to', 'must be after from');
+        const query = { company: options.company, project: options.project };
+        if (filters.list)
+            query.list = filters.list;
+        const search = planningSearch(filters.search);
+        if (search)
+            query.name = { $regex: search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), $options: 'i' };
+        if (from || to) {
+            const plans = await ShiftPlanDaysService.plansInRange(from, to, options);
+            query._id = { $in: plans };
+        }
+        const { site, limit, skip } = planningPagination(filters);
+        const all = await this.model.db.countDocuments(query);
+        const plans = await this.model.db.find(query).sort({ name: 1, _id: 1 }).skip(skip).limit(limit).toArray();
+        return planningPage(await this.responses(plans, options), all, site, limit);
+    }
+    async planForScheduling(plan, options, required = true) {
+        const document = await this.model.db.findOne({ _id: plan, company: options.company, project: options.project });
+        if (!document && required)
+            throw new ImmutableError('SHIFT_PLAN_NOT_FOUND');
+        return document;
+    }
+    plansForProject(options, list) {
+        return this.model.db.find({ company: options.company, project: options.project, ...(list ? { list } : {}) }).toArray();
+    }
+    /** Labor checks may span projects; callers return only diagnostics, never these other plans' details. */
+    plansForCompany(plans, options) {
+        return this.model.db.find({ company: options.company, _id: { $in: plans } }).toArray();
+    }
+    async responses(plans, options) {
+        const settings = await SettingsService.singleSettings(options);
+        const days = await ShiftPlanDaysService.daysForPlans(plans.map((plan) => plan._id), options);
+        const areas = await WorkAreasService.areasForPlanning(days.flatMap((day) => (day.areas ?? []).map((link) => link.area)), options);
+        const listIds = plans.map((plan) => plan.list).filter((list) => !!list);
+        const lists = listIds.length ? await ListsService.listsForPlanning(listIds, options) : [];
+        return plans.map((plan) => {
+            const planDays = days.filter((day) => day.plan.equals(plan._id));
+            const list = plan.list ? lists.find((document) => document._id.equals(plan.list)) : undefined;
+            return { ...plan, days: planDays, effectiveSettings: effectivePolicy(settings?.settings, plan.settingsOverrides),
+                workAreas: areas.filter((area) => planDays.some((day) => (day.areas ?? []).some((link) => link.area.equals(area._id)))),
+                ...(list?.categories?.length ? { categories: list.categories } : {}),
+            };
+        });
+    }
+}
+export default new ShiftPlansService();
+//# sourceMappingURL=shiftPlans.service.js.map

package/lib/src/services/shiftPlans.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shiftPlans.service.js","sourceRoot":"","sources":["../../../src/services/shiftPlans.service.ts"],"names":[],"mappings":"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"}

package/lib/src/services/shifts.service.d.ts

@@ -0,0 +1,46 @@
+import { ObjectId, WithId } from 'mongodb';
+import type { MemberShift, MemberShiftFilters, PlanningScope, Shift, ShiftAssignmentBreak, ShiftAssignmentsInput, ShiftCreateInput, ShiftInput, ShiftPlanDay, ShiftPlanningFilters, ShiftPlanningPage, ShiftResponse, ShiftPlanningProjectOptions } from '@lilaquadrat/interfaces';
+import Immutable from '../Immutable.class.js';
+import type { ShiftAutofillResult } from '../interfaces/ShiftAutofillResult.js';
+/** Scheduling owns employee allocation; work areas and plans only supply reusable identity/configuration. */
+export declare class ShiftsService extends Immutable<Shift> {
+    model: import("../classes/shiftPlanningModel.class.js").default<Shift>;
+    private normalizedTime;
+    private document;
+    private resolvedAssignments;
+    createShift(plan: ObjectId, input: ShiftCreateInput, options: ShiftPlanningProjectOptions): Promise<ShiftResponse>;
+    singleShift(plan: ObjectId, shift: ObjectId, options: ShiftPlanningProjectOptions): Promise<ShiftResponse | null>;
+    listShifts(plan: ObjectId, filters: ShiftPlanningFilters, options: ShiftPlanningProjectOptions): Promise<ShiftPlanningPage<ShiftResponse>>;
+    /** Absolute break times survive edits; moving a shift outside them must be resolved explicitly by the planner. */
+    changeShift(plan: ObjectId, shift: ObjectId, input: ShiftInput, options: ShiftPlanningProjectOptions): Promise<ShiftResponse>;
+    removeShift(plan: ObjectId, shift: ObjectId, options: ShiftPlanningProjectOptions): Promise<void>;
+    replaceAssignments(plan: ObjectId, shift: ObjectId, input: ShiftAssignmentsInput, options: ShiftPlanningProjectOptions): Promise<ShiftResponse>;
+    /** Suggestions use the manual assignment rules without applying the proposed allocation. */
+    autofillShift(plan: ObjectId, shift: ObjectId, options: ShiftPlanningProjectOptions, breaks?: ShiftAssignmentBreak[]): Promise<ShiftAutofillResult>;
+    /**
+     * Same allocation and rules as autofillShift, but resolves the suggestion into assignments and
+     * returns the recomputed shift, so a caller can apply it without a second round trip. Nothing is
+     * persisted; applying the result still goes through the normal assignment validation.
+     */
+    autofillShiftReport(plan: ObjectId, shift: ObjectId, options: ShiftPlanningProjectOptions, breaks?: ShiftAssignmentBreak[]): Promise<ShiftResponse>;
+    /**
+     * Rule-checked suggestions for every under-staffed shift in a plan, day, work area or single shift.
+     * Shifts are filled greedily in start order against one shared allocation, so a person already
+     * picked for a colliding shift is not picked again; other plans act only as conflict neighbours.
+     * Nothing is persisted; applying a result still goes through the normal assignment validation.
+     */
+    autofill(scope: PlanningScope, options: ShiftPlanningProjectOptions, breaks?: ShiftAssignmentBreak[]): Promise<ShiftResponse[]>;
+    hasWorkAreaAssignments(area: ObjectId, options: ShiftPlanningProjectOptions): Promise<boolean>;
+    /** A plan cannot change its time zone while existing shifts would no longer match their day's local date. */
+    assertPlanTimeZone(plan: ObjectId, timeZone: string, options: ShiftPlanningProjectOptions): Promise<void>;
+    hasDayShifts(day: ObjectId, options: ShiftPlanningProjectOptions): Promise<boolean>;
+    /** A day cannot drop an area or change its date while shifts still reference it. */
+    assertDayReferences(previous: WithId<ShiftPlanDay>, configuration: Pick<ShiftPlanDay, 'date' | 'areas'>, options: ShiftPlanningProjectOptions): Promise<void>;
+    myShifts(customer: ObjectId, filters: MemberShiftFilters, options: ShiftPlanningProjectOptions): Promise<ShiftPlanningPage<MemberShift>>;
+    private reportContext;
+    private reports;
+    private scheduleNeighbors;
+    private validateSchedule;
+}
+declare const _default: ShiftsService;
+export default _default;

package/lib/src/services/shifts.service.js

@@ -0,0 +1,405 @@
+import { ObjectId } from 'mongodb';
+import Immutable from '../Immutable.class.js';
+import ImmutableError from '../classes/errors/Immutable.error.js';
+import ShiftModel from '../models/shift.model.js';
+import ShiftPlansService from './shiftPlans.service.js';
+import ShiftPlanDaysService from './shiftPlanDays.service.js';
+import WorkAreasService from './workAreas.service.js';
+import SettingsService from './shiftPlanningSettings.service.js';
+import AbsencesService from './employeeAbsences.service.js';
+import ListsService from './lists.service.js';
+import ParticipantsService from './listParticipants.service.js';
+import CustomersService from './customers.service.js';
+import { effectivePolicy, interval, localDate, maximumShiftMilliseconds, normalizeBreaks, planningValidation } from '../helpers/shiftPlanningTime.js';
+import { assertUniquePlanningIds, equalAssignmentSets, equalBreaks, newScheduleViolations, planningIntervalFilter, planningPage, planningPagination, } from '../helpers/shiftPlanningValidation.js';
+import { allocateShiftFills } from '../helpers/shiftPlanAllocation.js';
+import { boundedPlanningInstant, reportShift, scheduleWindowMilliseconds, unavailableParticipantStates } from '../helpers/shiftPlanningReports.js';
+/** Scheduling owns employee allocation; work areas and plans only supply reusable identity/configuration. */
+export class ShiftsService extends Immutable {
+    constructor() {
+        super(...arguments);
+        this.model = ShiftModel;
+    }
+    normalizedTime(input, plan, day) {
+        const normalized = { ...input, ...interval(input.start, input.end) };
+        if (Date.parse(normalized.end) - Date.parse(normalized.start) > maximumShiftMilliseconds)
+            planningValidation('/end', 'a shift must not exceed seven days');
+        if (localDate(normalized.start, plan.timeZone) !== day.date) {
+            planningValidation('/day', 'must match the local start date of its day');
+        }
+        if (!(day.areas ?? []).some((link) => link.area.equals(input.area))) {
+            planningValidation('/area', 'must be a work area linked to this day');
+        }
+        return normalized;
+    }
+    async document(plan, shift, options) {
+        await ShiftPlansService.planForScheduling(plan, options);
+        const document = await this.model.db.findOne({ _id: shift, company: options.company, project: options.project, plan });
+        if (!document)
+            throw new ImmutableError('SHIFT_NOT_FOUND');
+        return document;
+    }
+    async resolvedAssignments(inputs, shift, options, previous) {
+        assertUniquePlanningIds(inputs.map((entry) => entry.participant.toHexString()), '/assignments');
+        const { list } = shift;
+        if (inputs.length && !list)
+            planningValidation('/assignments', 'assignments require a linked employee list');
+        const assignments = [];
+        for (const input of inputs) {
+            const breaks = (input.breaks ?? []).map((entry) => interval(entry.start, entry.end));
+            const existing = previous?.assignments.find((entry) => entry.participant.equals(input.participant));
+            // Retain the original customer anchor when the list entry has since been canceled or removed.
+            if (existing && equalBreaks(existing.breaks, breaks)) {
+                assignments.push(normalizeBreaks(shift, existing));
+                continue;
+            }
+            const participant = await ParticipantsService.singleForPlanning(list, input.participant, options);
+            if (!participant || unavailableParticipantStates.has(participant.state))
+                planningValidation('/assignments/participant', 'participant is not available in this list');
+            const customer = (await CustomersService.peopleForPlanning([participant.user], options.company))[0];
+            if (!customer)
+                planningValidation('/assignments/participant', 'participant must identify a person in this company');
+            assignments.push(normalizeBreaks(shift, { participant: input.participant, customer: customer._id, breaks }));
+        }
+        // Several list entries can represent one person; participant identity alone cannot prevent double allocation.
+        assertUniquePlanningIds(assignments.map((entry) => entry.customer.toHexString()), '/assignments');
+        return assignments;
+    }
+    async createShift(plan, input, options) {
+        const configuration = await ShiftPlansService.planForScheduling(plan, options);
+        const day = await ShiftPlanDaysService.dayForScheduling(plan, input.day, options);
+        const list = configuration.list;
+        const { assignments, ...time } = input;
+        const candidate = { ...this.normalizedTime(time, configuration, day), _id: new ObjectId(),
+            company: options.company, project: options.project, plan, ...(list ? { list } : {}), assignments: [],
+        };
+        candidate.assignments = await this.resolvedAssignments(assignments ?? [], candidate, options);
+        await this.validateSchedule(candidate, options);
+        const { _id, ...data } = candidate;
+        const created = await this.create(data, options.user, options.app);
+        return (await this.singleShift(plan, created._id, options));
+    }
+    async singleShift(plan, shift, options) {
+        await ShiftPlansService.planForScheduling(plan, options);
+        const document = await this.model.db.findOne({ _id: shift, company: options.company, project: options.project, plan });
+        return document ? (await this.reports([document], options, undefined, undefined, plan))[0] : null;
+    }
+    async listShifts(plan, filters, options) {
+        await ShiftPlansService.planForScheduling(plan, options);
+        const query = { company: options.company, project: options.project, plan, ...planningIntervalFilter(filters) };
+        if (filters.area)
+            query.area = filters.area;
+        const { site, limit, skip } = planningPagination(filters);
+        const all = await this.model.db.countDocuments(query);
+        const documents = await this.model.db.find(query).sort({ start: 1, _id: 1 }).skip(skip).limit(limit).toArray();
+        return planningPage(await this.reports(documents, options, undefined, undefined, plan), all, site, limit);
+    }
+    /** Absolute break times survive edits; moving a shift outside them must be resolved explicitly by the planner. */
+    async changeShift(plan, shift, input, options) {
+        const previous = await this.document(plan, shift, options);
+        const configuration = await ShiftPlansService.planForScheduling(plan, options);
+        const day = await ShiftPlanDaysService.dayForScheduling(plan, input.day, options);
+        const time = this.normalizedTime(input, configuration, day);
+        const candidate = { ...previous, ...time };
+        candidate.assignments = candidate.assignments.map((assignment) => normalizeBreaks(candidate, assignment));
+        await this.validateSchedule(candidate, options, previous);
+        const list = configuration.list;
+        await this.immutable({ _id: shift, company: options.company, project: options.project, plan }, { ...time, ...(list ? { list } : {}) }, options.user, 'change', options.app);
+        return (await this.singleShift(plan, shift, options));
+    }
+    async removeShift(plan, shift, options) {
+        await this.document(plan, shift, options);
+        await this.delete(shift, options.user, options.app);
+    }
+    async replaceAssignments(plan, shift, input, options) {
+        const previous = await this.document(plan, shift, options);
+        const configuration = await ShiftPlansService.planForScheduling(plan, options);
+        const list = configuration.list;
+        // The plan owns the employee list; a shift persisted before the plan was linked must resolve against it.
+        const target = { ...previous, ...(list ? { list } : {}) };
+        const assignments = await this.resolvedAssignments(input.assignments, target, options, previous);
+        if (!equalAssignmentSets(assignments, previous.assignments)) {
+            await this.validateSchedule({ ...target, assignments }, options, previous);
+            await this.immutable({ _id: shift, company: options.company, project: options.project, plan }, { assignments, ...(list ? { list } : {}) }, options.user, 'change', options.app, undefined, undefined, 'assignments');
+        }
+        return (await this.singleShift(plan, shift, options));
+    }
+    /** Suggestions use the manual assignment rules without applying the proposed allocation. */
+    async autofillShift(plan, shift, options, breaks = []) {
+        const configuration = await ShiftPlansService.planForScheduling(plan, options);
+        const previous = await this.model.db.findOne({ _id: shift, company: options.company, project: options.project, plan });
+        if (!previous)
+            throw new ImmutableError('SHIFT_NOT_FOUND');
+        // Existing attention items belong to the planner; autofill must not silently remove their assignments.
+        const result = { shift: previous._id, users: previous.assignments.map((assignment) => assignment.participant) };
+        // An absent staffing target is not permission to fill the shift with the entire employee pool.
+        const requiredPeople = previous.requiredPeople ?? 0;
+        if (requiredPeople <= previous.assignments.length)
+            return result;
+        // A plan may have changed lists since this shift was saved; its current configuration is authoritative.
+        const list = configuration.list;
+        if (!list)
+            return result;
+        const target = { ...previous, list };
+        const categories = configuration.workAreaCategories?.find((binding) => binding.area.equals(target.area))?.categoryIds;
+        const state = configuration.defaultParticipantState ? [configuration.defaultParticipantState] : undefined;
+        // The pool is ranked by qualification, then raw score; normalized stages would merge different scores.
+        // Inspect every candidate because scheduling conflicts can rule out an entire page of higher-ranked people.
+        const pool = await ParticipantsService.planningParticipants(list, { level: 'shift', shift: target._id, workArea: target.area }, state, categories, undefined, {
+            ...options, skip: 0, limit: Number.MAX_SAFE_INTEGER, sort: { _id: 1 },
+        });
+        // Multiple list entries can identify the same person, including someone already assigned to this shift.
+        const seenCustomers = new Set(previous.assignments.map((assignment) => assignment.customer.toHexString()));
+        const candidates = [];
+        for (const candidate of pool.data) {
+            const customer = candidate.user?._id;
+            if (!customer || unavailableParticipantStates.has(candidate.state) || seenCustomers.has(customer.toHexString()))
+                continue;
+            seenCustomers.add(customer.toHexString());
+            // Only supplied breaks are considered; inventing break times would leave callers unable to apply an ID-only result.
+            candidates.push(normalizeBreaks(target, { participant: candidate._id, customer, breaks }));
+        }
+        if (!candidates.length)
+            return result;
+        // The probe expands the shared read scope to all possible picks; it is never an actual allocation.
+        // Loading this context once avoids database queries inside the candidate loop.
+        const probe = { ...target, assignments: [...previous.assignments, ...candidates] };
+        const neighbors = await this.scheduleNeighbors(probe, options, previous);
+        const otherNeighbors = neighbors.filter((neighbor) => !neighbor._id.equals(target._id));
+        const context = await this.reportContext([...otherNeighbors, probe], options);
+        // Missing or incompatible settings must not silently disable scheduling checks.
+        if (!effectivePolicy(context.settings, configuration.settingsOverrides))
+            throw new ImmutableError('SHIFT_PLANNING_SETTINGS_NOT_CONFIGURED');
+        // Persisted violation severities are the baseline, so existing attention items need not block safe additions.
+        // Working-time totals are unnecessary here; only rule violations influence selection.
+        const baseline = new Map();
+        for (const neighbor of neighbors)
+            reportShift(neighbor, context, false, baseline);
+        const otherSchedules = context.schedules.filter((scheduled) => !scheduled._id.equals(target._id));
+        const assignments = [...previous.assignments];
+        for (const candidate of candidates) {
+            if (assignments.length >= requiredPeople)
+                break;
+            const proposed = { ...target, assignments: [...assignments, candidate] };
+            // Replace the shift only in memory so neighboring plans can reveal new rest or hours violations.
+            const proposedContext = { ...context, schedules: [...otherSchedules, proposed] };
+            const updatedEvidence = new Map();
+            const updated = [...otherNeighbors, proposed]
+                .map((document) => reportShift(document, proposedContext, false, updatedEvidence));
+            // Availability may have changed between the pool query and the later context reads.
+            if (updated[updated.length - 1].unavailableParticipantIds.includes(candidate.participant.toHexString()))
+                continue;
+            if (newScheduleViolations(proposed, previous, updated, baseline, updatedEvidence).length)
+                continue;
+            assignments.push(candidate);
+            result.users.push(candidate.participant);
+        }
+        // A partial result is intentional, not a reservation; applying it later still requires assignment validation.
+        return result;
+    }
+    /**
+     * Same allocation and rules as autofillShift, but resolves the suggestion into assignments and
+     * returns the recomputed shift, so a caller can apply it without a second round trip. Nothing is
+     * persisted; applying the result still goes through the normal assignment validation.
+     */
+    async autofillShiftReport(plan, shift, options, breaks = []) {
+        const result = await this.autofillShift(plan, shift, options, breaks);
+        const previous = await this.document(plan, shift, options);
+        const configuration = await ShiftPlansService.planForScheduling(plan, options);
+        // The plan owns the employee list; a shift persisted before the plan was linked must resolve against it.
+        const target = { ...previous, ...(configuration.list ? { list: configuration.list } : {}) };
+        const assignments = await this.resolvedAssignments(result.users.map((participant) => ({ participant, breaks })), target, options, previous);
+        const proposal = { ...target, assignments };
+        return (await this.reports([proposal], options, proposal))[0];
+    }
+    /**
+     * Rule-checked suggestions for every under-staffed shift in a plan, day, work area or single shift.
+     * Shifts are filled greedily in start order against one shared allocation, so a person already
+     * picked for a colliding shift is not picked again; other plans act only as conflict neighbours.
+     * Nothing is persisted; applying a result still goes through the normal assignment validation.
+     */
+    async autofill(scope, options, breaks = []) {
+        if (!scope.plan)
+            return [];
+        const configuration = await ShiftPlansService.planForScheduling(scope.plan, options);
+        const list = configuration.list;
+        if (!list)
+            return [];
+        const preparation = await ParticipantsService.prepareShiftPlanning(list, scope, options);
+        if (!preparation || !preparation.targets.length)
+            return [];
+        // The pool arrives ranked; carrying breaks and keeping one entry per person matches a manual pick.
+        const targets = preparation.targets.map((target) => {
+            const shift = { ...target.shift, list };
+            const seen = new Set(shift.assignments.map((assignment) => assignment.customer.toHexString()));
+            const candidates = [];
+            for (const candidate of target.candidates) {
+                const customer = candidate.customer.toHexString();
+                if (seen.has(customer))
+                    continue;
+                seen.add(customer);
+                candidates.push({ ...candidate, breaks: normalizeBreaks(shift, { participant: candidate.participant, customer: candidate.customer, breaks }).breaks });
+            }
+            return { ...target, shift, candidates };
+        });
+        // The probe widens the shared context read to every possible pick; it is never an allocation.
+        const probes = targets.map((target) => ({
+            ...target.shift,
+            assignments: [...target.shift.assignments, ...target.candidates.map((candidate) => ({ participant: candidate.participant, customer: candidate.customer, breaks: [] }))],
+        }));
+        const customerIds = [...new Map(probes.flatMap((probe) => probe.assignments.map((assignment) => [assignment.customer.toHexString(), assignment.customer]))).values()];
+        const starts = probes.map((probe) => Date.parse(probe.start));
+        const ends = probes.map((probe) => Date.parse(probe.end));
+        // Only this scope's shifts may be filled, but conflicts in every plan are compared, as manual edits do.
+        const neighbours = await this.model.db.find({ company: options.company, 'assignments.customer': { $in: customerIds },
+            end: { $gt: boundedPlanningInstant(Math.min(...starts) - scheduleWindowMilliseconds) },
+            start: { $lt: boundedPlanningInstant(Math.max(...ends) + scheduleWindowMilliseconds) },
+        }).toArray();
+        // The neighbours already cover the complete rule window; expanding around them would grow it again.
+        const context = await this.reportContext([...neighbours, ...probes], options, { schedules: neighbours, preparation });
+        // Missing or incompatible settings must not silently disable scheduling checks.
+        if (!effectivePolicy(context.settings, configuration.settingsOverrides))
+            throw new ImmutableError('SHIFT_PLANNING_SETTINGS_NOT_CONFIGURED');
+        const schedules = [...new Map([...context.schedules, ...targets.map((target) => target.shift)].map((shift) => [shift._id.toHexString(), shift])).values()];
+        const allocation = allocateShiftFills(schedules, targets, context, { matchingGate: false, breaksBlocking: true, stopOnUnfillable: false });
+        // Report against the finished allocation so overlaps between the suggested shifts are visible.
+        const filled = [...new Map([...context.schedules, ...allocation.shifts].map((shift) => [shift._id.toHexString(), shift])).values()];
+        return allocation.shifts.map((shift) => reportShift(shift, { ...context, schedules: filled }));
+    }
+    async hasWorkAreaAssignments(area, options) {
+        return await this.model.db.countDocuments({ company: options.company, project: options.project, area }) > 0;
+    }
+    /** A plan cannot change its time zone while existing shifts would no longer match their day's local date. */
+    async assertPlanTimeZone(plan, timeZone, options) {
+        const shifts = await this.model.db.find({ company: options.company, project: options.project, plan }).toArray();
+        if (!shifts.length)
+            return;
+        const days = await ShiftPlanDaysService.daysForPlans([plan], options);
+        if (shifts.some((shift) => {
+            const day = days.find((entry) => entry._id.equals(shift.day));
+            return !day || localDate(shift.start, timeZone) !== day.date;
+        }))
+            throw new ImmutableError('SHIFT_PLAN_REFERENCES_IN_USE');
+    }
+    async hasDayShifts(day, options) {
+        return await this.model.db.countDocuments({ company: options.company, project: options.project, day }) > 0;
+    }
+    /** A day cannot drop an area or change its date while shifts still reference it. */
+    async assertDayReferences(previous, configuration, options) {
+        const plan = await ShiftPlansService.planForScheduling(previous.plan, options);
+        const shifts = await this.model.db.find({ company: options.company, project: options.project, day: previous._id }).toArray();
+        if (shifts.some((shift) => localDate(shift.start, plan.timeZone) !== configuration.date
+            || !(configuration.areas ?? []).some((link) => link.area.equals(shift.area)))) {
+            throw new ImmutableError('SHIFT_PLAN_REFERENCES_IN_USE');
+        }
+    }
+    async myShifts(customer, filters, options) {
+        if (!await CustomersService.memberForPlanning(customer, options))
+            throw new ImmutableError('MEMBER_NOT_ALLOWED');
+        const plans = await ShiftPlansService.plansForProject(options, filters.list);
+        const lists = await ListsService.listsForPlanning(plans.map((plan) => plan.list).filter((list) => list !== undefined), options);
+        const days = await ShiftPlanDaysService.daysForPlans(plans.map((plan) => plan._id), options);
+        const areas = await WorkAreasService.areasForPlanning(days.flatMap((day) => (day.areas ?? []).map((link) => link.area)), options);
+        const planLinks = (plan) => days.filter((day) => day.plan.equals(plan._id)).flatMap((day) => day.areas ?? []);
+        const visiblePlans = plans.filter((plan) => plan.list && lists.some((list) => list._id.equals(plan.list))
+            && planLinks(plan).some((link) => areas.some((area) => area._id.equals(link.area))));
+        const { site, limit, skip } = planningPagination(filters);
+        if (!visiblePlans.length)
+            return planningPage([], 0, site, limit);
+        // Filtering usable references before pagination avoids disclosing totals for orphaned assignments.
+        const query = { company: options.company, project: options.project, 'assignments.customer': customer, ...planningIntervalFilter(filters),
+            $or: visiblePlans.map((plan) => ({ plan: plan._id, list: plan.list,
+                area: { $in: planLinks(plan).map((link) => link.area).filter((area) => areas.some((entry) => entry._id.equals(area))) },
+                assignments: { $elemMatch: { customer } },
+            })), };
+        const all = await this.model.db.countDocuments(query);
+        const shifts = await this.model.db.find(query).sort({ start: 1, _id: 1 }).skip(skip).limit(limit).toArray();
+        const data = [];
+        for (const shift of shifts) {
+            const plan = visiblePlans.find((entry) => entry._id.equals(shift.plan));
+            const list = lists.find((entry) => entry._id.equals(shift.list));
+            const assignment = shift.assignments.find((entry) => entry.customer.equals(customer));
+            const area = areas.find((entry) => entry._id.equals(shift.area));
+            const day = days.find((entry) => entry._id.equals(shift.day));
+            if (!plan || !list || !assignment || !area || !day)
+                continue;
+            // Explicit projection keeps future internal area/shift fields out of the member contract automatically.
+            const publicArea = { _id: area._id, name: area.name };
+            if (area.description !== undefined)
+                publicArea.description = area.description;
+            if (area.location !== undefined)
+                publicArea.location = area.location;
+            if (area.address !== undefined)
+                publicArea.address = area.address;
+            data.push({ _id: shift._id, day: day.date, title: shift.title, start: shift.start, end: shift.end,
+                plan: { _id: plan._id, name: plan.name, timeZone: plan.timeZone }, list: { _id: list._id, name: list.name }, area: publicArea, breaks: assignment.breaks,
+            });
+        }
+        return planningPage(data, all, site, limit);
+    }
+    async reportContext(documents, options, contextOptions = {}) {
+        const { replacement, plan, preparation } = contextOptions;
+        const customerIds = [...new Map(documents.flatMap((shift) => shift.assignments.map((entry) => [entry.customer.toHexString(), entry.customer]))).values()];
+        const earliest = Math.min(...documents.map((shift) => Date.parse(shift.start)));
+        const latest = Math.max(...documents.map((shift) => Date.parse(shift.end)));
+        // Plan reads stay inside their plan; scheduling writes omit the scope to keep their company-wide conflict checks.
+        const schedules = contextOptions.schedules ?? await this.model.db.find({ company: options.company, ...(plan ? { plan } : {}), 'assignments.customer': { $in: customerIds },
+            end: { $gt: boundedPlanningInstant(earliest - scheduleWindowMilliseconds) }, start: { $lt: boundedPlanningInstant(latest + scheduleWindowMilliseconds) },
+        }).toArray();
+        if (replacement) {
+            const index = schedules.findIndex((shift) => shift._id.equals(replacement._id));
+            if (index >= 0)
+                schedules[index] = replacement;
+            else
+                schedules.push(replacement);
+        }
+        const participantIds = documents.flatMap((shift) => shift.assignments.map((entry) => entry.participant));
+        const planIds = [...new Map([...schedules, ...documents].map((shift) => [shift.plan.toHexString(), shift.plan])).values()]
+            .filter((planId) => !preparation?.plan._id.equals(planId));
+        const [plans, settings, absences, people] = await Promise.all([
+            planIds.length ? ShiftPlansService.plansForCompany(planIds, options) : [],
+            preparation ? preparation.settings : SettingsService.singleSettings(options),
+            AbsencesService.absencesForPlanning(customerIds, boundedPlanningInstant(earliest), boundedPlanningInstant(latest), options),
+            ParticipantsService.planningParticipantContext(participantIds, customerIds, options.company, preparation),
+        ]);
+        return { schedules, plans: preparation ? [preparation.plan, ...plans] : plans, settings: settings?.settings, absences, ...people };
+    }
+    async reports(documents, options, replacement, evidence, plan) {
+        if (!documents.length)
+            return [];
+        const context = await this.reportContext(documents, options, { replacement, plan });
+        return documents.map((shift) => reportShift(shift, context, evidence === undefined, evidence));
+    }
+    scheduleNeighbors(candidate, options, previous) {
+        const customers = [...new Map([...candidate.assignments, ...(previous?.assignments ?? [])].map((entry) => [entry.customer.toHexString(), entry.customer])).values()];
+        // Both intervals matter when moving a shift, since its old and new positions can affect different neighbors.
+        const earliest = Math.min(Date.parse(candidate.start), previous ? Date.parse(previous.start) : Infinity);
+        const latest = Math.max(Date.parse(candidate.end), previous ? Date.parse(previous.end) : -Infinity);
+        // Future shifts in other plans may impose stricter incoming-rest rules than the proposed shift's own plan.
+        return this.model.db.find({ company: options.company, 'assignments.customer': { $in: customers },
+            end: { $gte: new Date(earliest).toISOString() }, start: { $lte: boundedPlanningInstant(latest + scheduleWindowMilliseconds) },
+        }).toArray();
+    }
+    async validateSchedule(candidate, options, previous) {
+        if (!candidate.assignments.length && !previous?.assignments.length)
+            return;
+        const neighbors = await this.scheduleNeighbors(candidate, options, previous);
+        // Capture persisted evidence before evaluating the in-memory replacement, just as autofill does for its trials.
+        const baseline = new Map();
+        await this.reports(neighbors, options, undefined, baseline);
+        const updatedEvidence = new Map();
+        const updated = await this.reports([...neighbors.filter((shift) => !shift._id.equals(candidate._id)), candidate], options, candidate, updatedEvidence);
+        const violations = newScheduleViolations(candidate, previous, updated, baseline, updatedEvidence);
+        if (violations.some((violation) => violation.rule === 'settingsMissing' && violation.shift === candidate._id.toHexString())) {
+            throw new ImmutableError('SHIFT_PLANNING_SETTINGS_NOT_CONFIGURED');
+        }
+        if (violations.length) {
+            throw new ImmutableError('SHIFT_PLANNING_RULE_VIOLATION', [{
+                    instancePath: '/assignments', schemaPath: '#/shiftPlanning', keyword: 'shiftPlanning', params: { violations },
+                    message: 'assignments violate the effective working-time policy',
+                }]);
+        }
+    }
+}
+export default new ShiftsService();
+//# sourceMappingURL=shifts.service.js.map