@lilaquadrat/studio 9.14.3 → 9.15.1

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

@@ -1,729 +0,0 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __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