@lilaquadrat/studio 12.1.0 → 12.3.0

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

@@ -2,7 +2,10 @@ import { ObjectId } from 'mongodb';
 import Immutable from '../Immutable.class.js';
 import ListParticipantsModel from '../models/listsParticipants.model.js';
 import ListsModel from '../models/lists.model.js';
-import { EditorService, HistoryService, ListsService, SpamAnalasysService } from '../../services.js';
+import AreaModel from '../models/workAreas.model.js';
+import ShiftModel from '../models/shift.model.js';
+import ShiftPlanModel from '../models/shiftPlan.model.js';
+import { EditorService, HistoryService, HistorySeenService, ListsService, SpamAnalasysService } from '../../services.js';
 import CustomersService from './customers.service.js';
 import hardCopy from '../helpers/hardCopy.js';
 import AgreementsError from '../classes/errors/Agreements.error.js';
@@ -13,9 +16,372 @@ import cleanObject from '../helpers/cleanObject.js';
 import StructureService from './structures.service.js';
 import CustomersModel from '../models/customers.model.js';
 import ImmutableError from '../classes/errors/Immutable.error.js';
-import { projectStructuresAggregation } from '../aggegations/structures.aggregation.js';
+import { companyStructuresAggregation, projectStructuresAggregation } from '../aggegations/structures.aggregation.js';
+import { structureScore } from '../helpers/structureMatch.js';
+import { effectivePolicy } from '../helpers/shiftPlanningTime.js';
+import { boundedPlanningInstant, unavailableParticipantStates } from '../helpers/shiftPlanningReports.js';
+import { allocateShiftCoverage } from '../helpers/shiftPlanCoverage.js';
+import AbsencesService from './employeeAbsences.service.js';
+import SettingsService from './shiftPlanningSettings.service.js';
 import jetstreamService from './jetstream.service.js';
