@intuitionrobotics/permissions/dist/app-backend/modules/PermissionsModule.js

Permissions

import { arrayToMap, batchActionParallel, ImplementationMissingException, Module } from "@intuitionrobotics/ts-common";
import {} from "./_imports.js";
import { PermissionsAssert } from "./permissions-assert.js";
import { ApiPermissionsDB, ProjectPermissionsDB } from "./db-types/managment.js";
import { GroupPermissionsDB, UserPermissionsDB } from "./db-types/assign.js";
import { AccountModule } from "@intuitionrobotics/user-account/backend";
import {} from "@intuitionrobotics/user-account/shared/api";
export class PermissionsModule_Class extends Module {
    constructor() {
        super("PermissionsModule");
    }
    // Was init(): fail-fast on missing project identity moved to validate(),
    // which Storm still runs at build time.
    validate() {
        super.validate();
        if (!this.config.project)
            throw new ImplementationMissingException("MUST set config with project identity!!");
    }
    getProjectIdentity = () => this.config.project;
    async getUserUrlsPermissions(projectId, urlsMap, userId, requestCustomField) {
        const urls = Object.keys(urlsMap);
        const [userDetails, apiDetails] = await Promise.all([
            PermissionsAssert.getUserDetails(userId),
            PermissionsAssert.getApisDetails(urls, projectId)
        ]);
        return urls.reduce((userUrlsPermissions, url, i) => {
            const apiDetail = apiDetails[i];
            if (apiDetail) {
                try {
                    PermissionsAssert._assertUserPermissionsImpl(apiDetail, projectId, userDetails, requestCustomField);
                    userUrlsPermissions[url] = true;
                }
                catch (_e) {
                    userUrlsPermissions[url] = false;
                }
            }
            else
                userUrlsPermissions[url] = false;
            return userUrlsPermissions;
        }, {});
    }
    async getUsersCFsByShareGroups(usersEmails, groupsIds) {
        const accounts = await AccountModule.getUsers(usersEmails);
        const usersMap = arrayToMap(accounts, u => u.email);
        const permissionUsers = await batchActionParallel(accounts.map(u => u._id), 10, async (batchedAccountIds) => {
            return UserPermissionsDB.query({
                where: {
                    accountId: {
                        $in: batchedAccountIds
                    }
                },
                select: ['groups', 'accountId']
            });
        });
        const permissionUsersMap = arrayToMap(permissionUsers, pu => pu.accountId);
        return usersEmails.reduce((acc, e) => {
            const account = usersMap[e.toLowerCase()];
            if (!account)
                return acc;
            const user = permissionUsersMap[account._id];
            if (!user)
                return acc;
            acc[e] = this.getCustomFields(user, groupsIds);
            return acc;
        }, {});
    }
    async getUserCFsByShareGroups(userId, groupsIds) {
        const user = await UserPermissionsDB.queryUnique({ accountId: userId });
        return this.getCustomFields(user, groupsIds);
    }
    getCustomFields(user, groupsIds) {
        if (!user.groups)
            return [];
        return user.groups.reduce((acc, userGroup) => {
            if (!groupsIds.find(groupId => groupId === userGroup.groupId))
                return acc;
            if (!userGroup.customField)
                return acc;
            acc.push(userGroup.customField);
            return acc;
        }, []);
    }
    async registerProject(routes) {
        const projectRoutes = {
            project: PermissionsModule.getProjectIdentity(),
            routes,
            predefinedGroups: this.config.predefinedGroups,
            predefinedUser: this.config.predefinedUser
        };
        return this._registerProject(projectRoutes);
    }
    async _registerProject(registerProject) {
        const project = registerProject.project;
        await ProjectPermissionsDB.upsert(project);
        await ApiPermissionsDB.registerApis(project._id, registerProject.routes);
        const predefinedGroups = registerProject.predefinedGroups;
        if (!predefinedGroups || predefinedGroups.length === 0)
            return;
        await GroupPermissionsDB.upsertPredefinedGroups(project._id, project.name, predefinedGroups);
        const predefinedUser = registerProject.predefinedUser;
        if (!predefinedUser)
            return;
        const groupsUser = predefinedUser.groups.map(groupItem => {
            const customField = {};
            const allRegEx = ".*";
            if (!groupItem.customKeys || !groupItem.customKeys.length)
                customField["_id"] = allRegEx;
            else {
                groupItem.customKeys.forEach((customKey) => {
                    customField[customKey] = allRegEx;
                });
            }
            return {
                groupId: GroupPermissionsDB.getPredefinedGroupId(project._id, groupItem._id),
                customField
            };
        });
        await UserPermissionsDB.upsert({ ...predefinedUser, groups: groupsUser });
    }
}
export const PermissionsModule = new PermissionsModule_Class();
//# sourceMappingURL=PermissionsModule.js.map