@lilaquadrat/studio 9.15.2 → 9.15.3

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

@@ -0,0 +1,739 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionsService = void 0;
+const me_model_1 = __importDefault(require("../models/me.model"));
+const permissions_model_1 = __importStar(require("../models/permissions.model"));
+const mongodb_1 = require("mongodb");
+const Immutable_error_1 = __importDefault(require("../classes/errors/Immutable.error"));
+const app_model_1 = __importDefault(require("../models/app.model"));
+const user_aggregation_1 = __importDefault(require("../aggegations/user.aggregation"));
+const Immutable_class_1 = __importDefault(require("../Immutable.class"));
+const hardCopy_1 = __importDefault(require("../helpers/hardCopy"));
+class PermissionsService extends Immutable_class_1.default {
+    constructor() {
+        super(...arguments);
+        this.model = permissions_model_1.default;
+    }
+    getScope(type, includeAdmin) {
+        const baseScope = type === 'company'
+            ? (0, hardCopy_1.default)(permissions_model_1.CompanyScope)
+            : (0, hardCopy_1.default)(permissions_model_1.ProjectScope);
+        if (type === 'company' && includeAdmin) {
+            Object.keys(permissions_model_1.CompanyScopeAdmin).forEach((key) => {
+                const singleScope = permissions_model_1.CompanyScopeAdmin[key];
+                if (baseScope[key]) {
+                    baseScope[key].push(...singleScope);
+                }
+                else {
+                    baseScope[key] = singleScope;
+                }
+            });
+        }
+        return baseScope;
+    }
+    /**
+       * list members of the company or the project
+       * lastname will be a regex on lastname in the database
+       * if not is true and a project is given, returns matching members that are not in this team
+       */
+    getTeamMember(company, project, lastname, not) {
+        let aggregation = [];
+        /**
+             * base query
+             * only for the providede customer and no history entries
+            */
+        const query = {
+            $and: [],
+        };
+        const lookupUser = [
+            {
+                $lookup: {
+                    from: 'me',
+                    as: 'user',
+                    let: {
+                        user: '$user',
+                    },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    { $expr: { $eq: ['$id', '$$user'] } },
+                                ],
+                            },
+                        },
+                        {
+                            $project: {
+                                lastname: 1,
+                                prename: 1,
+                                email: 1,
+                                id: 1,
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$user',
+                },
+            },
+        ];
+        if (lastname) {
+            lookupUser[0].$lookup.pipeline[0].$match.$and.push({ lastname: { $regex: new RegExp(lastname, 'i') } });
+        }
+        const projectScope = {
+            $project: {
+                scope: 0,
+            },
+        };
+        const lookupUniqueProjects = [
+            {
+                $lookup: {
+                    from: 'permissions',
+                    as: 'projects',
+                    let: {
+                        user: '$user.id',
+                    },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    { $expr: { $eq: ['$user', '$$user'] } },
+                                    { $expr: { $eq: ['$project', project] } },
+                                    { $expr: { $eq: ['$company', company] } },
+                                ],
+                            },
+                        },
+                        {
+                            $group: { _id: null, count: { $sum: 1 } },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$projects',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $match: {
+                    $and: [
+                        { projects: { $exists: false } },
+                    ],
+                },
+            },
+            {
+                $project: {
+                    projects: 0,
+                },
+            },
+        ];
+        /**
+             * base query and company lookup are always needed
+            */
+        aggregation.push({ $match: query });
+        aggregation.push(projectScope);
+        aggregation = [...aggregation, ...lookupUser];
+        if (company && !project) {
+            query.$and.push({ project: { $exists: false } });
+            query.$and.push({ company: { $exists: true } });
+            query.$and.push({ $expr: { $eq: ['$company', company] } });
+        }
+        if (company && project) {
+            query.$and.push({ $expr: { $eq: ['$company', company] } });
+            if (!not) {
+                query.$and.push({ $expr: { $eq: ['$project', project] } });
+            }
+            else {
+                query.$and.push({ project: { $exists: false } });
+                aggregation = [...aggregation, ...lookupUniqueProjects];
+            }
+        }
+        return permissions_model_1.default.db.aggregate(aggregation).toArray();
+    }
+    generatePermissionArray(permissionsObject) {
+        const permissionArray = [];
+        Object.keys(permissionsObject).forEach((key) => {
+            const single = permissionsObject[key];
+            single.forEach((permission) => {
+                permissionArray.push(`${key}:${permission}`);
+            });
+        });
+        return permissionArray;
+    }
+    single(_id, company, project) {
+        const query = [
+            {
+                $match: {
+                    company,
+                    project,
+                    _id,
+                },
+            },
+            ...user_aggregation_1.default,
+        ];
+        return this.model.db.aggregate(query).toArray()
+            .then((permissions) => {
+            if (!permissions.length)
+                return null;
+            return permissions[0];
+        });
+    }
+    all(user) {
+        const query = [
+            {
+                $match: {
+                    user,
+                    project: {
+                        $exists: false,
+                    },
+                },
+            },
+            {
+                $project: {
+                    history: 0,
+                    user: 0,
+                },
+            },
+            {
+                $lookup: {
+                    from: 'permissions',
+                    as: 'projects',
+                    let: {
+                        companyId: '$company',
+                        user,
+                    },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    {
+                                        $expr: {
+                                            $eq: ['$user', '$$user'],
+                                        },
+                                    },
+                                    {
+                                        project: {
+                                            $exists: true,
+                                        },
+                                    },
+                                    {
+                                        $expr: {
+                                            $eq: [
+                                                '$company',
+                                                '$$companyId',
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$projects',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $lookup: {
+                    from: 'projects',
+                    as: 'projectDetails',
+                    let: {
+                        projectId: '$projects.project',
+                        companyId: '$company',
+                    },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    {
+                                        $expr: {
+                                            $eq: ['$id', '$$projectId'],
+                                        },
+                                    },
+                                    {
+                                        $expr: {
+                                            $eq: [
+                                                '$company',
+                                                '$$companyId',
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            $project: {
+                                _id: 0,
+                                name: 1,
+                                id: 1,
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$projectDetails',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $addFields: {
+                    'projects.sortName': {
+                        $cond: {
+                            if: {
+                                $and: [
+                                    {
+                                        $ne: ['$projectDetails', null],
+                                    },
+                                    // Checks that projectDetails is not null
+                                    {
+                                        $ne: [
+                                            {
+                                                $type: '$projectDetails',
+                                            },
+                                            'missing',
+                                        ],
+                                    }, // Checks that projectDetails exists
+                                ],
+                            },
+                            then: {
+                                $toLower: '$projectDetails.name',
+                            },
+                            // Example operation if conditions are met
+                            else: '$$REMOVE', // Removes the field or alternative action
+                        },
+                    },
+                    'projects.name': {
+                        $cond: {
+                            if: {
+                                $and: [
+                                    {
+                                        $ne: ['$projectDetails', null],
+                                    },
+                                    // Checks that projectDetails is not null
+                                    {
+                                        $ne: [
+                                            {
+                                                $type: '$projectDetails',
+                                            },
+                                            'missing',
+                                        ],
+                                    }, // Checks that projectDetails exists
+                                ],
+                            },
+                            then: '$projectDetails.name',
+                            // Example operation if conditions are met
+                            else: '$$REMOVE', // Removes the field or alternative action
+                        },
+                    },
+                    'projects.id': {
+                        $cond: {
+                            if: {
+                                $and: [
+                                    {
+                                        $ne: ['$projectDetails', null],
+                                    },
+                                    // Checks that projectDetails is not null
+                                    {
+                                        $ne: [
+                                            {
+                                                $type: '$projectDetails',
+                                            },
+                                            'missing',
+                                        ],
+                                    }, // Checks that projectDetails exists
+                                ],
+                            },
+                            then: {
+                                $toLower: '$projectDetails.id',
+                            },
+                            // Example operation if conditions are met
+                            else: '$$REMOVE', // Removes the field or alternative action
+                        },
+                    },
+                },
+            },
+            {
+                $sort: {
+                    'projects.sortName': 1,
+                },
+            },
+            {
+                $project: 
+                /**
+                 * specifications: The fields to
+                 *   include or exclude.
+                 */
+                {
+                    'projects._id': 0,
+                    'projects.user': 0,
+                    'projects.history': 0,
+                    'projects.sortName': 0,
+                },
+            },
+            {
+                $project: {
+                    projectDetails: 0,
+                },
+            },
+            {
+                $group: {
+                    _id: '$company',
+                    projects: {
+                        $push: '$projects',
+                    }, // Collect documents based on the condition
+                },
+            },
+            {
+                $lookup: {
+                    from: 'companies',
+                    as: 'companyDetails',
+                    let: {
+                        companyId: '$_id',
+                    },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    {
+                                        $expr: {
+                                            $eq: ['$id', '$$companyId'],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            $project: {
+                                _id: 0,
+                                name: 1,
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$companyDetails',
+                    preserveNullAndEmptyArrays: false,
+                },
+            },
+            {
+                $addFields: {
+                    name: '$companyDetails.name',
+                    sortName: {
+                        $toLower: '$companyDetails.name',
+                    },
+                },
+            },
+            {
+                $project: {
+                    companyDetails: 0,
+                },
+            },
+            {
+                $addFields: {
+                    projects: {
+                        $cond: {
+                            if: {
+                                $eq: [
+                                    {
+                                        $arrayElemAt: ['$projects', 0],
+                                    },
+                                    {},
+                                ],
+                            },
+                            // Check if the first element is an empty object
+                            then: {
+                                $concatArrays: [
+                                    {
+                                        $slice: [
+                                            '$projects',
+                                            1,
+                                            {
+                                                $size: '$projects',
+                                            },
+                                        ],
+                                    }, // Remove the first element if it's an empty object
+                                ],
+                            },
+                            else: '$projects', // Leave the array unchanged if the first element is not an empty object
+                        },
+                    },
+                },
+            },
+            {
+                $sort: 
+                /**
+                 * Provide any number of field/order pairs.
+                 */
+                {
+                    sortName: 1,
+                },
+            },
+            {
+                $project: {
+                    sortName: 0,
+                },
+            },
+            {
+                $lookup: {
+                    from: 'permissions',
+                    as: 'companyScope',
+                    let: {
+                        companyId: '$_id',
+                        user,
+                    },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    {
+                                        $expr: {
+                                            $eq: ['$user', '$$user'],
+                                        },
+                                    },
+                                    {
+                                        $expr: {
+                                            $eq: [
+                                                '$company',
+                                                '$$companyId',
+                                            ],
+                                        },
+                                    },
+                                    {
+                                        $expr: {
+                                            $eq: [
+                                                {
+                                                    $ifNull: ['$project', null],
+                                                },
+                                                null,
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            $project: {
+                                _id: 0,
+                                scope: 1,
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$companyScope',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $addFields: {
+                    scope: '$companyScope.scope',
+                },
+            },
+            {
+                $project: {
+                    companyScope: 0,
+                },
+            },
+        ];
+        return this.model.db.aggregate(query).toArray()
+            .then((permissions) => {
+            if (!permissions.length)
+                return null;
+            return permissions;
+        });
+    }
+    addToCompany(email, company, scope, user, app) {
+        let newUser;
+        return me_model_1.default.db.findOne({ email })
+            .then((userDatabase) => {
+            if (!userDatabase)
+                throw new Error('USER_NOT_FOUND');
+            newUser = userDatabase;
+            return this.model.db.countDocuments({ user: newUser.id, company, project: { $exists: false } });
+        })
+            .then((count) => {
+            if (count)
+                throw new Error('USER_ALREADY_EXISTS');
+            return this.create({ user: newUser.id, company, scope }, user, app);
+        });
+    }
+    addToProject(userToAdd, company, project, scope, user, app) {
+        return this.model.db.countDocuments({ user: userToAdd, company, project: { $exists: false } })
+            .then((userInCompany) => {
+            if (!userInCompany)
+                throw new Error('user not in company');
+            return this.create({
+                user: userToAdd,
+                company,
+                project,
+                scope,
+            }, user, app);
+        });
+    }
+    remove(_id, company, project, user, app) {
+        return this.model.db.countDocuments({ _id, company, project })
+            .then((documentCount) => {
+            if (!documentCount)
+                throw new Immutable_error_1.default('document for deletion not found');
+            return this.delete(_id, user, app);
+        });
+    }
+    async filterPermissions(scope, appKeys, options) {
+        const basicApps = ['permissions', 'settings', 'app', 'html'];
+        const combinedApps = [...appKeys, ...basicApps];
+        const apps = await app_model_1.default.db.find({ id: { $in: combinedApps }, available: { $in: options.filter || ['public'] } }).toArray();
+        const filteredPermissions = {};
+        combinedApps.forEach((single) => {
+            const singleApp = apps.find((app) => app.id === single);
+            if (options.isProject && !singleApp?.projectAvailable && !basicApps.includes(single))
+                return;
+            if (singleApp?.universal) {
+                filteredPermissions[single] = this.getUniversalAppScope(permissions_model_1.UniversalScope, singleApp.models);
+            }
+            else if (basicApps.includes(single) || singleApp) {
+                filteredPermissions[single] = scope[single];
+                if (singleApp?.models) {
+                    singleApp.models.forEach((singleModel) => {
+                        if (scope[singleModel]) {
+                            filteredPermissions[singleModel] = scope[singleModel];
+                        }
+                    });
+                }
+            }
+        });
+        return filteredPermissions;
+    }
+    getUniversalAppScope(scope, models) {
+        const scopeObject = {};
+        models?.forEach((single) => {
+            scopeObject[single] = scope;
+        });
+        return scopeObject;
+    }
+    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();
+        const queryArray = [];
+        /**
+        * create a query array for the existing items
+        */
+        importData.map((single) => {
+            queryArray.push({ company: options.company, project: options.project, user: single.user });
+        });
+        /**
+             * get all existing items
+             */
+        const existingItems = await this.model.db.find({ $or: queryArray }).toArray();
+        const skippedData = [];
+        const filteredData = [];
+        /**
+             * filter the data to only import new items
+             * add removed items to skippedData
+             */
+        importData.forEach((importItem) => {
+            const documentExists = existingItems.some((existingItem) => existingItem.company === options.company &&
+                existingItem.project === options.project &&
+                existingItem.user === importItem.user);
+            if (documentExists) {
+                skippedData.push(importItem);
+            }
+            else {
+                filteredData.push(importItem);
+            }
+            return importItem;
+        });
+        const filteredHistoryData = importHistoryData.filter((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;
+            if (filteredData.find((data) => data._id?.toString() === newParentId?.toString())) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+        filteredData.map((single) => {
+            bulk.insert(single);
+        });
+        filteredHistoryData.map((single) => {
+            bulkHistory.insert(single);
+        });
+        return { bulk, skippedData, filteredData };
+    }
+}
+exports.PermissionsService = PermissionsService;
+exports.default = new PermissionsService();
+//# sourceMappingURL=permissions.service.js.map