feat: Version 2

Closes #627, closes #1047

server/api/helpers/users/make-scoper.js

@@ -0,0 +1,149 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+class Scoper {
+  constructor(user) {
+    this.user = user;
+
+    this.projectManagers = null;
+
+    this.separatedUserIds = null;
+    this.userRelatedProjectManagerAndBoardMemberUserIds = null;
+
+    this.privateUserRelatedUserIds = null;
+    this.publicUserRelatedUserIds = null;
+  }
+
+  async getProjectManagers() {
+    if (!this.projectManagers) {
+      this.projectManagers = await ProjectManager.qm.getByUserId(this.user.id);
+    }
+
+    return this.projectManagers;
+  }
+
+  async getSeparatedUserIds() {
+    if (!this.separatedUserIds) {
+      const users = await User.qm.getAll({
+        roleOrRoles: [User.Roles.ADMIN, User.Roles.PROJECT_OWNER],
+      });
+
+      const adminUserIds = [];
+      const projectOwnerUserIds = [];
+
+      users.forEach((user) => {
+        if (user.role === User.Roles.ADMIN) {
+          adminUserIds.push(user.id);
+        } else {
+          projectOwnerUserIds.push(user.id);
+        }
+      });
+
+      this.separatedUserIds = {
+        adminUserIds,
+        projectOwnerUserIds,
+      };
+    }
+
+    return this.separatedUserIds;
+  }
+
+  async getUserRelatedProjectManagerAndBoardMemberUserIds() {
+    if (!this.userRelatedProjectManagerAndBoardMemberUserIds) {
+      const projectManagers = await this.getProjectManagers();
+      const projectIds = sails.helpers.utils.mapRecords(projectManagers, 'projectId');
+
+      const relatedProjectManagers = await ProjectManager.qm.getByProjectIds(projectIds, {
+        exceptUserIdOrIds: this.user.id,
+      });
+
+      const relatedProjectManagerUserIds = sails.helpers.utils.mapRecords(
+        relatedProjectManagers,
+        'userId',
+      );
+
+      const relatedProjectBoardMemberships = await BoardMembership.qm.getByProjectIds(projectIds);
+
+      const relatedProjectBoardMemberUserIds = sails.helpers.utils.mapRecords(
+        relatedProjectBoardMemberships,
+        'userId',
+      );
+
+      const boardMemberships = await BoardMembership.qm.getByUserId(this.user.id, {
+        exceptProjectIdOrIds: projectIds,
+      });
+
+      const boardIds = sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
+
+      const relatedBoardMemberships = await BoardMembership.qm.getByBoardIds(boardIds, {
+        exceptUserIdOrIds: this.user.id,
+      });
+
+      const relatedBoardMemberUserIds = sails.helpers.utils.mapRecords(
+        relatedBoardMemberships,
+        'userId',
+      );
+
+      this.userRelatedProjectManagerAndBoardMemberUserIds = _.union(
+        relatedProjectManagerUserIds,
+        relatedProjectBoardMemberUserIds,
+        relatedBoardMemberUserIds,
+      );
+    }
+
+    return this.userRelatedProjectManagerAndBoardMemberUserIds;
+  }
+
+  async getPrivateUserRelatedUserIds() {
+    if (!this.privateUserRelatedUserIds) {
+      const { adminUserIds } = await this.getSeparatedUserIds();
+
+      this.privateUserRelatedUserIds = _.union([this.user.id], adminUserIds);
+    }
+
+    return this.privateUserRelatedUserIds;
+  }
+
+  async getPublicUserRelatedUserIds(skipRelatedProjectManagerAndBoardMemberUserIds = false) {
+    if (!this.publicUserRelatedUserIds) {
+      const privateUserRelatedUserIds = await this.getPrivateUserRelatedUserIds();
+      const privateUserRelatedUserIdsSet = new Set(privateUserRelatedUserIds);
+
+      const { projectOwnerUserIds } = await this.getSeparatedUserIds();
+
+      let userRelatedProjectManagerAndBoardMemberUserIds;
+      if (!skipRelatedProjectManagerAndBoardMemberUserIds) {
+        userRelatedProjectManagerAndBoardMemberUserIds =
+          await this.getUserRelatedProjectManagerAndBoardMemberUserIds();
+      }
+
+      const externalPublicUserRelatedUserIds = _.union(
+        projectOwnerUserIds,
+        userRelatedProjectManagerAndBoardMemberUserIds,
+      );
+
+      this.publicUserRelatedUserIds = externalPublicUserRelatedUserIds.filter(
+        (userId) => !privateUserRelatedUserIdsSet.has(userId),
+      );
+    }
+
+    return this.publicUserRelatedUserIds;
+  }
+}
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    record: {
+      type: 'ref',
+      required: true,
+    },
+  },
+
+  fn(inputs) {
+    return new Scoper(inputs.record);
+  },
+};