@lilaquadrat/studio 9.15.2 → 9.15.3

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

@@ -0,0 +1,905 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListParticipantsService = void 0;
+const mongodb_1 = require("mongodb");
+const Immutable_class_1 = __importDefault(require("../Immutable.class"));
+const listsParticipants_model_1 = __importDefault(require("../models/listsParticipants.model"));
+const services_1 = require("../../services");
+const customers_service_1 = __importDefault(require("./customers.service"));
+const hardCopy_1 = __importDefault(require("../helpers/hardCopy"));
+const Agreements_error_1 = __importDefault(require("../classes/errors/Agreements.error"));
+const storage_queue_1 = require("@azure/storage-queue");
+const publish_service_1 = __importDefault(require("./publish.service"));
+const safeObjectId_1 = __importDefault(require("../helpers/safeObjectId"));
+const cleanObject_1 = __importDefault(require("../helpers/cleanObject"));
+const identity_1 = require("@azure/identity");
+const structures_service_1 = __importDefault(require("./structures.service"));
+const customers_model_1 = __importDefault(require("../models/customers.model"));
+const Immutable_error_1 = __importDefault(require("../classes/errors/Immutable.error"));
+const structures_aggregation_1 = require("../aggegations/structures.aggregation");
+class ListParticipantsService extends Immutable_class_1.default {
+    constructor(connectionString, accountName, queue) {
+        super();
+        this.model = listsParticipants_model_1.default;
+        this.customerLookup = [
+            {
+                $lookup: {
+                    from: 'customers',
+                    as: 'userData',
+                    let: { userid: '$user' },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    { $expr: { $eq: ['$_id', '$$userid'] } },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$userData',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $addFields: {
+                    'user': {
+                        name: { $concat: ['$userData.name', ', ', '$userData.prename'] },
+                        email: '$userData.email',
+                        id: '$userData.id',
+                        _id: '$userData._id',
+                    },
+                },
+            },
+            {
+                $project: {
+                    'userData': 0,
+                },
+            },
+        ];
+        this.paymentLookup = [
+            {
+                $lookup: {
+                    from: 'payments',
+                    as: 'paymentData',
+                    let: { paymentid: '$payment' },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    { $expr: { $eq: ['$_id', '$$paymentid'] } },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$paymentData',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $addFields: {
+                    'payment': {
+                        _id: '$paymentData._id',
+                        amount: '$paymentData.amount',
+                        currency: '$paymentData.currency',
+                        provider: '$paymentData.provider',
+                        items: '$paymentData.items',
+                        state: '$paymentData.state',
+                    },
+                },
+            },
+            {
+                $project: {
+                    'paymentData': 0,
+                },
+            },
+        ];
+        this.paymentLookupList = [
+            {
+                $lookup: {
+                    from: 'payments',
+                    as: 'paymentData',
+                    let: { paymentid: '$payment' },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    { $expr: { $eq: ['$_id', '$$paymentid'] } },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$paymentData',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $addFields: {
+                    'payment': {
+                        amount: '$paymentData.amount',
+                    },
+                },
+            },
+            {
+                $project: {
+                    'paymentData': 0,
+                },
+            },
+        ];
+        if (accountName) {
+            this.service = new storage_queue_1.QueueServiceClient(`https://${accountName}.queue.core.windows.net`, new identity_1.DefaultAzureCredential());
+        }
+        else if (connectionString && queue) {
+            this.service = storage_queue_1.QueueServiceClient.fromConnectionString(connectionString);
+            this.queue = queue;
+        }
+        if (this.service) {
+            this.client = this.service.getQueueClient(queue);
+        }
+    }
+    getCustomerLookup(search) {
+        const lookup = (0, hardCopy_1.default)(this.customerLookup);
+        if (search) {
+            lookup[0].$lookup?.pipeline[0].$match.$and.push({
+                $expr: {
+                    $regexMatch: {
+                        input: '$name',
+                        regex: search,
+                        options: 'i',
+                    },
+                },
+            });
+            lookup[1].$unwind.preserveNullAndEmptyArrays = false;
+        }
+        return lookup;
+    }
+    single(list, internalId, options) {
+        let aggregation = [
+            {
+                $match: {
+                    $and: [
+                        { $expr: { $eq: ['$company', options.company] } },
+                        { $expr: { $eq: ['$project', options.project] } },
+                        { $expr: { $eq: ['$list', list] } },
+                        { $expr: { $eq: ['$_id', internalId] } },
+                    ],
+                },
+            },
+            ...this.customerLookup,
+            ...this.paymentLookup,
+            ...structures_aggregation_1.projectStructuresAggregation,
+        ];
+        return this.model.db.aggregate(aggregation).toArray()
+            .then((data) => data[0] || undefined);
+    }
+    /**
+     * get state of the provided account for this list
+     */
+    async stateForAccount(list, account, options) {
+        const customer = await customers_service_1.default.getCustomerByAccount(account, options.app);
+        if (!customer)
+            throw new Error('CUSTOMER_NOT_FOUND');
+        let aggregation = [
+            {
+                $match: {
+                    $and: [
+                        { $expr: { $eq: ['$company', options.company] } },
+                        { $expr: { $eq: ['$project', options.project] } },
+                        { $expr: { $eq: ['$list', list] } },
+                        { $expr: { $eq: ['$user', customer._id] } },
+                    ],
+                },
+            },
+        ];
+        return this.model.db.aggregate(aggregation).toArray()
+            .then((data) => data[0] || undefined);
+    }
+    async updateAfterCheck(useful, explanation, partiticpantInternalId, listInternalId, options) {
+        const list = await services_1.ListsService.single(listInternalId, undefined, options);
+        if (!list)
+            throw new Error('LIST_NOT_FOUND');
+        let entryState = 'notuseful';
+        if (useful) {
+            if (list.mode === 'contact')
+                entryState = 'enlisted';
+            if (list.mode === 'content')
+                entryState = 'enlisted';
+            if (list.mode === 'reservation')
+                entryState = 'reserved';
+        }
+        return this.immutable({ _id: partiticpantInternalId }, { state: entryState, explanation }, options.user, 'change', options.app, undefined, undefined, 'updateAfterCheck');
+    }
+    getValidatorForStructures(contactCategories, structures, model, schemaHint) {
+        const required = [];
+        const compatibleModels = {
+            listsParticipants: listsParticipants_model_1.default,
+            customers: customers_model_1.default,
+        };
+        contactCategories.forEach((single) => {
+            single.required?.forEach((singleRequired) => {
+                const singleStructure = structures.find((structure) => structure._id?.toString() === singleRequired);
+                if (singleStructure)
+                    required.push(singleStructure.id);
+            });
+        });
+        const useModel = compatibleModels[model];
+        if (!useModel)
+            throw new Error('MODEL_FOR_VALIDATOR_NOT_FOUND');
+        /**
+         * get the base schema and create a validator
+         */
+        const baseSchema = useModel.getSchema(schemaHint);
+        if (!baseSchema)
+            throw new Error('SCHEMA_NOT_FOUND');
+        return structures_service_1.default.createValidator([], required, structures, (0, hardCopy_1.default)(baseSchema.schema));
+    }
+    createParticipantsObject(list, mode, user, state, message, category, payment, structureInput, agreements, options) {
+        let participant = {
+            list,
+            user,
+            message,
+            category,
+            agreements,
+            state,
+            payment,
+            company: options.company,
+            project: options.project,
+        };
+        if (structureInput) {
+            participant = { ...participant, ...structureInput };
+        }
+        (0, cleanObject_1.default)(participant);
+        return participant;
+    }
+    /**
+     * join a list from customer perspective
+     */
+    async join(listInternalId, person, message, category, agreements, structureInput, options) {
+        let customerModelAction = 'createPersonExternal';
+        const list = await services_1.ListsService.single(listInternalId, undefined, options);
+        const modelHints = { listsParticipants: '', customers: 'createPersonExternal' };
+        const optionsWithValidatorCustomers = { ...options };
+        const optionsWithValidatorListsParticipants = { ...options };
+        /**
+         * Separate structures by type for easier access
+         */
+        let structuresByModel = {};
+        let structuresInputByModel = {};
+        const validatorByModel = {};
+        if (!list)
+            throw new Error('LIST_NOT_FOUND');
+        if (!list.participants?.available)
+            throw new Error('LIST_NO_SPOT_AVAILABLE');
+        if (!person?.email)
+            throw new Error('EMAIL_INVALID');
+        const checkEmail = await services_1.SpamAnalasysService.checkEmailDns(person.email);
+        if (!checkEmail)
+            throw new Error('EMAIL_INVALID');
+        let entryState = 'unchecked';
+        // if (list.mode === 'contact') entryState = 'enlisted';
+        if (list.mode === 'content')
+            entryState = 'enlisted';
+        if (list.mode === 'reservation')
+            entryState = 'reserved';
+        modelHints.listsParticipants = `${list.mode}-create`;
+        // if the address is required use the matching action in the model for validation
+        if (list.participants?.addressRequired) {
+            customerModelAction = 'createPersonExternalWithAddress';
+        }
+        const agreementsMissing = this.agreementsMissing(list.agreements, agreements);
+        if (agreementsMissing.length) {
+            throw new Agreements_error_1.default('accepted', [
+                {
+                    keyword: 'accepted',
+                    instancePath: 'agreements',
+                    schemaPath: '#/accepted',
+                    params: { missingProperty: 'agreements', missing: agreementsMissing },
+                },
+            ], { required: agreementsMissing });
+        }
+        /**
+         * existing parent id indicates that we need to check if we have a contact module with structures in it
+         */
+        if (options.parentId) {
+            /**
+             * get the editor and find used the contact module
+             */
+            const editor = await services_1.EditorService.getById(options.parentId, options);
+            const contactModule = editor.modules.find((single) => single.uuid === options.uuid && single.type === 'contact-module');
+            if (editor.genericData?.structures && contactModule) {
+                /**
+                 * get all used structures for the contact module
+                 */
+                const structures = await structures_service_1.default.byMultipleInternalIds(editor.genericData?.structures, options);
+                const contactCategories = contactModule.categories;
+                const groupedStructures = structures_service_1.default.groupStructuresByModel(structures, structureInput);
+                structuresByModel = groupedStructures.structuresByModel;
+                structuresInputByModel = groupedStructures.structuresInputByModel;
+                /**
+                 * create a validator each model
+                 */
+                Object.keys(structuresByModel).forEach((model) => {
+                    validatorByModel[model] = this.getValidatorForStructures(contactCategories, structuresByModel[model], model, modelHints[model]);
+                });
+                if (validatorByModel.customers)
+                    optionsWithValidatorCustomers.validator = validatorByModel.customers;
+                if (validatorByModel.listsParticipants)
+                    optionsWithValidatorListsParticipants.validator = validatorByModel.listsParticipants;
+            }
+        }
+        else {
+            throw new Error('PARENT_NOT_FOUND');
+        }
+        /**
+         * user id is only for validation and needs to be replaced with the real customer id
+         */
+        const participantsObject = this.createParticipantsObject(listInternalId, list.mode, new mongodb_1.ObjectId(), entryState, message, category, undefined, structuresInputByModel.listsParticipants, agreements, optionsWithValidatorListsParticipants);
+        /**
+         * TODO: double validation needs to be removed
+         * we currently validate the data two times
+         * with this pre validation of the listsParticipants we dont create a customer if the list validation fails
+         */
+        if (validatorByModel.listsParticipants) {
+            if (!validatorByModel.listsParticipants(participantsObject)) {
+                throw new Immutable_error_1.default('VALIDATION_FAILED', validatorByModel.listsParticipants.errors);
+            }
+        }
+        /**
+         * if the customer exists we don't update the data.
+         * because in general everybody with the knowledge of the email could overwrite the data for the customer
+         * updating the customer data will be only possible via members and from the admins
+         */
+        const customerResponse = await customers_service_1.default.getOrCreateByEmail({ ...person, ...structuresInputByModel.customers }, customerModelAction, optionsWithValidatorCustomers);
+        if (!customerResponse?.customer)
+            throw new Error('CUSTOMER_NOT_FOUND');
+        /**
+         * update the user id with the real customer id
+         */
+        participantsObject.user = customerResponse.customer._id;
+        const participantInList = await this.singleWithoutLookup(listInternalId, customerResponse.customer._id, options);
+        if (list.participants?.unique && participantInList) {
+            throw new Error('LIST_UNIQUE_CUSTOMER_CONFIRMED');
+        }
+        if (participantInList?.state === 'blocked') {
+            throw new Error('LIST_CANNOT_JOIN');
+        }
+        const addResponse = await this.addParticipantViaObject(participantsObject, list.mode, optionsWithValidatorListsParticipants);
+        await this.sendStateAndAudienceAwareEmail(list._id, customerResponse.customer._id, entryState, 'public', { ...options, disableEmailConfirmedCheck: true });
+        /**
+        * only add to the queue and initiate the spam check when the entry state is unchecked
+        */
+        if (entryState === 'unchecked') {
+            await this.client.sendMessage(Buffer.from(JSON.stringify({ _id: addResponse._id, listId: list._id })).toString('base64'));
+        }
+        return customerResponse.customer;
+    }
+    async joinManually(listInternalId, customerId, category, state, note, options) {
+        const list = await services_1.ListsService.single(listInternalId, undefined, options);
+        if (!list)
+            throw new Error('LIST_NOT_FOUND');
+        const customer = await customers_service_1.default.customerExists(customerId);
+        if (!customer)
+            throw new Error('CUSTOMER_NOT_FOUND');
+        const listCategory = list.categories?.find((single) => single.id === category);
+        if (!listCategory)
+            throw new Error('LIST_CATEGORY_NOT_FOUND');
+        let participant = {
+            list: listInternalId,
+            user: customerId,
+            category,
+            note,
+            agreements: [],
+            state,
+            company: options.company,
+            project: options.project,
+        };
+        (0, cleanObject_1.default)(participant);
+        return this.create(participant, options.user, options.app, undefined, undefined, 'create-manually');
+    }
+    /**
+     * join a list through payment
+     */
+    async joinViaPayment(listInternalId, customerId, message, category, payment, agreements, options) {
+        const list = await services_1.ListsService.single(listInternalId, undefined, options);
+        if (!list)
+            throw new Error('LIST_NOT_FOUND');
+        let entryState = 'paid';
+        const participantInList = await this.singleWithoutLookup(listInternalId, customerId, options);
+        if (list.participants?.unique && participantInList) {
+            throw new Error('LIST_UNIQUE_CUSTOMER_CONFIRMED');
+        }
+        if (participantInList?.state === 'blocked') {
+            throw new Error('LIST_CANNOT_JOIN');
+        }
+        await this.addParticipant(listInternalId, list.mode, customerId, entryState, message, category, payment, undefined, agreements, options);
+        await this.sendStateAndAudienceAwareEmail(list._id, customerId, entryState, 'public', { ...options, disableEmailConfirmedCheck: true });
+        return customerId;
+    }
+    /**
+     * join a list from members perspective
+     */
+    async membersJoin(listInternalId, account, message, category, agreements, structureInput, options) {
+        const modelHints = { listsParticipants: '', customers: 'changePersonMinimal' };
+        const optionsWithValidatorCustomers = { ...options };
+        const optionsWithValidatorListsParticipants = { ...options };
+        /**
+         * Separate structures by type for easier access
+         */
+        let structuresByModel = {};
+        let structuresInputByModel = {};
+        const validatorByModel = {};
+        const list = await services_1.ListsService.single(listInternalId, undefined, options);
+        if (!list)
+            throw new Error('LIST_NOT_FOUND');
+        if (!list.participants?.available)
+            throw new Error('LIST_NO_SPOT_AVAILABLE');
+        let entryState = 'unchecked';
+        // if (list.mode === 'contact') entryState = 'enlisted';
+        if (list.mode === 'content')
+            entryState = 'enlisted';
+        if (list.mode === 'reservation')
+            entryState = 'reserved';
+        modelHints.listsParticipants = `${list.mode}-create`;
+        const agreementsMissing = this.agreementsMissing(list.agreements, agreements);
+        if (agreementsMissing.length) {
+            throw new Agreements_error_1.default('accepted', [
+                {
+                    keyword: 'accepted',
+                    instancePath: 'agreements',
+                    schemaPath: '#/accepted',
+                    params: { missingProperty: 'agreements', missing: agreementsMissing },
+                },
+            ], { required: agreementsMissing });
+        }
+        /**
+         * existing parent id indicates that we need to check if we have a contact module with structures in it
+         */
+        if (options.parentId) {
+            /**
+                 * get the editor and find used the contact module
+                 */
+            const editor = await services_1.EditorService.getById(options.parentId, options);
+            const contactModule = editor.modules.find((single) => single.uuid === options.uuid);
+            if (editor.genericData?.structures && contactModule) {
+                /**
+                     * get all used structures for the contact module
+                     */
+                const structures = await structures_service_1.default.byMultipleInternalIds(editor.genericData?.structures, options);
+                const contactCategories = contactModule.categories;
+                const groupedStructures = structures_service_1.default.groupStructuresByModel(structures, structureInput);
+                structuresByModel = groupedStructures.structuresByModel;
+                structuresInputByModel = groupedStructures.structuresInputByModel;
+                /**
+                     * create a validator each model
+                     */
+                Object.keys(structuresByModel).forEach((model) => {
+                    validatorByModel[model] = this.getValidatorForStructures(contactCategories, structuresByModel[model], model, modelHints[model]);
+                });
+                if (validatorByModel.customers)
+                    optionsWithValidatorCustomers.validator = validatorByModel.customers;
+                if (validatorByModel.listsParticipants)
+                    optionsWithValidatorListsParticipants.validator = validatorByModel.listsParticipants;
+            }
+        }
+        else {
+            throw new Error('PARENT_NOT_FOUND');
+        }
+        /**
+         * user id is only for validation and needs to be replaced with the real customer id
+         */
+        const participantsObject = this.createParticipantsObject(listInternalId, list.mode, new mongodb_1.ObjectId(), entryState, message, category, undefined, structuresInputByModel.listsParticipants, agreements, optionsWithValidatorListsParticipants);
+        /**
+             * TODO: double validation needs to be removed
+             * we currently validate the data two times
+             * with this pre validation of the listsParticipants we dont create a customer if the list validation fails
+             */
+        if (validatorByModel.listsParticipants) {
+            if (!validatorByModel.listsParticipants(participantsObject)) {
+                throw new Immutable_error_1.default('VALIDATION_FAILED', validatorByModel.listsParticipants.errors);
+            }
+        }
+        const customer = await customers_service_1.default.getCustomerByAccount(account, options.app, { history: 0, accounts: 0 });
+        if (!customer)
+            throw new Error('CUSTOMER_NOT_FOUND');
+        const customerId = customer._id;
+        participantsObject.user = customerId;
+        delete customer._id;
+        if (structuresInputByModel.customers) {
+            await customers_service_1.default.immutable({ _id: customerId }, { ...customer, ...structuresInputByModel.customers }, options.user, 'change', options.app, undefined, undefined, 'changePersonMinimal', { validator: optionsWithValidatorCustomers.validator });
+        }
+        const participantInList = await this.singleWithoutLookup(listInternalId, customerId, options);
+        if (list.participants?.unique && participantInList) {
+            throw new Error('LIST_UNIQUE_CUSTOMER_CONFIRMED');
+        }
+        if (participantInList?.state === 'blocked') {
+            throw new Error('LIST_CANNOT_JOIN');
+        }
+        const addResponse = await this.addParticipantViaObject(participantsObject, list.mode, optionsWithValidatorListsParticipants);
+        // const addResponse = await this.addParticipant(listInternalId, list.mode, customer._id, entryState, message, category, undefined, undefined, agreements, options);
+        /**
+        * only add to the queue and initiate the spam check when the entrystate is unchecked
+        */
+        if (entryState === 'unchecked') {
+            await this.client.sendMessage(Buffer.from(JSON.stringify({ _id: addResponse._id, listId: list._id })).toString('base64'));
+        }
+        await this.sendStateAndAudienceAwareEmail(list._id, customerId, entryState, 'members', options);
+        return customerId;
+    }
+    /**
+     * Sends an email based on participant state and audience criteria.
+     * if the options for disableEmailConfirmedCheck is set to true, the email will be sent regardless of the email confirmation status.
+     */
+    async sendStateAndAudienceAwareEmail(listId, customerId, state, audience, options) {
+        const list = await services_1.ListsService.single(listId, undefined, options);
+        if (!list)
+            return;
+        const email = list.emails?.find((single) => single.affectedState === state && single.audience === audience);
+        if (!email)
+            return;
+        if (!options.disableEmailConfirmedCheck) {
+            const customer = await customers_service_1.default.single(customerId, options);
+            if (!customer)
+                return;
+            if (!customer.emailConfirmed) {
+                console.debug('EMAIL_NOT_CONFIRMED');
+                return;
+            }
+        }
+        return publish_service_1.default.email((0, safeObjectId_1.default)(email.contentId), customerId, undefined, options);
+    }
+    async remove(list, participationId, options) {
+        return this.delete(participationId, options.user, options.app);
+    }
+    /**
+     * Updates the state of a participant in a list
+     */
+    async state(list, participationId, state, options) {
+        await this.immutable({ _id: participationId, list, company: options.company, project: options.project }, { state }, options.user, 'change', options.app, undefined, undefined, 'updateState');
+        const participant = await this.model.db.findOne({ _id: participationId, company: options.company, project: options.project });
+        if (!participant)
+            return;
+        const customer = await customers_service_1.default.single(participant.user, options);
+        if (customer?.type === 'person') {
+            // Determine the audience type based on whether the customer has accounts
+            // 'members' for customers with accounts, 'public' for those without
+            const audience = customer.accounts && customer.accounts[0] ? 'members' : 'public';
+            // Send an email notification based on the new state and audience type
+            await this.sendStateAndAudienceAwareEmail(list, customer._id, state, audience, options);
+        }
+    }
+    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');
+    }
+    async participantInList(list, user, options) {
+        return await this.model.db.countDocuments({ list, user, company: options.company, project: options.project }) > 0;
+    }
+    singleWithoutLookup(list, user, options) {
+        return this.model.db.findOne({ list, user, company: options.company, project: options.project });
+    }
+    viaPayment(listId, paymentId, options) {
+        let aggregation = [
+            {
+                $match: {
+                    $and: [
+                        { $expr: { $eq: ['$company', options.company] } },
+                        { $expr: { $eq: ['$project', options.project] } },
+                        { $expr: { $eq: ['$list', listId] } },
+                        { $expr: { $eq: ['$payment', paymentId] } },
+                    ],
+                },
+            },
+            ...this.customerLookup,
+            ...this.paymentLookup,
+            ...structures_aggregation_1.projectStructuresAggregation,
+        ];
+        return this.model.db.aggregate(aggregation).toArray()
+            .then((data) => data[0] || undefined);
+    }
+    byInternalId(internalId, customerLookup) {
+        if (!customerLookup) {
+            return this.model.db.findOne({ _id: internalId });
+        }
+        let aggregation = [
+            {
+                $match: {
+                    $and: [
+                        { $expr: { $eq: ['$_id', internalId] } },
+                    ],
+                },
+            },
+            {
+                $lookup: {
+                    from: 'customers',
+                    as: 'userData',
+                    let: { userid: '$user' },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    { $expr: { $eq: ['$_id', '$$userid'] } },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$userData',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $addFields: {
+                    user: '$userData',
+                },
+            },
+            {
+                $project: {
+                    userData: 0,
+                },
+            },
+        ];
+        return this.model.db.aggregate(aggregation).toArray()
+            .then((data) => data[0] || undefined);
+    }
+    addParticipant(list, mode, user, state, message, category, payment, structureInput, agreements, options) {
+        let participant = {
+            list,
+            user,
+            message,
+            category,
+            agreements,
+            state,
+            payment,
+            company: options.company,
+            project: options.project,
+        };
+        if (structureInput) {
+            participant = { ...participant, ...structureInput };
+        }
+        (0, cleanObject_1.default)(participant);
+        const partial = `${mode}-create`;
+        return this.create(participant, options.user, options.app, undefined, undefined, partial, { validator: options.validator });
+    }
+    addParticipantViaObject(participant, mode, options) {
+        const partial = `${mode}-create`;
+        return this.create(participant, options.user, options.app, undefined, undefined, partial, { validator: options.validator });
+    }
+    removeParticipant(list, user, options) {
+    }
+    listHistory(list, reason, options) {
+        const query = services_1.HistoryService.createQuery(options.company, options.project, undefined, reason, 'listParticipants');
+        query.countQuery.list = list;
+        query.aggregation[0].$match.$and.push({ $expr: { $eq: ['$list', list] } });
+        query.aggregation = [
+            query.aggregation[0],
+            query.aggregation[1],
+            ...this.customerLookup,
+        ];
+        return services_1.HistoryService.listCustomQuery(query);
+    }
+    agreementsMissing(listAgreements, providedAgreements) {
+        let missing = [];
+        const required = listAgreements?.filter((single) => single.required);
+        required.push({ required: true, contentId: 'contact-dsgvo', text: '' });
+        required.forEach((single) => {
+            if (!providedAgreements?.find((singleResponse) => singleResponse.id === single.contentId)) {
+                missing.push(single.contentId);
+            }
+        });
+        return missing;
+    }
+    async listParticipants(list, state, category, lastname, options) {
+        let aggregation = [
+            {
+                $match: {
+                    $and: [
+                        { $expr: { $eq: ['$company', options.company] } },
+                        { $expr: { $eq: ['$list', list] } },
+                    ],
+                },
+            },
+        ];
+        aggregation.push({
+            $sort: options.sort || { _id: -1 },
+        });
+        if (options.project) {
+            aggregation[0].$match.$and.push({ $expr: { $eq: ['$project', options.project] } });
+        }
+        if (state) {
+            aggregation[0].$match.$and.push({ $expr: { $in: ['$state', state] } });
+        }
+        else {
+            aggregation[0].$match.$and.push({ $expr: { $not: { $in: ['$state', ['blocked', 'unchecked', 'notuseful']] } } });
+        }
+        if (category) {
+            aggregation[0].$match.$and.push({ $expr: { $in: ['$category', category] } });
+        }
+        aggregation = [
+            ...aggregation,
+            ...this.getCustomerLookup(lastname),
+            ...this.paymentLookupList,
+        ];
+        aggregation.push({
+            $addFields: {
+                message: {
+                    $substrCP: ['$message', 0, 150],
+                },
+            },
+        });
+        aggregation.push({
+            $facet: {
+                all: [
+                    {
+                        $count: 'all',
+                    },
+                ],
+                data: [
+                    {
+                        $skip: options.skip,
+                    },
+                    {
+                        $limit: options.limit,
+                    },
+                ],
+            },
+        }, {
+            $unwind: '$all',
+        });
+        const data = await this.model.db.aggregate(aggregation)
+            .toArray();
+        return data[0] ? { all: data[0].all.all, data: data[0].data, count: data[0].data?.length } : { all: 0, data: [], count: 0 };
+    }
+    async getMyListsQuery(customerInternalId, filter, options) {
+        const aggregation = [
+            {
+                $match: {
+                    user: customerInternalId,
+                },
+            },
+            {
+                $lookup: {
+                    from: 'lists',
+                    localField: 'list',
+                    foreignField: '_id',
+                    as: 'listData',
+                },
+            },
+            {
+                $unwind: '$listData',
+            },
+            {
+                $addFields: {
+                    'listData.user': {
+                        state: '$state',
+                        created: '$history.created',
+                        updated: '$history.updated',
+                    },
+                },
+            },
+            {
+                $group: {
+                    _id: '$listData._id',
+                    list: {
+                        $first: '$listData',
+                    },
+                },
+            },
+            {
+                $replaceRoot: {
+                    newRoot: '$list',
+                },
+            },
+            {
+                $project: {
+                    _id: 1,
+                    name: 1,
+                    payment: 1,
+                    mode: 1,
+                    company: 1,
+                    project: 1,
+                    user: 1,
+                },
+            },
+            {
+                $addFields: {
+                    all: '$count',
+                },
+            },
+        ];
+        aggregation.push({
+            $sort: options.sort || { _id: -1 },
+        });
+        aggregation.push({
+            $facet: {
+                all: [
+                    {
+                        $count: 'all',
+                    },
+                ],
+                data: [
+                    {
+                        $skip: options.skip,
+                    },
+                    {
+                        $limit: options.limit,
+                    },
+                ],
+            },
+        }, {
+            $unwind: '$all',
+        });
+        const data = await this.model.db.aggregate(aggregation)
+            .toArray();
+        return data[0] ? { all: data[0].all.all, data: data[0].data, count: data[0].data?.length } : { all: 0, data: [], count: 0 };
+    }
+    updateImportIds(importData, options) {
+        const idMapping = {};
+        /**
+             * update the unique datasets with new object ids and company and project
+             */
+        importData.map((single) => {
+            const originalId = single._id?.toString();
+            const newId = new mongodb_1.ObjectId();
+            single._id = newId;
+            single.company = options.company;
+            single.project = options.project;
+            idMapping[originalId] = newId;
+        });
+        return idMapping;
+    }
+    export(options) {
+        return this.model.db.find({ company: options.company, project: options.project }).toArray();
+    }
+    async import(importData, importHistoryData, idMapping, bulkHistory, options) {
+        const bulk = this.model.db.initializeUnorderedBulkOp();
+        [...importData, ...importHistoryData].forEach((participant) => {
+            participant.list = idMapping[participant.list?.toString()];
+            participant.user = idMapping[participant.user?.toString()];
+            participant.payment = idMapping[participant.payment?.toString()];
+            participant.agreements?.forEach((agreement) => {
+                if (agreement.id !== 'contact-dsgvo') {
+                    agreement.id = idMapping[agreement.id]?.toString().toString();
+                }
+            });
+        });
+        importHistoryData.map((single) => {
+            const newParentId = idMapping[single.history.parent?.toString()];
+            single._id = new mongodb_1.ObjectId();
+            /**
+                 * update the parent id
+                 */
+            single.history.parent = newParentId;
+            /**
+                 * update the company and project to the new import data
+                 */
+            single.company = options.company;
+            single.project = options.project;
+        });
+        importData.map((single) => {
+            bulk.insert(single);
+        });
+        importHistoryData.map((single) => {
+            bulkHistory.insert(single);
+        });
+        return { bulk };
+    }
+}
+exports.ListParticipantsService = ListParticipantsService;
+exports.default = new ListParticipantsService(process.env.PUBLISH_QUEUE_CONNECTION_STRING, process.env.STORAGE_ACCOUNT, 'check');
+//# sourceMappingURL=listParticipants.service.js.map