feat: Version 2

Closes #627, closes #1047

server/api/helpers/projects/create-one.js

@@ -1,3 +1,8 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
 module.exports = {
   inputs: {
     values: {
@@ -16,27 +21,34 @@ module.exports = {
   async fn(inputs) {
     const { values } = inputs;
 
-    const project = await Project.create({ ...values }).fetch();
+    const { project, projectManager } = await Project.qm.createOne(values, {
+      user: inputs.actorUser,
+    });
 
-    const projectManager = await ProjectManager.create({
-      projectId: project.id,
-      userId: inputs.actorUser.id,
-    }).fetch();
+    const scoper = sails.helpers.projects.makeScoper.with({
+      record: project,
+    });
 
-    sails.sockets.broadcast(
-      `user:${projectManager.userId}`,
-      'projectCreate',
-      {
-        item: project,
-      },
-      inputs.request,
-    );
+    scoper.projectManagerUserIds = [projectManager.userId];
+    const userIdsWithFullProjectVisibility = await scoper.getUserIdsWithFullProjectVisibility();
+
+    userIdsWithFullProjectVisibility.forEach((userId) => {
+      // TODO: send projectManager in included
+      sails.sockets.broadcast(
+        `user:${userId}`,
+        'projectCreate',
+        {
+          item: project,
+        },
+        inputs.request,
+      );
+    });
 
     sails.helpers.utils.sendWebhooks.with({
       event: 'projectCreate',
-      data: {
+      buildData: () => ({
         item: project,
-      },
+      }),
       user: inputs.actorUser,
     });
 

server/api/helpers/projects/delete-one.js

@@ -1,3 +1,8 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
 module.exports = {
   inputs: {
     record: {
@@ -13,25 +18,29 @@ module.exports = {
     },
   },
 
-  async fn(inputs) {
-    const projectManagers = await ProjectManager.destroy({
-      projectId: inputs.record.id,
-    }).fetch();
+  exits: {
+    mustNotHaveBoards: {},
+  },
 
-    const project = await Project.archiveOne(inputs.record.id);
+  async fn(inputs) {
+    const boardsTotal = await sails.helpers.projects.getBoardsTotalById(inputs.record.id);
+
+    if (boardsTotal > 0) {
+      throw 'mustNotHaveBoards';
+    }
+
+    const { projectManagers } = await sails.helpers.projects.deleteRelated(inputs.record);
+    const project = await Project.qm.deleteOne(inputs.record.id);
 
     if (project) {
-      const projectManagerUserIds = sails.helpers.utils.mapRecords(projectManagers, 'userId');
+      const scoper = sails.helpers.projects.makeScoper.with({
+        record: project,
+      });
 
-      const boardIds = await sails.helpers.projects.getBoardIds(project.id);
-      const boardRooms = boardIds.map((boardId) => `board:${boardId}`);
-
-      const boardMemberUserIds = await sails.helpers.boards.getMemberUserIds(boardIds);
-      const projectRelatedUserIds = _.union(projectManagerUserIds, boardMemberUserIds);
+      scoper.projectManagerUserIds = sails.helpers.utils.mapRecords(projectManagers, 'userId');
+      const projectRelatedUserIds = await scoper.getProjectRelatedUserIds();
 
       projectRelatedUserIds.forEach((userId) => {
-        sails.sockets.removeRoomMembersFromRooms(`@user:${userId}`, boardRooms);
-
         sails.sockets.broadcast(
           `user:${userId}`,
           'projectDelete',
@@ -44,9 +53,9 @@ module.exports = {
 
       sails.helpers.utils.sendWebhooks.with({
         event: 'projectDelete',
-        data: {
+        buildData: () => ({
           item: project,
-        },
+        }),
         user: inputs.actorUser,
       });
     }

server/api/helpers/projects/delete-related.js

@@ -0,0 +1,52 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+module.exports = {
+  inputs: {
+    recordOrRecords: {
+      type: 'ref',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    let projectIdOrIds;
+    if (_.isPlainObject(inputs.recordOrRecords)) {
+      ({
+        recordOrRecords: { id: projectIdOrIds },
+      } = inputs);
+    } else if (_.every(inputs.recordOrRecords, _.isPlainObject)) {
+      projectIdOrIds = sails.helpers.utils.mapRecords(inputs.recordOrRecords);
+    }
+
+    await ProjectFavorite.qm.delete({
+      projectId: projectIdOrIds,
+    });
+
+    const projectManagers = await ProjectManager.qm.delete({
+      projectId: projectIdOrIds,
+    });
+
+    const backgroundImages = await BackgroundImage.qm.delete({
+      projectId: projectIdOrIds,
+    });
+
+    sails.helpers.backgroundImages.removeRelatedFiles(backgroundImages);
+
+    const baseCustomFieldGroups = await BaseCustomFieldGroup.qm.delete({
+      projectId: projectIdOrIds,
+    });
+
+    await sails.helpers.baseCustomFieldGroups.deleteRelated(baseCustomFieldGroups);
+
+    const boards = await Board.qm.delete({
+      projectId: projectIdOrIds,
+    });
+
+    await sails.helpers.boards.deleteRelated(boards);
+
+    return { projectManagers };
+  },
+};

server/api/helpers/projects/get-board-ids-by-id.js

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    const boards = await Board.qm.getByProjectId(inputs.id);
+
+    return sails.helpers.utils.mapRecords(boards);
+  },
+};

server/api/helpers/projects/get-board-ids.js

@@ -1,17 +0,0 @@
-const idOrIdsValidator = (value) => _.isString(value) || _.every(value, _.isString);
-
-module.exports = {
-  inputs: {
-    idOrIds: {
-      type: 'json',
-      custom: idOrIdsValidator,
-      required: true,
-    },
-  },
-
-  async fn(inputs) {
-    const boards = await sails.helpers.projects.getBoards(inputs.idOrIds);
-
-    return sails.helpers.utils.mapRecords(boards);
-  },
-};

server/api/helpers/projects/get-board-member-user-ids.js

@@ -1,17 +0,0 @@
-const idOrIdsValidator = (value) => _.isString(value) || _.every(value, _.isString);
-
-module.exports = {
-  inputs: {
-    idOrIds: {
-      type: 'json',
-      custom: idOrIdsValidator,
-      required: true,
-    },
-  },
-
-  async fn(inputs) {
-    const boardIds = await sails.helpers.projects.getBoardIds(inputs.idOrIds);
-
-    return sails.helpers.boards.getMemberUserIds(boardIds);
-  },
-};

server/api/helpers/projects/get-board-memberships-total-by-id-and-user-id.js

@@ -0,0 +1,26 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      required: true,
+    },
+    userId: {
+      type: 'string',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    const boardMemberships = await BoardMembership.qm.getByProjectIdAndUserId(
+      inputs.id,
+      inputs.userId,
+    );
+
+    return boardMemberships.length;
+  },
+};

server/api/helpers/projects/get-boards-total-by-id.js

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    const boards = await Board.qm.getByProjectId(inputs.id);
+
+    return boards.length;
+  },
+};

server/api/helpers/projects/get-boards.js

@@ -1,29 +0,0 @@
-const idOrIdsValidator = (value) => _.isString(value) || _.every(value, _.isString);
-
-module.exports = {
-  inputs: {
-    idOrIds: {
-      type: 'json',
-      custom: idOrIdsValidator,
-      required: true,
-    },
-    exceptBoardIdOrIds: {
-      type: 'json',
-      custom: idOrIdsValidator,
-    },
-  },
-
-  async fn(inputs) {
-    const criteria = {
-      projectId: inputs.idOrIds,
-    };
-
-    if (!_.isUndefined(inputs.exceptBoardIdOrIds)) {
-      criteria.id = {
-        '!=': inputs.exceptBoardIdOrIds,
-      };
-    }
-
-    return sails.helpers.boards.getMany(criteria);
-  },
-};

server/api/helpers/projects/get-lonely-by-ids.js

@@ -0,0 +1,25 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+module.exports = {
+  inputs: {
+    ids: {
+      type: 'json',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    const projectManagers = await ProjectManager.qm.getByProjectIds(inputs.ids);
+
+    const managerProjectIdsSet = new Set(
+      sails.helpers.utils.mapRecords(projectManagers, 'projectId', true),
+    );
+
+    const lonelyProjectIds = inputs.ids.filter((id) => !managerProjectIdsSet.has(id));
+
+    return Project.qm.getByIds(lonelyProjectIds);
+  },
+};

server/api/helpers/projects/get-manager-and-board-member-user-ids.js

@@ -1,18 +0,0 @@
-const idOrIdsValidator = (value) => _.isString(value) || _.every(value, _.isString);
-
-module.exports = {
-  inputs: {
-    idOrIds: {
-      type: 'json',
-      custom: idOrIdsValidator,
-      required: true,
-    },
-  },
-
-  async fn(inputs) {
-    const projectManagerUserIds = await sails.helpers.projects.getManagerUserIds(inputs.idOrIds);
-    const boardMemberUserIds = await sails.helpers.projects.getBoardMemberUserIds(inputs.idOrIds);
-
-    return _.union(projectManagerUserIds, boardMemberUserIds);
-  },
-};

server/api/helpers/projects/get-manager-user-ids.js

@@ -1,17 +1,19 @@
-const idOrIdsValidator = (value) => _.isString(value) || _.every(value, _.isString);
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
 
 module.exports = {
   inputs: {
-    idOrIds: {
-      type: 'json',
-      custom: idOrIdsValidator,
+    id: {
+      type: 'string',
       required: true,
     },
   },
 
   async fn(inputs) {
-    const projectManagers = await sails.helpers.projects.getProjectManagers(inputs.idOrIds);
+    const projectManagers = await ProjectManager.qm.getByProjectId(inputs.id);
 
-    return sails.helpers.utils.mapRecords(projectManagers, 'userId', _.isArray(inputs.idOrIds));
+    return sails.helpers.utils.mapRecords(projectManagers, 'userId');
   },
 };

server/api/helpers/projects/get-many.js

@@ -1,14 +0,0 @@
-const criteriaValidator = (value) => _.isArray(value) || _.isPlainObject(value);
-
-module.exports = {
-  inputs: {
-    criteria: {
-      type: 'json',
-      custom: criteriaValidator,
-    },
-  },
-
-  async fn(inputs) {
-    return Project.find(inputs.criteria).sort('id');
-  },
-};

server/api/helpers/projects/get-project-managers-total-by-id.js

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      required: true,
+    },
+    exceptProjectManagerIdOrIds: {
+      type: 'json',
+    },
+  },
+
+  async fn(inputs) {
+    const projectManagers = await ProjectManager.qm.getByProjectId(inputs.id, {
+      exceptIdOrIds: inputs.exceptProjectManagerIdOrIds,
+    });
+
+    return projectManagers.length;
+  },
+};

server/api/helpers/projects/get-project-managers.js

@@ -1,17 +0,0 @@
-const idOrIdsValidator = (value) => _.isString(value) || _.every(value, _.isString);
-
-module.exports = {
-  inputs: {
-    idOrIds: {
-      type: 'json',
-      custom: idOrIdsValidator,
-      required: true,
-    },
-  },
-
-  async fn(inputs) {
-    return sails.helpers.projectManagers.getMany({
-      projectId: inputs.idOrIds,
-    });
-  },
-};

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

@@ -0,0 +1,209 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+class Scoper {
+  constructor(project, board, { notificationService }) {
+    this.project = project;
+    this.board = board;
+    this.notificationService = notificationService;
+
+    this.adminUserIds = null;
+    this.projectManagerUserIds = null;
+    this.boardMemberships = null;
+
+    this.userIdsWithFullProjectVisibility = null;
+    this.boardMembershipsForWholeProject = null;
+    this.boardMemberUserIdsForWholeProject = null;
+    this.boardMemberUserIds = null;
+
+    this.projectRelatedUserIds = null;
+    this.boardRelatedUserIds = null;
+    this.notificationServiceRelatedUserIds = null;
+  }
+
+  replaceProject(project) {
+    if (this.project && project.id !== this.project.id) {
+      this.projectManagerUserIds = null;
+
+      this.boardMembershipsForWholeProject = null;
+      this.boardMemberUserIdsForWholeProject = null;
+    }
+
+    this.project = project;
+
+    this.userIdsWithFullProjectVisibility = null;
+
+    this.projectRelatedUserIds = null;
+    this.boardRelatedUserIds = null;
+  }
+
+  replaceBoard(board) {
+    if (this.board && board.id !== this.board.id) {
+      this.boardMemberships = null;
+
+      this.boardMemberUserIds = null;
+
+      this.boardRelatedUserIds = null;
+    }
+
+    this.board = board;
+  }
+
+  clone() {
+    return _.cloneDeep(this);
+  }
+
+  cloneForProject(project) {
+    const scoper = this.clone();
+    scoper.replaceProject(project);
+
+    return scoper;
+  }
+
+  cloneForBoard(board) {
+    const scoper = this.clone();
+    scoper.replaceBoard(board);
+
+    return scoper;
+  }
+
+  async getAdminUserIds() {
+    if (!this.adminUserIds) {
+      this.adminUserIds = await sails.helpers.users.getAllIds(User.Roles.ADMIN);
+    }
+
+    return this.adminUserIds;
+  }
+
+  async getProjectManagerUserIds() {
+    if (!this.projectManagerUserIds) {
+      this.projectManagerUserIds = await sails.helpers.projects.getManagerUserIds(this.project.id);
+    }
+
+    return this.projectManagerUserIds;
+  }
+
+  async getBoardMemberships() {
+    if (!this.boardMemberships) {
+      this.boardMemberships = await BoardMembership.qm.getByBoardId(this.board.id);
+    }
+
+    return this.boardMemberships;
+  }
+
+  async getUserIdsWithFullProjectVisibility() {
+    if (!this.userIdsWithFullProjectVisibility) {
+      const projectManagerUserIds = await this.getProjectManagerUserIds();
+
+      if (this.project.ownerProjectManagerId) {
+        this.userIdsWithFullProjectVisibility = projectManagerUserIds;
+      } else {
+        const adminUserIds = await this.getAdminUserIds();
+
+        this.userIdsWithFullProjectVisibility = _.union(adminUserIds, projectManagerUserIds);
+      }
+    }
+
+    return this.userIdsWithFullProjectVisibility;
+  }
+
+  async getBoardMembershipsForWholeProject() {
+    if (!this.boardMembershipsForWholeProject) {
+      this.boardMembershipsForWholeProject = await BoardMembership.qm.getByProjectId(
+        this.project.id,
+      );
+    }
+
+    return this.boardMembershipsForWholeProject;
+  }
+
+  async getBoardMemberUserIdsForWholeProject() {
+    if (!this.boardMemberUserIdsForWholeProject) {
+      const boardMembershipsForWholeProject = await this.getBoardMembershipsForWholeProject();
+
+      this.boardMemberUserIdsForWholeProject = sails.helpers.utils.mapRecords(
+        boardMembershipsForWholeProject,
+        'userId',
+        true,
+      );
+    }
+
+    return this.boardMemberUserIdsForWholeProject;
+  }
+
+  async getBoardMemberUserIds() {
+    if (!this.boardMemberUserIds) {
+      const boardMemberships = await this.getBoardMemberships();
+
+      this.boardMemberUserIds = sails.helpers.utils.mapRecords(boardMemberships, 'userId');
+    }
+
+    return this.boardMemberUserIds;
+  }
+
+  async getProjectRelatedUserIds() {
+    if (!this.projectRelatedUserIds) {
+      const userIdsWithFullProjectVisibility = await this.getUserIdsWithFullProjectVisibility();
+      const boardMemberUserIdsForWholeProject = await this.getBoardMemberUserIdsForWholeProject();
+
+      this.projectRelatedUserIds = _.union(
+        userIdsWithFullProjectVisibility,
+        boardMemberUserIdsForWholeProject,
+      );
+    }
+
+    return this.projectRelatedUserIds;
+  }
+
+  async getBoardRelatedUserIds() {
+    if (!this.boardRelatedUserIds) {
+      const userIdsWithFullProjectVisibility = await this.getUserIdsWithFullProjectVisibility();
+      const boardMemberUserIds = await this.getBoardMemberUserIds();
+
+      this.boardRelatedUserIds = _.union(userIdsWithFullProjectVisibility, boardMemberUserIds);
+    }
+
+    return this.boardRelatedUserIds;
+  }
+
+  async getNotificationServiceRelatedUserIds() {
+    if (!this.notificationServiceRelatedUserIds) {
+      this.notificationServiceRelatedUserIds = await this.getProjectManagerUserIds();
+    }
+
+    return this.notificationServiceRelatedUserIds;
+  }
+}
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    record: {
+      type: 'ref',
+      required: true,
+    },
+    board: {
+      type: 'ref',
+    },
+    notificationService: {
+      type: 'ref',
+    },
+  },
+
+  exits: {
+    boardMustBePresent: {},
+  },
+
+  fn(inputs) {
+    if (inputs.notificationService && !inputs.board) {
+      throw 'boardMustBePresent';
+    }
+
+    return new Scoper(inputs.record, inputs.board, {
+      notificationService: inputs.notificationService,
+    });
+  },
+};

server/api/helpers/projects/process-uploaded-background-image-file.js

@@ -1,94 +0,0 @@
-const { rimraf } = require('rimraf');
-const { v4: uuid } = require('uuid');
-const sharp = require('sharp');
-
-module.exports = {
-  inputs: {
-    file: {
-      type: 'json',
-      required: true,
-    },
-  },
-
-  exits: {
-    fileIsNotImage: {},
-  },
-
-  async fn(inputs) {
-    let image = sharp(inputs.file.fd, {
-      animated: true,
-    });
-
-    let metadata;
-    try {
-      metadata = await image.metadata();
-    } catch (error) {
-      throw 'fileIsNotImage';
-    }
-
-    if (['svg', 'pdf'].includes(metadata.format)) {
-      throw 'fileIsNotImage';
-    }
-
-    const fileManager = sails.hooks['file-manager'].getInstance();
-
-    const dirname = uuid();
-    const dirPathSegment = `${sails.config.custom.projectBackgroundImagesPathSegment}/${dirname}`;
-
-    let { width, pageHeight: height = metadata.height } = metadata;
-    if (metadata.orientation && metadata.orientation > 4) {
-      [image, width, height] = [image.rotate(), height, width];
-    }
-
-    const extension = metadata.format === 'jpeg' ? 'jpg' : metadata.format;
-
-    try {
-      const originalBuffer = await image.toBuffer();
-
-      await fileManager.save(
-        `${dirPathSegment}/original.${extension}`,
-        originalBuffer,
-        inputs.file.type,
-      );
-
-      const cover336Buffer = await image
-        .resize(
-          336,
-          200,
-          width < 336 || height < 200
-            ? {
-                kernel: sharp.kernel.nearest,
-              }
-            : undefined,
-        )
-        .toBuffer();
-
-      await fileManager.save(
-        `${dirPathSegment}/cover-336.${extension}`,
-        cover336Buffer,
-        inputs.file.type,
-      );
-    } catch (error1) {
-      console.warn(error1.stack); // eslint-disable-line no-console
-
-      try {
-        fileManager.deleteDir(dirPathSegment);
-      } catch (error2) {
-        console.warn(error2.stack); // eslint-disable-line no-console
-      }
-
-      throw 'fileIsNotImage';
-    }
-
-    try {
-      await rimraf(inputs.file.fd);
-    } catch (error) {
-      console.warn(error.stack); // eslint-disable-line no-console
-    }
-
-    return {
-      dirname,
-      extension,
-    };
-  },
-};

server/api/helpers/projects/update-one.js

@@ -1,18 +1,7 @@
-const valuesValidator = (value) => {
-  if (!_.isPlainObject(value)) {
-    return false;
-  }
-
-  if (!_.isNil(value.background) && !_.isPlainObject(value.background)) {
-    return false;
-  }
-
-  if (!_.isNil(value.backgroundImage) && !_.isPlainObject(value.backgroundImage)) {
-    return false;
-  }
-
-  return true;
-};
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
 
 module.exports = {
   inputs: {
@@ -22,81 +11,155 @@ module.exports = {
     },
     values: {
       type: 'json',
-      custom: valuesValidator,
       required: true,
     },
     actorUser: {
       type: 'ref',
       required: true,
     },
+    scoper: {
+      type: 'ref',
+    },
     request: {
       type: 'ref',
     },
   },
 
   exits: {
-    backgroundImageInValuesMustNotBeNull: {},
+    ownerProjectManagerInValuesMustBeLastManager: {},
+    backgroundImageInValuesMustBePresent: {},
+    backgroundGradientInValuesMustBePresent: {},
+    alreadyHasOwnerProjectManager: {},
   },
 
+  // TODO: use normalizeValues
   async fn(inputs) {
-    const { values } = inputs;
+    const { isFavorite, ...values } = inputs.values;
 
     if (values.backgroundImage) {
-      values.background = {
-        type: 'image',
-      };
-    } else if (
-      _.isNull(values.backgroundImage) &&
-      inputs.record.background &&
-      inputs.record.background.type === 'image'
-    ) {
-      values.background = null;
+      values.backgroundImageId = values.backgroundImage.id;
+    }
+
+    if (values.ownerProjectManager) {
+      if (inputs.record.ownerProjectManagerId) {
+        if (values.ownerProjectManager.id === inputs.record.ownerProjectManagerId) {
+          delete values.ownerProjectManager;
+        } else {
+          throw 'alreadyHasOwnerProjectManager';
+        }
+      } else {
+        const projectManagersLeft = await sails.helpers.projects.getProjectManagersTotalById(
+          inputs.record.id,
+          values.ownerProjectManager.id,
+        );
+
+        if (projectManagersLeft > 0) {
+          throw 'ownerProjectManagerInValuesMustBeLastManager';
+        }
+
+        values.ownerProjectManagerId = values.ownerProjectManager.id;
+      }
+    }
+
+    const backgroundType = _.isUndefined(values.backgroundType)
+      ? inputs.record.backgroundType
+      : values.backgroundType;
+
+    if (_.isNull(backgroundType)) {
+      Object.assign(values, {
+        backgroundImageId: null,
+        backgroundGradient: null,
+      });
+    } else if (backgroundType === Project.BackgroundTypes.GRADIENT) {
+      const backgroundGradient = _.isUndefined(values.backgroundGradient)
+        ? inputs.record.backgroundGradient
+        : values.backgroundGradient;
+
+      if (!backgroundGradient) {
+        throw 'backgroundGradientInValuesMustBePresent';
+      }
+
+      values.backgroundImageId = null;
+    } else if (backgroundType === Project.BackgroundTypes.IMAGE) {
+      const backgroundImageId = _.isUndefined(values.backgroundImageId)
+        ? inputs.record.backgroundImageId
+        : values.backgroundImageId;
+
+      if (!backgroundImageId) {
+        throw 'backgroundImageInValuesMustBePresent';
+      }
+
+      values.backgroundGradient = null;
     }
 
     let project;
-    if (values.background && values.background.type === 'image') {
-      if (_.isNull(values.backgroundImage)) {
-        throw 'backgroundImageInValuesMustNotBeNull';
+    if (_.isEmpty(values)) {
+      project = inputs.record;
+    } else {
+      project = await Project.qm.updateOne(inputs.record.id, values);
+
+      if (!project) {
+        return project;
       }
 
-      if (_.isUndefined(values.backgroundImage)) {
-        project = await Project.updateOne({
-          id: inputs.record.id,
-          backgroundImage: {
-            '!=': null,
-          },
-        }).set({ ...values });
+      const {
+        scoper = sails.helpers.projects.makeScoper.with({
+          record: project,
+        }),
+      } = inputs;
 
-        if (!project) {
-          delete values.background;
-        }
-      }
-    }
+      const projectRelatedUserIds = await scoper.getProjectRelatedUserIds();
 
-    if (!project) {
-      project = await Project.updateOne(inputs.record.id).set({ ...values });
-    }
+      if (values.ownerProjectManager) {
+        const boardIds = await sails.helpers.projects.getBoardIdsById(project.id);
 
-    if (project) {
-      if (
-        inputs.record.backgroundImage &&
-        (!project.backgroundImage ||
-          project.backgroundImage.dirname !== inputs.record.backgroundImage.dirname)
-      ) {
-        const fileManager = sails.hooks['file-manager'].getInstance();
+        const prevScoper = scoper.cloneForProject(inputs.record);
+        const adminUserIds = await prevScoper.getAdminUserIds();
+        const projectManagerUserIds = await prevScoper.getProjectManagerUserIds();
+        const boardMemberships = await prevScoper.getBoardMembershipsForWholeProject();
 
-        try {
-          await fileManager.deleteDir(
-            `${sails.config.custom.projectBackgroundImagesPathSegment}/${inputs.record.backgroundImage.dirname}`,
+        const nonProjectManagerAdminUserIds = _.difference(adminUserIds, projectManagerUserIds);
+
+        const boardMemberUserIdsByBoardId = boardMemberships.reduce(
+          (result, boardMembership) => ({
+            ...result,
+            [boardMembership.boardId]: [
+              ...(result[boardMembership.boardId] || []),
+              boardMembership.userId,
+            ],
+          }),
+          {},
+        );
+
+        boardIds.forEach((boardId) => {
+          const missingUserIds = _.difference(
+            nonProjectManagerAdminUserIds,
+            boardMemberUserIdsByBoardId[boardId] || [],
           );
-        } catch (error) {
-          console.warn(error.stack); // eslint-disable-line no-console
-        }
-      }
 
-      const projectRelatedUserIds = await sails.helpers.projects.getManagerAndBoardMemberUserIds(
-        project.id,
-      );
+          missingUserIds.forEach((userId) => {
+            sails.sockets.removeRoomMembersFromRooms(`@user:${userId}`, `board:${boardId}`);
+          });
+        });
+
+        const projectRelatedUserIdsSet = new Set(projectRelatedUserIds);
+        const prevProjectRelatedUserIds = await prevScoper.getProjectRelatedUserIds();
+
+        const missingProjectRelatedUserIds = prevProjectRelatedUserIds.filter(
+          (userId) => !projectRelatedUserIdsSet.has(userId),
+        );
+
+        missingProjectRelatedUserIds.forEach((userId) => {
+          sails.sockets.broadcast(
+            `user:${userId}`,
+            'projectUpdate',
+            {
+              item: _.pick(project, ['id', 'ownerProjectManagerId']),
+            },
+            inputs.request,
+          );
+        });
+      }
 
       projectRelatedUserIds.forEach((userId) => {
         sails.sockets.broadcast(
@@ -111,16 +174,57 @@ module.exports = {
 
       sails.helpers.utils.sendWebhooks.with({
         event: 'projectUpdate',
-        data: {
+        buildData: () => ({
           item: project,
-        },
-        prevData: {
+        }),
+        buildPrevData: () => ({
           item: inputs.record,
-        },
+        }),
         user: inputs.actorUser,
       });
     }
 
+    if (!_.isUndefined(isFavorite)) {
+      const wasFavorite = await sails.helpers.users.isProjectFavorite(
+        inputs.actorUser.id,
+        project.id,
+      );
+
+      if (isFavorite !== wasFavorite) {
+        if (isFavorite) {
+          try {
+            await ProjectFavorite.qm.createOne({
+              projectId: project.id,
+              userId: inputs.actorUser.id,
+            });
+          } catch (error) {
+            if (error.code !== 'E_UNIQUE') {
+              throw error;
+            }
+          }
+        } else {
+          await ProjectFavorite.qm.deleteOne({
+            projectId: project.id,
+            userId: inputs.actorUser.id,
+          });
+        }
+
+        sails.sockets.broadcast(
+          `user:${inputs.actorUser.id}`,
+          'projectUpdate',
+          {
+            item: {
+              isFavorite,
+              id: project.id,
+            },
+          },
+          inputs.request,
+        );
+
+        // TODO: send webhooks
+      }
+    }
+
     return project;
   },
 };