feat: Version 2

Closes #627, closes #1047

server/api/controllers/projects/create.js

@@ -1,31 +1,32 @@
-const Errors = {
-  NOT_ENOUGH_RIGHTS: {
-    notEnoughRights: 'Not enough rights',
-  },
-};
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
 
 module.exports = {
   inputs: {
-    name: {
+    type: {
       type: 'string',
+      isIn: Object.values(Project.Types),
       required: true,
     },
-  },
-
-  exits: {
-    notEnoughRights: {
-      responseType: 'forbidden',
+    name: {
+      type: 'string',
+      maxLength: 128,
+      required: true,
+    },
+    description: {
+      type: 'string',
+      isNotEmptyString: true,
+      maxLength: 1024,
+      allowNull: true,
     },
   },
 
   async fn(inputs) {
     const { currentUser } = this.req;
 
-    if (!currentUser.isAdmin && !sails.config.custom.allowAllToCreateProjects) {
-      throw Errors.NOT_ENOUGH_RIGHTS;
-    }
-
-    const values = _.pick(inputs, ['name']);
+    const values = _.pick(inputs, ['type', 'name', 'description']);
 
     const { project, projectManager } = await sails.helpers.projects.createOne.with({
       values,

server/api/controllers/projects/delete.js

@@ -1,14 +1,23 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { idInput } = require('../../../utils/inputs');
+
 const Errors = {
   PROJECT_NOT_FOUND: {
     projectNotFound: 'Project not found',
   },
+  MUST_NOT_HAVE_BOARDS: {
+    mustNotHaveBoards: 'Must not have boards',
+  },
 };
 
 module.exports = {
   inputs: {
     id: {
-      type: 'string',
-      regex: /^[0-9]+$/,
+      ...idInput,
       required: true,
     },
   },
@@ -17,12 +26,15 @@ module.exports = {
     projectNotFound: {
       responseType: 'notFound',
     },
+    mustNotHaveBoards: {
+      responseType: 'unprocessableEntity',
+    },
   },
 
   async fn(inputs) {
     const { currentUser } = this.req;
 
-    let project = await Project.findOne(inputs.id);
+    let project = await Project.qm.getOneById(inputs.id);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
@@ -34,11 +46,13 @@ module.exports = {
       throw Errors.PROJECT_NOT_FOUND; // Forbidden
     }
 
-    project = await sails.helpers.projects.deleteOne.with({
-      record: project,
-      actorUser: currentUser,
-      request: this.req,
-    });
+    project = await sails.helpers.projects.deleteOne
+      .with({
+        record: project,
+        actorUser: currentUser,
+        request: this.req,
+      })
+      .intercept('mustNotHaveBoards', () => Errors.MUST_NOT_HAVE_BOARDS);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;

server/api/controllers/projects/index.js

@@ -1,53 +1,104 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
 module.exports = {
   async fn() {
     const { currentUser } = this.req;
 
-    const managerProjectIds = await sails.helpers.users.getManagerProjectIds(currentUser.id);
-    const managerProjects = await sails.helpers.projects.getMany(managerProjectIds);
+    let sharedProjects;
+    let sharedProjectIds;
 
-    let boardMemberships = await sails.helpers.users.getBoardMemberships(currentUser.id);
+    const managerProjectIds = await sails.helpers.users.getManagerProjectIds(currentUser.id);
+    const fullyVisibleProjectIds = [...managerProjectIds];
+
+    if (currentUser.role === User.Roles.ADMIN) {
+      sharedProjects = await Project.qm.getShared({
+        exceptIdOrIds: managerProjectIds,
+      });
+
+      sharedProjectIds = sails.helpers.utils.mapRecords(sharedProjects);
+      fullyVisibleProjectIds.push(...sharedProjectIds);
+    }
+
+    const boardMemberships = await BoardMembership.qm.getByUserId(currentUser.id);
     const membershipBoardIds = sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
 
-    let membershipBoards = await sails.helpers.boards.getMany({
-      id: membershipBoardIds,
-      projectId: {
-        '!=': managerProjectIds,
-      },
+    const membershipBoards = await Board.qm.getByIds(membershipBoardIds, {
+      exceptProjectIdOrIds: fullyVisibleProjectIds,
     });
 
-    let membershipProjectIds = sails.helpers.utils.mapRecords(membershipBoards, 'projectId', true);
-    const membershipProjects = await sails.helpers.projects.getMany(membershipProjectIds);
-
-    membershipProjectIds = sails.helpers.utils.mapRecords(membershipProjects);
+    const membershipProjectIds = sails.helpers.utils.mapRecords(
+      membershipBoards,
+      'projectId',
+      true,
+    );
 
     const projectIds = [...managerProjectIds, ...membershipProjectIds];
-    const projects = [...managerProjects, ...membershipProjects];
+    const projects = await Project.qm.getByIds(projectIds);
 
-    const projectManagers = await sails.helpers.projects.getProjectManagers(projectIds);
+    if (sharedProjectIds) {
+      projectIds.push(...sharedProjectIds);
+      projects.push(...sharedProjects);
+    }
+
+    const fullyVisibleBoards = await Board.qm.getByProjectIds(fullyVisibleProjectIds);
+    const boards = [...fullyVisibleBoards, ...membershipBoards];
+
+    const projectFavorites = await ProjectFavorite.qm.getByProjectIdsAndUserId(
+      projectIds,
+      currentUser.id,
+    );
+
+    const projectManagers = await ProjectManager.qm.getByProjectIds(projectIds);
 
     const userIds = sails.helpers.utils.mapRecords(projectManagers, 'userId', true);
-    const users = await sails.helpers.users.getMany(userIds);
+    const users = await User.qm.getByIds(userIds);
 
-    const managerBoards = await sails.helpers.projects.getBoards(managerProjectIds);
+    const backgroundImages = await BackgroundImage.qm.getByProjectIds(projectIds);
 
-    membershipBoards = membershipBoards.filter((membershipBoard) =>
-      membershipProjectIds.includes(membershipBoard.projectId),
+    const baseCustomFieldGroups = await BaseCustomFieldGroup.qm.getByProjectIds(projectIds);
+    const baseCustomFieldGroupsIds = sails.helpers.utils.mapRecords(baseCustomFieldGroups);
+
+    const customFields =
+      await CustomField.qm.getByBaseCustomFieldGroupIds(baseCustomFieldGroupsIds);
+
+    let notificationServices = [];
+    if (managerProjectIds.length > 0) {
+      const managerProjectIdsSet = new Set(managerProjectIds);
+
+      const managerBoardIds = boards.flatMap((board) =>
+        managerProjectIdsSet.has(board.projectId) ? board.id : [],
+      );
+
+      notificationServices = await NotificationService.qm.getByBoardIds(managerBoardIds);
+    }
+
+    const isFavoriteByProjectId = projectFavorites.reduce(
+      (result, projectFavorite) => ({
+        ...result,
+        [projectFavorite.projectId]: true,
+      }),
+      {},
     );
 
-    const boards = [...managerBoards, ...membershipBoards];
-    const boardIds = sails.helpers.utils.mapRecords(boards);
-
-    boardMemberships = boardMemberships.filter((boardMembership) =>
-      boardIds.includes(boardMembership.boardId),
-    );
+    projects.forEach((project) => {
+      // eslint-disable-next-line no-param-reassign
+      project.isFavorite = isFavoriteByProjectId[project.id] || false;
+    });
 
     return {
       items: projects,
       included: {
-        users,
         projectManagers,
+        baseCustomFieldGroups,
         boards,
         boardMemberships,
+        customFields,
+        notificationServices,
+        users: sails.helpers.users.presentMany(users, currentUser),
+        backgroundImages: sails.helpers.backgroundImages.presentMany(backgroundImages),
       },
     };
   },

server/api/controllers/projects/show.js

@@ -1,3 +1,10 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { idInput } = require('../../../utils/inputs');
+
 const Errors = {
   PROJECT_NOT_FOUND: {
     projectNotFound: 'Project not found',
@@ -7,8 +14,7 @@ const Errors = {
 module.exports = {
   inputs: {
     id: {
-      type: 'string',
-      regex: /^[0-9]+$/,
+      ...idInput,
       required: true,
     },
   },
@@ -22,43 +28,67 @@ module.exports = {
   async fn(inputs) {
     const { currentUser } = this.req;
 
-    const project = await Project.findOne(inputs.id);
+    const project = await Project.qm.getOneById(inputs.id);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
-    let boards = await sails.helpers.projects.getBoards(project.id);
-    let boardIds = sails.helpers.utils.mapRecords(boards);
-
-    const boardMemberships = await sails.helpers.boardMemberships.getMany({
-      boardId: boardIds,
-      userId: currentUser.id,
-    });
-
     const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
 
-    if (!isProjectManager) {
-      if (boardMemberships.length === 0) {
-        throw Errors.PROJECT_NOT_FOUND; // Forbidden
-      }
+    const boardMemberships = await BoardMembership.qm.getByProjectIdAndUserId(
+      project.id,
+      currentUser.id,
+    );
 
-      boardIds = sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
-      boards = boards.filter((board) => boardIds.includes(board.id));
+    let boards;
+    if (currentUser.role !== User.Roles.ADMIN || project.ownerProjectManagerId) {
+      if (!isProjectManager) {
+        if (boardMemberships.length === 0) {
+          throw Errors.PROJECT_NOT_FOUND; // Forbidden
+        }
+
+        const boardIds = sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
+        boards = await Board.qm.getByIds(boardIds);
+      }
     }
 
-    const projectManagers = await sails.helpers.projects.getProjectManagers(project.id);
+    if (!boards) {
+      boards = await Board.qm.getByProjectId(project.id);
+    }
+
+    project.isFavorite = await sails.helpers.users.isProjectFavorite(currentUser.id, project.id);
+
+    const projectManagers = await ProjectManager.qm.getByProjectId(project.id);
 
     const userIds = sails.helpers.utils.mapRecords(projectManagers, 'userId');
-    const users = await sails.helpers.users.getMany(userIds);
+    const users = await User.qm.getByIds(userIds);
+
+    const backgroundImages = await BackgroundImage.qm.getByProjectId(project.id);
+
+    const baseCustomFieldGroups = await BaseCustomFieldGroup.qm.getByProjectId(project.id);
+    const baseCustomFieldGroupsIds = sails.helpers.utils.mapRecords(baseCustomFieldGroups);
+
+    const customFields =
+      await CustomField.qm.getByBaseCustomFieldGroupIds(baseCustomFieldGroupsIds);
+
+    let notificationServices = [];
+    if (isProjectManager) {
+      boardIds = sails.helpers.utils.mapRecords(boards);
+      notificationServices = await NotificationService.qm.getByBoardIds(boardIds);
+    }
 
     return {
       item: project,
       included: {
-        users,
         projectManagers,
+        baseCustomFieldGroups,
         boards,
         boardMemberships,
+        customFields,
+        notificationServices,
+        users: sails.helpers.users.presentMany(users, currentUser),
+        backgroundImages: sails.helpers.backgroundImages.presentMany(backgroundImages),
       },
     };
   },

server/api/controllers/projects/update-background-image.js

@@ -1,96 +0,0 @@
-const rimraf = require('rimraf');
-
-const Errors = {
-  PROJECT_NOT_FOUND: {
-    projectNotFound: 'Project not found',
-  },
-  NO_FILE_WAS_UPLOADED: {
-    noFileWasUploaded: 'No file was uploaded',
-  },
-  FILE_IS_NOT_IMAGE: {
-    fileIsNotImage: 'File is not image',
-  },
-};
-
-module.exports = {
-  inputs: {
-    id: {
-      type: 'string',
-      regex: /^[0-9]+$/,
-      required: true,
-    },
-  },
-
-  exits: {
-    projectNotFound: {
-      responseType: 'notFound',
-    },
-    noFileWasUploaded: {
-      responseType: 'unprocessableEntity',
-    },
-    fileIsNotImage: {
-      responseType: 'unprocessableEntity',
-    },
-    uploadError: {
-      responseType: 'unprocessableEntity',
-    },
-  },
-
-  async fn(inputs, exits) {
-    const { currentUser } = this.req;
-
-    let project = await Project.findOne(inputs.id);
-
-    if (!project) {
-      throw Errors.PROJECT_NOT_FOUND;
-    }
-
-    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
-
-    if (!isProjectManager) {
-      throw Errors.PROJECT_NOT_FOUND; // Forbidden
-    }
-
-    let files;
-    try {
-      files = await sails.helpers.utils.receiveFile('file', this.req);
-    } catch (error) {
-      return exits.uploadError(error.message); // TODO: add error
-    }
-
-    if (files.length === 0) {
-      throw Errors.NO_FILE_WAS_UPLOADED;
-    }
-
-    const file = _.last(files);
-
-    const fileData = await sails.helpers.projects
-      .processUploadedBackgroundImageFile(file)
-      .intercept('fileIsNotImage', () => {
-        try {
-          rimraf.sync(file.fd);
-        } catch (error) {
-          console.warn(error.stack); // eslint-disable-line no-console
-        }
-
-        return Errors.FILE_IS_NOT_IMAGE;
-      });
-
-    project = await sails.helpers.projects.updateOne.with({
-      record: project,
-      values: {
-        backgroundImage: fileData,
-      },
-      actorUser: currentUser,
-      request: this.req,
-    });
-
-    if (!project) {
-      throw Errors.PROJECT_NOT_FOUND;
-    }
-
-    return exits.success({
-      item: project,
-    });
-  },
-};

server/api/controllers/projects/update.js

@@ -1,89 +1,230 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { idInput } = require('../../../utils/inputs');
+
 const Errors = {
+  NOT_ENOUGH_RIGHTS: {
+    notEnoughRights: 'Not enough rights',
+  },
   PROJECT_NOT_FOUND: {
     projectNotFound: 'Project not found',
   },
+  OWNER_PROJECT_MANAGER_NOT_FOUND: {
+    ownerProjectManagerNotFound: 'Owner project manager not found',
+  },
+  BACKGROUND_IMAGE_NOT_FOUND: {
+    backgroundImageNotFound: 'Background image not found',
+  },
+  PROJECT_ALREADY_HAS_OWNER_PROJECT_MANAGER: {
+    projectAlreadyHasOwnerProjectManager: 'Project already has owner project manager',
+  },
+  OWNER_PROJECT_MANAGER_MUST_BE_LAST_MANAGER: {
+    ownerProjectManagerMustBeLastManager: 'Owner project manager must be last manager',
+  },
+  BACKGROUND_IMAGE_MUST_BE_PRESENT: {
+    backgroundImageMustBePresent: 'Background image must be present',
+  },
+  BACKGROUND_GRADIENT_MUST_BE_PRESENT: {
+    backgroundGradientMustBePresent: 'Background gradient must be present',
+  },
 };
 
-const backgroundValidator = (value) => {
-  if (_.isNull(value)) {
-    return true;
-  }
-
-  if (!_.isPlainObject(value)) {
-    return false;
-  }
-
-  if (!Object.values(Project.BackgroundTypes).includes(value.type)) {
-    return false;
-  }
-
-  if (
-    value.type === Project.BackgroundTypes.GRADIENT &&
-    _.size(value) === 2 &&
-    Project.BACKGROUND_GRADIENTS.includes(value.name)
-  ) {
-    return true;
-  }
-
-  if (value.type === Project.BackgroundTypes.IMAGE && _.size(value) === 1) {
-    return true;
-  }
-
-  return false;
-};
-
-const backgroundImageValidator = (value) => _.isNull(value);
-
 module.exports = {
   inputs: {
     id: {
-      type: 'string',
-      regex: /^[0-9]+$/,
+      ...idInput,
       required: true,
     },
+    ownerProjectManagerId: {
+      ...idInput,
+      allowNull: true,
+    },
+    backgroundImageId: {
+      ...idInput,
+      allowNull: true,
+    },
     name: {
       type: 'string',
       isNotEmptyString: true,
+      maxLength: 128,
     },
-    background: {
-      type: 'json',
-      custom: backgroundValidator,
+    description: {
+      type: 'string',
+      isNotEmptyString: true,
+      maxLength: 1024,
+      allowNull: true,
     },
-    backgroundImage: {
-      type: 'json',
-      custom: backgroundImageValidator,
+    backgroundType: {
+      type: 'string',
+      isIn: Object.values(Project.BackgroundTypes),
+      allowNull: true,
+    },
+    backgroundGradient: {
+      type: 'string',
+      isIn: Project.BACKGROUND_GRADIENTS,
+      allowNull: true,
+    },
+    isHidden: {
+      type: 'boolean',
+    },
+    isFavorite: {
+      type: 'boolean',
     },
   },
 
   exits: {
+    notEnoughRights: {
+      responseType: 'forbidden',
+    },
     projectNotFound: {
       responseType: 'notFound',
     },
+    ownerProjectManagerNotFound: {
+      responseType: 'notFound',
+    },
+    backgroundImageNotFound: {
+      responseType: 'notFound',
+    },
+    projectAlreadyHasOwnerProjectManager: {
+      responseType: 'conflict',
+    },
+    ownerProjectManagerMustBeLastManager: {
+      responseType: 'unprocessableEntity',
+    },
+    backgroundImageMustBePresent: {
+      responseType: 'unprocessableEntity',
+    },
+    backgroundGradientMustBePresent: {
+      responseType: 'unprocessableEntity',
+    },
   },
 
   async fn(inputs) {
     const { currentUser } = this.req;
 
-    let project = await Project.findOne(inputs.id);
+    let project = await Project.qm.getOneById(inputs.id);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
-    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
+    const projectManager = await ProjectManager.qm.getOneByProjectIdAndUserId(
+      project.id,
+      currentUser.id,
+    );
 
-    if (!isProjectManager) {
-      throw Errors.PROJECT_NOT_FOUND; // Forbidden
+    const availableInputKeys = ['id', 'isFavorite'];
+    if (project.ownerProjectManagerId) {
+      if (projectManager) {
+        if (!_.isNil(inputs.ownerProjectManagerId)) {
+          throw Errors.NOT_ENOUGH_RIGHTS;
+        }
+
+        availableInputKeys.push('ownerProjectManagerId', 'isHidden');
+      }
+    } else if (currentUser.role === User.Roles.ADMIN) {
+      availableInputKeys.push('ownerProjectManagerId', 'isHidden');
+    } else if (projectManager) {
+      availableInputKeys.push('isHidden');
     }
 
-    const values = _.pick(inputs, ['name', 'background', 'backgroundImage']);
+    if (projectManager) {
+      availableInputKeys.push(
+        'backgroundImageId',
+        'name',
+        'description',
+        'backgroundType',
+        'backgroundGradient',
+      );
+    }
 
-    project = await sails.helpers.projects.updateOne.with({
-      values,
-      record: project,
-      actorUser: currentUser,
-      request: this.req,
-    });
+    if (_.difference(Object.keys(inputs), availableInputKeys).length > 0) {
+      throw Errors.NOT_ENOUGH_RIGHTS;
+    }
+
+    let nextOwnerProjectManager;
+    if (inputs.ownerProjectManagerId) {
+      nextOwnerProjectManager = await ProjectManager.qm.getOneById(inputs.ownerProjectManagerId, {
+        projectId: project.id,
+      });
+
+      if (!nextOwnerProjectManager) {
+        throw Errors.OWNER_PROJECT_MANAGER_NOT_FOUND;
+      }
+
+      delete inputs.ownerProjectManagerId; // eslint-disable-line no-param-reassign
+    }
+
+    let nextBackgroundImage;
+    if (inputs.backgroundImageId) {
+      nextBackgroundImage = await BackgroundImage.qm.getOneById(inputs.backgroundImageId, {
+        projectId: project.id,
+      });
+
+      if (!nextBackgroundImage) {
+        throw Errors.BACKGROUND_IMAGE_NOT_FOUND;
+      }
+
+      delete inputs.backgroundImageId; // eslint-disable-line no-param-reassign
+    }
+
+    if (!_.isUndefined(inputs.isFavorite)) {
+      if (currentUser.role !== User.Roles.ADMIN || project.ownerProjectManagerId) {
+        if (!projectManager) {
+          const boardMembershipsTotal =
+            await sails.helpers.projects.getBoardMembershipsTotalByIdAndUserId(
+              project.id,
+              currentUser.id,
+            );
+
+          if (boardMembershipsTotal === 0) {
+            throw Errors.PROJECT_NOT_FOUND; // Forbidden
+          }
+        }
+      }
+    }
+
+    const values = _.pick(inputs, [
+      'ownerProjectManagerId',
+      'backgroundImageId',
+      'name',
+      'description',
+      'backgroundType',
+      'backgroundGradient',
+      'isHidden',
+      'isFavorite',
+    ]);
+
+    project = await sails.helpers.projects.updateOne
+      .with({
+        record: project,
+        values: {
+          ...values,
+          ownerProjectManager: nextOwnerProjectManager,
+          backgroundImage: nextBackgroundImage,
+        },
+        actorUser: currentUser,
+        request: this.req,
+      })
+      .intercept(
+        'ownerProjectManagerInValuesMustBeLastManager',
+        () => Errors.OWNER_PROJECT_MANAGER_MUST_BE_LAST_MANAGER,
+      )
+      .intercept(
+        'backgroundImageInValuesMustBePresent',
+        () => Errors.BACKGROUND_IMAGE_MUST_BE_PRESENT,
+      )
+      .intercept(
+        'backgroundGradientInValuesMustBePresent',
+        () => Errors.BACKGROUND_GRADIENT_MUST_BE_PRESENT,
+      )
+      .intercept(
+        'alreadyHasOwnerProjectManager',
+        () => Errors.PROJECT_ALREADY_HAS_OWNER_PROJECT_MANAGER,
+      );
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;