+/** Structure answers live on the owning document under `s-` prefixed keys. */
+function structureAnswers(document) {
+    return Object.fromEntries(Object.entries(document).filter(([key]) => key.startsWith('s-')));
+}
+/** Definitions the document actually answered. */
+function resolvedStructures(answers, structures) {
+    const answered = new Set(Object.keys(answers));
+    return structures.filter((structure) => answered.has(structure.id));
+}
+/** Keeps the first occurrence of every id, so batched reads receive each document once. */
+function uniqueObjectIds(ids) {
+    return [...new Map(ids.map((id) => [id.toHexString(), id])).values()];
+}
+function normalizePlanningScore(score, minimumScore, maximumScore) {
+    if (minimumScore === maximumScore)
+        return 4;
+    const position = (score - minimumScore) / (maximumScore - minimumScore);
+    if (position < 0.25)
+        return 1;
+    if (position < 0.5)
+        return 2;
+    if (position < 0.75)
+        return 3;
+    return 4;
+}
 export class ListParticipantsService extends Immutable {
+    singleForPlanning(list, participant, options) {
+        return this.model.db.findOne({ _id: participant, list, company: options.company, project: options.project });
+    }
+    /** Reports retain unavailable entries; the scheduling layer applies eligibility only to new assignments. */
+    participantsForPlanning(participants, company) {
+        return this.model.db.find({ _id: { $in: participants }, company }).toArray();
+    }
+    /** Attaches each participant's answers, their list definitions and the customer's to the entry. */
+    resolveParticipantDetails(entries, customers, listStructures, customerStructures) {
+        const listStructuresByProject = new Map();
+        for (const structure of listStructures) {
+            const projectStructures = listStructuresByProject.get(structure.project);
+            if (projectStructures)
+                projectStructures.push(structure);
+            else
+                listStructuresByProject.set(structure.project, [structure]);
+        }
+        const companyCustomerStructures = customerStructures.filter((structure) => structure.project === undefined);
+        const customersById = new Map(customers.map((customer) => {
+            const answers = structureAnswers(customer);
+            return [customer._id.toHexString(), {
+                    ...answers,
+                    name: [customer.name, customer.prename].filter(Boolean).join(', '),
+                    email: customer.email,
+                    id: customer.id,
+                    _id: customer._id,
+                    structures: resolvedStructures(answers, companyCustomerStructures),
+                }];
+        }));
+        return entries.map((entry) => {
+            const customer = customersById.get(entry.user.toHexString());
+            const answers = structureAnswers(entry);
+            return {
+                ...answers,
+                ...entry,
+                structures: resolvedStructures(answers, listStructuresByProject.get(entry.project) ?? []),
+                user: customer ? {
+                    ...customer,
+                    structures: [...customer.structures],
+                } : undefined,
+            };
+        });
+    }
+    /** Same entries as participantsForPlanning, resolved with their structure answers and definitions for reporting. */
+    async participantsForPlanningWithDetails(participants, company) {
+        if (!participants.length)
+            return [];
+        return (await this.planningParticipantContext(participants, [], company)).participantDetails;
+    }
+    /** Raw availability and resolved answers share the same reads within one scheduling request. */
+    async planningParticipantContext(participantIds, customerIds, company, preparation) {
+        const participants = participantIds.length ? await this.participantsForPlanning(uniqueObjectIds(participantIds), company) : [];
+        const canReuseListStructures = preparation && participants.every((participant) => participant.project === preparation.plan.project);
+        const [customers, listStructures, customerStructures] = await Promise.all([
+            CustomersService.peopleForPlanning(uniqueObjectIds([...customerIds, ...participants.map((participant) => participant.user)]), company),
+            canReuseListStructures ? preparation.listStructures : StructureService.byModelAndCompany('listsParticipants', company),
+            preparation ? preparation.customerStructures : StructureService.byModelAndCompany('customers', company),
+        ]);
+        return { participants, customers, participantDetails: this.resolveParticipantDetails(participants, customers, listStructures, customerStructures) };
+    }
+    /**
+     * Candidates for a list scored against a planning scope, ordered best-first so pagination ranks
+     * the whole candidate set. `shift` and `workArea` resolve one condition set and return the pool;
+     * `day` and `plan` cover every shift in that scope and return its coverage, unless a membership
+     * mode is given, in which case they return the membership-filtered pool.
+     */
+    async planningParticipants(list, scope, state, categories, search, options, 
+    /** Optional membership mode; absent makes a day/plan scope return coverage instead of the pool. */
+    membership, coverageMode = 'matching') {
+        // A membership mode asks for a candidate pool, so only an unfiltered day/plan scope returns coverage.
+        if ((scope.level === 'day' || scope.level === 'plan') && !membership) {
+            const coverage = await this.planCoverage(list, scope, options, coverageMode);
+            return coverage ? { all: 0, data: [], count: 0, coverage } : { all: 0, data: [], count: 0 };
+        }
+        const scored = await this.scoringCandidates(list, scope, state, categories, search, options);
+        if (!scored.length)
+            return { all: 0, data: [], count: 0 };
+        // Membership is a plan-level property applied to the ranked pool; `all` keeps everyone.
+        let candidates = scored;
+        if (membership && membership !== 'all') {
+            const members = await this.planMembership(scope, list, options);
+            candidates = scored.filter((candidate) => members.has(candidate._id.toHexString()) === (membership === 'assigned'));
+        }
+        if (!candidates.length)
+            return { all: 0, data: [], count: 0 };
+        let minimumScore = Infinity;
+        let maximumScore = -Infinity;
+        for (const candidate of candidates) {
+            minimumScore = Math.min(minimumScore, candidate.match.score);
+            maximumScore = Math.max(maximumScore, candidate.match.score);
+        }
+        const data = candidates.slice(options.skip, options.skip + options.limit).map((participant) => ({
+            _id: participant._id,
+            category: participant.category,
+            state: participant.state,
+            match: { ...participant.match, normalizedScore: normalizePlanningScore(participant.match.score, minimumScore, maximumScore) },
+            user: participant.user ? {
+                _id: participant.user._id,
+                id: participant.user.id,
+                name: participant.user.name,
+                email: participant.user.email,
+            } : undefined,
+        }));
+        return { all: candidates.length, data, count: data.length };
+    }
+    /** Conditions a scope is scored against; the work area's are used when a shift has none of its own. */
+    async scopeConditions(scope, options) {
+        const company = options.company;
+        const project = options.project;
+        const shift = scope.shift
+            ? await ShiftModel.db.findOne({ _id: scope.shift, company, project }, { projection: { structures: 1 } })
+            : undefined;
+        if (shift?.structures?.length)
+            return shift.structures;
+        if (!scope.workArea)
+            return [];
+        const area = await AreaModel.db.findOne({ _id: scope.workArea, company, project }, { projection: { structures: 1 } });
+        return area?.structures ?? [];
+    }
+    /** Participants holding at least one assignment anywhere in the scope's plan; empty when no plan exists. */
+    async planMembership(scope, list, options) {
+        const company = options.company;
+        const project = options.project;
+        // A shift knows its plan directly; other scopes fall back to the list's linked plan.
+        const plan = scope.plan ?? (scope.shift
+            ? (await ShiftModel.db.findOne({ _id: scope.shift, company, project }, { projection: { plan: 1 } }))?.plan
+            : (await ListsService.singleForPlanning(list, options))?.shiftPlan);
+        if (!plan)
+            return new Set();
+        const shifts = await ShiftModel.db
+            .find({ company, project, plan }, { projection: { assignments: 1 } })
+            .toArray();
+        return new Set(shifts.flatMap((shift) => shift.assignments.map((assignment) => assignment.participant.toHexString())));
+    }
+    async scoringCandidates(list, scope, state, categories, search, options) {
+        let categoryFilter;
+        if (categories?.length) {
+            // Participants store the list category's `id`; the plan binds its `_id`, so resolve here.
+            const listDocument = await ListsService.singleForPlanning(list, options);
+            const requested = new Set(categories.map((category) => category.toHexString()));
+            const ids = (listDocument?.categories ?? []).filter((category) => requested.has(category._id.toHexString())).map((category) => category.id);
+            if (!ids.length)
+                return [];
+            categoryFilter = { $in: ids };
+        }
+        // Conditions are only resolved once a requested category exists, so no-op filters skip the queries.
+        const conditions = await this.scopeConditions(scope, options);
+        return this.scoredEntries(list, conditions, state, categoryFilter, search, options);
+    }
+    /** Definitions that matter to one condition set, split by the model they belong to. */
+    scoringStructures(conditions, listStructures, customerStructures) {
+        const ids = new Set(conditions.map((condition) => condition.structure));
+        return {
+            list: listStructures.filter((structure) => ids.has(structure._id.toHexString())),
+            customer: customerStructures.filter((structure) => structure.project === undefined && ids.has(structure._id.toHexString())),
+        };
+    }
+    /**
+     * Scores resolved entries against one condition set and orders the feasible ones first. Unfit
+     * candidates fail a required/forbidden constraint, so they rank after every feasible one.
+     */
+    scoreEntries(entries, customers, conditions, listStructures, customerStructures) {
+        return this.resolveParticipantDetails(entries, customers, listStructures, customerStructures)
+            .map((participant) => ({ ...participant, match: structureScore(conditions, participant) }))
+            // Stable descending sort keeps the `_id` order from the query for equal scores.
+            .sort((left, right) => (left.match.state === 'unfit' ? 1 : 0) - (right.match.state === 'unfit' ? 1 : 0) || right.match.score - left.match.score);
+    }
+    /** Resolves the list's entries against one condition set and orders them best-first. */
+    async scoredEntries(list, conditions, state, categoryFilter, search, options) {
+        const company = options.company;
+        const project = options.project;
+        const stateFilter = state?.length
+            ? { $in: state }
+            : { $nin: ['blocked', 'unchecked', 'notuseful'] };
+        const [listStructures, customerStructures] = await Promise.all([
+            StructureService.getByModel('listsParticipants', { company, project }),
+            StructureService.byModelAndCompany('customers', company),
+        ]);
+        const scoring = this.scoringStructures(conditions, listStructures, customerStructures);
+        const answerProjection = Object.fromEntries([...scoring.list, ...scoring.customer].map((structure) => [structure.id, 1]));
+        const entries = await this.model.db
+            .find({ list, company, project, state: stateFilter, ...(categoryFilter ? { category: categoryFilter } : {}) }, {
+            projection: { _id: 1, user: 1, project: 1, category: 1, state: 1, ...answerProjection },
+        })
+            .sort({ _id: 1 })
+            .toArray();
+        if (!entries.length)
+            return [];
+        const customerIds = [...new Map(entries.map((entry) => [entry.user.toHexString(), entry.user])).values()];
+        const customers = await CustomersService.peopleForPlanning(customerIds, company, {
+            _id: 1, id: 1, name: 1, prename: 1, email: 1, ...answerProjection,
+        });
+        const term = search?.trim().toLowerCase();
+        const matchingCustomers = term
+            ? customers.filter((customer) => [customer.name, customer.prename].filter(Boolean).join(', ').toLowerCase().includes(term))
+            : customers;
+        const matchingCustomerIds = term ? new Set(matchingCustomers.map((customer) => customer._id.toHexString())) : undefined;
+        const matchingEntries = matchingCustomerIds ? entries.filter((entry) => matchingCustomerIds.has(entry.user.toHexString())) : entries;
+        if (!matchingEntries.length)
+            return [];
+        return this.scoreEntries(matchingEntries, matchingCustomers, conditions, scoring.list, scoring.customer);
+    }
+    /**
+     * Shared reads and ranked candidate pools for a planning scope. The list, its structures, the
+     * customer structures and every used work area are read once, and all condition answers and
+     * categories are fetched in a single entries query; ranking then happens in memory per shift.
+     * Coverage and autofill both build on this, so a scope resolves to the same targets either way.
+     */
+    async prepareShiftPlanning(list, scope, options) {
+        const company = options.company;
+        const project = options.project;
+        const planId = scope.plan ?? (await ListsService.singleForPlanning(list, options))?.shiftPlan;
+        if (!planId)
+            return undefined;
+        const plan = await ShiftPlanModel.db.findOne({ _id: planId, company, project });
+        if (!plan)
+            return undefined;
+        const shifts = await ShiftModel.db.find({ company, project, plan: plan._id }).sort({ start: 1, _id: 1 }).toArray();
+        // A work area or a single shift narrows the targets; the plan's full shifts stay the conflict scope.
+        const reportShifts = scope.shift ? shifts.filter((shift) => shift._id.equals(scope.shift))
+            : scope.workArea ? shifts.filter((shift) => shift.area.equals(scope.workArea))
+                : scope.day ? shifts.filter((shift) => shift.day.equals(scope.day))
+                    : shifts;
+        const participantIds = shifts.flatMap((shift) => shift.assignments.map((assignment) => assignment.participant));
+        const customerIds = shifts.flatMap((shift) => shift.assignments.map((assignment) => assignment.customer));
+        if (!reportShifts.length)
+            return { plan, shifts, targets: [], participantIds, customerIds, settings: null, listStructures: [], customerStructures: [] };
+        const settings = await SettingsService.singleSettings(options);
+        if (!effectivePolicy(settings?.settings, plan.settingsOverrides))
+            throw new ImmutableError('SHIFT_PLANNING_SETTINGS_NOT_CONFIGURED');
+        const [listDocument, listStructures, customerStructures, areas] = await Promise.all([
+            ListsService.singleForPlanning(list, options),
+            StructureService.getByModel('listsParticipants', { company, project }),
+            StructureService.byModelAndCompany('customers', company),
+            AreaModel.db.find({ _id: { $in: uniqueObjectIds(reportShifts.map((shift) => shift.area)) }, company, project }).toArray(),
+        ]);
+        const areaStructuresById = new Map(areas.map((area) => [area._id.toHexString(), area.structures ?? []]));
+        const categoryStringById = new Map((listDocument?.categories ?? []).map((category) => [category._id.toHexString(), category.id]));
+        const bindings = plan.workAreaCategories ?? [];
+        const prepared = reportShifts.map((shift) => {
+            const conditions = shift.structures?.length ? shift.structures : (areaStructuresById.get(shift.area.toHexString()) ?? []);
+            // A binding carries list category `_id`s; participants store the categories' `id`.
+            const binding = bindings.find((entry) => entry.area.equals(shift.area))?.categoryIds;
+            const categoryStrings = binding?.length
+                ? new Set(binding.map((id) => categoryStringById.get(id.toHexString())).filter((id) => id !== undefined))
+                : null;
+            return { shift, conditions, categoryStrings };
+        });
+        const usedStructures = this.scoringStructures(prepared.flatMap((entry) => entry.conditions), listStructures, customerStructures);
+        const answerProjection = Object.fromEntries([...usedStructures.list, ...usedStructures.customer].map((structure) => [structure.id, 1]));
+        const anyUnbound = prepared.some((entry) => entry.categoryStrings === null);
+        const boundCategories = new Set();
+        for (const entry of prepared)
+            if (entry.categoryStrings)
+                for (const id of entry.categoryStrings)
+                    boundCategories.add(id);
+        const state = plan.defaultParticipantState ? [plan.defaultParticipantState] : undefined;
+        const stateFilter = state?.length
+            ? { $in: state }
+            : { $nin: ['blocked', 'unchecked', 'notuseful'] };
+        const entries = await this.model.db
+            .find({ list, company, project, state: stateFilter, ...(anyUnbound ? {} : { category: { $in: [...boundCategories] } }) }, {
+            projection: { _id: 1, user: 1, project: 1, category: 1, state: 1, ...answerProjection },
+        })
+            .sort({ _id: 1 })
+            .toArray();
+        const resolvedCustomers = entries.length
+            ? await CustomersService.peopleForPlanning(uniqueObjectIds(entries.map((entry) => entry.user)), company, {
+                _id: 1, id: 1, name: 1, prename: 1, email: 1, ...answerProjection,
+            })
+            : [];
+        const targets = prepared.map((entry) => {
+            const matching = entry.categoryStrings
+                ? entries.filter((candidate) => candidate.category !== undefined && entry.categoryStrings.has(candidate.category))
+                : entries;
+            const scoring = this.scoringStructures(entry.conditions, listStructures, customerStructures);
+            // Cancelled entries are still returned for the shift editor; coverage only counts usable people.
+            const ranked = this.scoreEntries(matching, resolvedCustomers, entry.conditions, scoring.list, scoring.customer)
+                .filter((candidate) => !unavailableParticipantStates.has(candidate.state));
+            participantIds.push(...ranked.map((candidate) => candidate._id));
+            customerIds.push(...ranked.flatMap((candidate) => candidate.user?._id ? [candidate.user._id] : []));
+            return {
+                shift: entry.shift,
+                conditions: entry.conditions,
+                candidates: ranked.flatMap((candidate) => candidate.user?._id
+                    ? [{ participant: candidate._id, customer: candidate.user._id, matching: candidate.match.state === 'fulfilled' }]
+                    : []),
+            };
+        });
+        return { plan, shifts, targets, participantIds, customerIds, settings, listStructures, customerStructures };
+    }
+    /** Diagnostic data shared by a coverage run; the schedule is supplied per allocation step. */
+    async coverageReportContext(preparation, options) {
+        const participantIds = uniqueObjectIds(preparation.participantIds);
+        const customerIds = uniqueObjectIds(preparation.customerIds);
+        const starts = preparation.shifts.map((shift) => Date.parse(shift.start));
+        const ends = preparation.shifts.map((shift) => Date.parse(shift.end));
+        const [people, absences] = await Promise.all([
+            this.planningParticipantContext(participantIds, customerIds, options.company, preparation),
+            AbsencesService.absencesForPlanning(customerIds, boundedPlanningInstant(Math.min(...starts)), boundedPlanningInstant(Math.max(...ends)), options),
+        ]);
+        return { plans: [preparation.plan], settings: preparation.settings?.settings, absences, ...people };
+    }
+    /**
+     * Coverage of every shift in the linked (or given) plan or day. Only the plan's own shifts are
+     * compared, so collisions with other plans are out of scope.
+     */
+    async planCoverage(list, scope, options, coverageMode) {
+        const preparation = await this.prepareShiftPlanning(list, scope, options);
+        if (!preparation)
+            return undefined;
+        const level = scope.day ? 'day' : 'plan';
+        if (!preparation.targets.length)
+            return { level, plan: preparation.plan._id, shifts: [], totalShifts: 0, fillableShifts: 0, fillable: true };
+        const context = await this.coverageReportContext(preparation, options);
+        const allocation = allocateShiftCoverage(preparation.shifts, preparation.targets, context, false, coverageMode);
+        const fillableShifts = allocation.coverage.filter((entry) => entry.fillable).length;
+        return { level, plan: preparation.plan._id, shifts: allocation.coverage, totalShifts: allocation.coverage.length, fillableShifts, fillable: allocation.fillable };
+    }
+    /**
+     * Cheap answer for the same coverage: whether every shift in the plan can be staffed. Allocation
+     * stops at the first shift that cannot be filled, so no per-shift detail is produced.
+     */
+    async planCoverageSummary(list, scope, options, coverageMode = 'matching') {
+        const preparation = await this.prepareShiftPlanning(list, scope, options);
+        if (!preparation)
+            return { fillable: false };
+        if (!preparation.targets.length)
+            return { fillable: true };
+        const context = await this.coverageReportContext(preparation, options);
+        return { fillable: allocateShiftCoverage(preparation.shifts, preparation.targets, context, true, coverageMode).fillable };
+    }
     constructor(connectionString, accountName, queue) {
         super();
         this.model = ListParticipantsModel;
@@ -33,6 +399,8 @@ export class ListParticipantsService extends Immutable {
                                 ],
                             },
                         },
