Prepare for collection board type, refactoring, update dependencies

server/api/controllers/cards/create.js

@@ -1,21 +1,33 @@
 const moment = require('moment');
 
 const Errors = {
+  BOARD_NOT_FOUND: {
+    boardNotFound: 'Board not found',
+  },
   LIST_NOT_FOUND: {
     listNotFound: 'List not found',
   },
+  LIST_MUST_BE_PRESENT: {
+    listMustBePresent: 'List must be present',
+  },
+  POSITION_MUST_BE_PRESENT: {
+    positionMustBePresent: 'Position must be present',
+  },
 };
 
 module.exports = {
   inputs: {
-    listId: {
+    boardId: {
       type: 'string',
       regex: /^[0-9]+$/,
       required: true,
     },
+    listId: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+    },
     position: {
       type: 'number',
-      required: true,
     },
     name: {
       type: 'string',
@@ -32,26 +44,49 @@ module.exports = {
     },
     timer: {
       type: 'json',
-      custom: (value) =>
-        _.isPlainObject(value) &&
-        _.size(value) === 2 &&
-        (_.isNull(value.startedAt) || moment(value.startedAt, moment.ISO_8601, true).isValid()) &&
-        _.isFinite(value.total),
+      custom: (value) => {
+        if (!_.isPlainObject(value) || _.size(value) !== 2) {
+          return false;
+        }
+
+        if (
+          !_.isNull(value.startedAt) &&
+          _.isString(value.startedAt) &&
+          !moment(value.startedAt, moment.ISO_8601, true).isValid()
+        ) {
+          return false;
+        }
+
+        if (!_.isFinite(value.total)) {
+          return false;
+        }
+
+        return true;
+      },
     },
   },
 
   exits: {
+    boardNotFound: {
+      responseType: 'notFound',
+    },
     listNotFound: {
       responseType: 'notFound',
     },
+    listMustBePresent: {
+      responseType: 'unprocessableEntity',
+    },
+    positionMustBePresent: {
+      responseType: 'unprocessableEntity',
+    },
   },
 
   async fn(inputs, exits) {
     const { currentUser } = this.req;
 
-    const { list, project } = await sails.helpers
-      .getListToProjectPath(inputs.listId)
-      .intercept('pathNotFound', () => Errors.LIST_NOT_FOUND);
+    const { board, project } = await sails.helpers
+      .getBoardToProjectPath(inputs.boardId)
+      .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
     const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
       project.id,
@@ -62,9 +97,24 @@ module.exports = {
       throw Errors.LIST_NOT_FOUND; // Forbidden
     }
 
+    let list;
+    if (!_.isUndefined(inputs.listId)) {
+      list = await List.findOne({
+        id: inputs.listId,
+        boardId: board.id,
+      });
+
+      if (!list) {
+        throw Errors.LIST_NOT_FOUND;
+      }
+    }
+
     const values = _.pick(inputs, ['position', 'name', 'description', 'dueDate', 'timer']);
 
-    const card = await sails.helpers.createCard(list, values, currentUser, this.req);
+    const card = await sails.helpers
+      .createCard(board, list, values, currentUser, this.req)
+      .intercept('listMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
+      .intercept('positionMustBeInValues', () => Errors.POSITION_MUST_BE_PRESENT);
 
     return exits.success({
       item: card,

server/api/controllers/cards/index.js

@@ -0,0 +1,79 @@
+const Errors = {
+  BOARD_NOT_FOUND: {
+    boardNotFound: 'Board not found',
+  },
+};
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+    beforeId: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+    },
+  },
+
+  exits: {
+    boardNotFound: {
+      responseType: 'notFound',
+    },
+  },
+
+  async fn(inputs, exits) {
+    const { currentUser } = this.req;
+
+    const { board, project } = await sails.helpers
+      .getBoardToProjectPath(inputs.boardId)
+      .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
+
+    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
+      project.id,
+      currentUser.id,
+    );
+
+    if (!isUserMemberForProject) {
+      throw Errors.BOARD_NOT_FOUND; // Forbidden
+    }
+
+    const cards = await sails.helpers.getCardsForBoard(board, inputs.beforeId);
+    const cardIds = sails.helpers.mapRecords(cards);
+
+    const cardSubscriptions = await sails.helpers.getSubscriptionsByUserForCard(
+      cardIds,
+      currentUser.id,
+    );
+
+    const cardMemberships = await sails.helpers.getMembershipsForCard(cardIds);
+    const cardLabels = await sails.helpers.getCardLabelsForCard(cardIds);
+
+    const tasks = await sails.helpers.getTasksForCard(cardIds);
+    const attachments = await sails.helpers.getAttachmentsForCard(cardIds);
+
+    const isSubscribedByCardId = cardSubscriptions.reduce(
+      (result, cardSubscription) => ({
+        ...result,
+        [cardSubscription.cardId]: true,
+      }),
+      {},
+    );
+
+    cards.map((card) => ({
+      ...card,
+      isSubscribed: isSubscribedByCardId[card.id] || false,
+    }));
+
+    return exits.success({
+      items: cards,
+      included: {
+        cardMemberships,
+        cardLabels,
+        tasks,
+        attachments,
+      },
+    });
+  },
+};

server/api/controllers/cards/update.js

@@ -4,9 +4,18 @@ const Errors = {
   CARD_NOT_FOUND: {
     cardNotFound: 'Card not found',
   },
+  BOARD_NOT_FOUND: {
+    boardNotFound: 'Board not found',
+  },
   LIST_NOT_FOUND: {
     listNotFound: 'List not found',
   },
+  LIST_MUST_BE_PRESENT: {
+    listMustBePresent: 'List must be present',
+  },
+  POSITION_MUST_BE_PRESENT: {
+    positionMustBePresent: 'Position must be present',
+  },
 };
 
 module.exports = {
@@ -16,11 +25,11 @@ module.exports = {
       regex: /^[0-9]+$/,
       required: true,
     },
-    listId: {
+    boardId: {
       type: 'string',
       regex: /^[0-9]+$/,
     },
-    boardId: {
+    listId: {
       type: 'string',
       regex: /^[0-9]+$/,
     },
@@ -48,11 +57,25 @@ module.exports = {
     },
     timer: {
       type: 'json',
-      custom: (value) =>
-        _.isPlainObject(value) &&
-        _.size(value) === 2 &&
-        (_.isNull(value.startedAt) || moment(value.startedAt, moment.ISO_8601, true).isValid()) &&
-        _.isFinite(value.total),
+      custom: (value) => {
+        if (!_.isPlainObject(value) || _.size(value) !== 2) {
+          return false;
+        }
+
+        if (
+          !_.isNull(value.startedAt) &&
+          _.isString(value.startedAt) &&
+          !moment(value.startedAt, moment.ISO_8601, true).isValid()
+        ) {
+          return false;
+        }
+
+        if (!_.isFinite(value.total)) {
+          return false;
+        }
+
+        return true;
+      },
     },
     isSubscribed: {
       type: 'boolean',
@@ -63,9 +86,18 @@ module.exports = {
     cardNotFound: {
       responseType: 'notFound',
     },
+    boardNotFound: {
+      responseType: 'notFound',
+    },
     listNotFound: {
       responseType: 'notFound',
     },
+    listMustBePresent: {
+      responseType: 'unprocessableEntity',
+    },
+    positionMustBePresent: {
+      responseType: 'unprocessableEntity',
+    },
   },
 
   async fn(inputs, exits) {
@@ -87,22 +119,11 @@ module.exports = {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
-    let toList;
     let toBoard;
-
-    if (!_.isUndefined(inputs.listId) && inputs.listId !== list.id) {
-      toList = await List.findOne({
-        id: inputs.listId,
-        boardId: inputs.boardId || card.boardId,
-      });
-
-      if (!toList) {
-        throw Errors.LIST_NOT_FOUND;
-      }
-
+    if (!_.isUndefined(inputs.boardId)) {
       ({ board: toBoard, project } = await sails.helpers
-        .getListToProjectPath(toList.id)
-        .intercept('pathNotFound', () => Errors.LIST_NOT_FOUND));
+        .getBoardToProjectPath(inputs.boardId)
+        .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND));
 
       isUserMemberForProject = await sails.helpers.isUserMemberForProject(
         project.id,
@@ -110,6 +131,18 @@ module.exports = {
       );
 
       if (!isUserMemberForProject) {
+        throw Errors.BOARD_NOT_FOUND; // Forbidden
+      }
+    }
+
+    let toList;
+    if (!_.isUndefined(inputs.listId)) {
+      toList = await List.findOne({
+        id: inputs.listId,
+        boardId: (toBoard || board).id,
+      });
+
+      if (!toList) {
         throw Errors.LIST_NOT_FOUND; // Forbidden
       }
     }
@@ -124,16 +157,10 @@ module.exports = {
       'isSubscribed',
     ]);
 
-    card = await sails.helpers.updateCard(
-      card,
-      values,
-      toList,
-      toBoard,
-      list,
-      board,
-      currentUser,
-      this.req,
-    );
+    card = await sails.helpers
+      .updateCard(card, toBoard, toList, values, board, list, currentUser, this.req)
+      .intercept('toListMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
+      .intercept('positionMustBeInValues', () => Errors.POSITION_MUST_BE_PRESENT);
 
     if (!card) {
       throw Errors.CARD_NOT_FOUND;