+                        // The customer's own structure answers and their definitions travel with the participant.
+                        ...companyStructuresAggregation,
                     ],
                 },
             },
@@ -45,10 +413,25 @@ export class ListParticipantsService extends Immutable {
             {
                 $addFields: {
                     'user': {
-                        name: { $concat: ['$userData.name', ', ', '$userData.prename'] },
-                        email: '$userData.email',
-                        id: '$userData.id',
-                        _id: '$userData._id',
+                        $mergeObjects: [
+                            {
+                                name: { $concat: ['$userData.name', ', ', '$userData.prename'] },
+                                email: '$userData.email',
+                                id: '$userData.id',
+                                _id: '$userData._id',
+                            },
+                            // Carry the customer's raw s- answers so shift conditions can be evaluated against them.
+                            {
+                                $arrayToObject: {
+                                    $filter: {
+                                        input: { $objectToArray: { $ifNull: ['$userData', {}] } },
+                                        as: 'entry',
+                                        cond: { $eq: [{ $substrCP: ['$$entry.k', 0, 2] }, 's-'] },
+                                    },
+                                },
+                            },
+                            { structures: { $ifNull: ['$userData.structures', []] } },
+                        ],
                     },
                 },
             },
@@ -693,6 +1076,20 @@ export class ListParticipantsService extends Immutable {
         await this.immutable({ _id: participant._id, list, company: options.company, project: options.project }, structureInput, options.user, 'change', options.app, undefined, undefined, 'changeMemberEntry', { origin: 'member', validator, unset });
         return this.singleWithoutLookup(list, participant.user, options);
     }
+    async updateStructures(list, participationId, structures, options) {
+        const baseSchema = ListParticipantsModel.getSchema('changeStructures');
+        if (!baseSchema)
+            throw new ImmutableError('VALIDATION_FAILED');
+        const structureDefinitions = await StructureService.getByModel('listsParticipants', options);
+        const validator = StructureService.createValidator([], [], structureDefinitions, hardCopy(baseSchema.schema));
+        if (!validator(structures))
+            throw new ImmutableError('VALIDATION_FAILED', validator.errors);
+        const payload = (structures ?? {});
+        const structureIds = structureDefinitions.map((structure) => structure.id).filter((id) => Boolean(id));
+        // a structure is only kept when the payload carries a key for it, so explicit false/0 answers survive
+        const unset = structureIds.filter((key) => !(key in payload));
+        return this.immutable({ _id: participationId, list, company: options.company, project: options.project }, structures, options.user, 'change', options.app, undefined, undefined, 'changeStructures', { validator, unset });
+    }
     async note(list, participationId, note, options) {
         return this.immutable({ _id: participationId, list, company: options.company, project: options.project }, note ? { note } : {}, options.user, 'change', options.app, undefined, undefined, 'updateNote');
     }
@@ -801,6 +1198,28 @@ export class ListParticipantsService extends Immutable {
         query.aggregation.push(...this.customerLookup);
         return HistoryService.listCustomQuery(query);
     }
+    /** a history entry of this list and the version before it, with the structures that name the custom fields */
+    async historyEntry(list, historyId, options) {
+        const entry = await HistoryService.entryWithPrevious(options.company, options.project, historyId, { list, 'history.model': 'listParticipants' });
+        if (!entry)
+            return null;
+        return { ...entry, structures: await StructureService.getByModel('listsParticipants', options) };
+    }
+    historySeenKey(list, options) {
+        return {
+            user: options.user,
+            company: options.company,
+            project: options.project,
+            model: 'listParticipants',
+            scope: list.toString(),
+        };
+    }
+    historyUnreadCount(list, options) {
+        return HistorySeenService.unreadCount(this.historySeenKey(list, options), { list });
+    }
+    markHistorySeen(list, options) {
+        return HistorySeenService.markSeen(this.historySeenKey(list, options), { list });
+    }
     agreementsMissing(listAgreements, providedAgreements) {
         const missing = [];
         const required = listAgreements?.filter((single) => single.required);
@@ -842,6 +1261,7 @@ export class ListParticipantsService extends Immutable {
             ...aggregation,
             ...this.getCustomerLookup(lastname),
             ...this.paymentLookupList,
+            ...projectStructuresAggregation,
         ];
         aggregation.push({
             $addFields: {