Merge branch 'master' into feat/el-notification-translations

server/api/controllers/tasks/create.js

@@ -12,6 +12,12 @@ const Errors = {
   TASK_LIST_NOT_FOUND: {
     taskListNotFound: 'Task list not found',
   },
+  LINKED_CARD_NOT_FOUND: {
+    linkedCardNotFound: 'Linked card not found',
+  },
+  LINKED_CARD_OR_NAME_MUST_BE_PRESENT: {
+    linkedCardOrNameMustBePresent: 'Linked card or name must be present',
+  },
 };
 
 module.exports = {
@@ -20,6 +26,7 @@ module.exports = {
       ...idInput,
       required: true,
     },
+    linkedCardId: idInput,
     position: {
       type: 'number',
       min: 0,
@@ -27,8 +34,9 @@ module.exports = {
     },
     name: {
       type: 'string',
+      isNotEmptyString: true,
       maxLength: 1024,
-      required: true,
+      allowNull: true,
     },
     isCompleted: {
       type: 'boolean',
@@ -42,6 +50,12 @@ module.exports = {
     taskListNotFound: {
       responseType: 'notFound',
     },
+    linkedCardNotFound: {
+      responseType: 'notFound',
+    },
+    linkedCardOrNameMustBePresent: {
+      responseType: 'unprocessableEntity',
+    },
   },
 
   async fn(inputs) {
@@ -51,7 +65,7 @@ module.exports = {
       .getPathToProjectById(inputs.taskListId)
       .intercept('pathNotFound', () => Errors.TASK_LIST_NOT_FOUND);
 
-    const boardMembership = await BoardMembership.qm.getOneByBoardIdAndUserId(
+    let boardMembership = await BoardMembership.qm.getOneByBoardIdAndUserId(
       board.id,
       currentUser.id,
     );
@@ -64,20 +78,53 @@ module.exports = {
       throw Errors.NOT_ENOUGH_RIGHTS;
     }
 
+    let linkedCard;
+    if (!_.isUndefined(inputs.linkedCardId)) {
+      const path = await sails.helpers.cards
+        .getPathToProjectById(inputs.linkedCardId)
+        .intercept('pathNotFound', () => Errors.LINKED_CARD_NOT_FOUND);
+
+      ({ card: linkedCard } = path);
+
+      if (currentUser.role !== User.Roles.ADMIN || path.project.ownerProjectManagerId) {
+        const isProjectManager = await sails.helpers.users.isProjectManager(
+          currentUser.id,
+          path.project.id,
+        );
+
+        if (!isProjectManager) {
+          boardMembership = await BoardMembership.qm.getOneByBoardIdAndUserId(
+            linkedCard.boardId,
+            currentUser.id,
+          );
+
+          if (!boardMembership) {
+            throw Errors.LINKED_CARD_NOT_FOUND; // Forbidden
+          }
+        }
+      }
+    }
+
     const values = _.pick(inputs, ['position', 'name', 'isCompleted']);
 
-    const task = await sails.helpers.tasks.createOne.with({
-      project,
-      board,
-      list,
-      card,
-      values: {
-        ...values,
-        taskList,
-      },
-      actorUser: currentUser,
-      request: this.req,
-    });
+    const task = await sails.helpers.tasks.createOne
+      .with({
+        project,
+        board,
+        list,
+        card,
+        values: {
+          ...values,
+          taskList,
+          linkedCard,
+        },
+        actorUser: currentUser,
+        request: this.req,
+      })
+      .intercept(
+        'linkedCardOrNameMustBeInValues',
+        () => Errors.LINKED_CARD_OR_NAME_MUST_BE_PRESENT,
+      );
 
     return {
       item: task,

server/api/controllers/tasks/update.js

@@ -83,6 +83,14 @@ module.exports = {
       throw Errors.NOT_ENOUGH_RIGHTS;
     }
 
+    if (task.linkedCardId) {
+      const availableInputKeys = ['id', 'taskListId', 'position'];
+
+      if (_.difference(Object.keys(inputs), availableInputKeys).length > 0) {
+        throw Errors.NOT_ENOUGH_RIGHTS;
+      }
+    }
+
     let nextTaskList;
     if (!_.isUndefined(inputs.taskListId)) {
       nextTaskList = await TaskList.qm.getOneById(inputs.taskListId, {

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

@@ -67,7 +67,7 @@ module.exports = {
       delete values.position;
     }
 
-    if (values.list.type === List.Types.CLOSED) {
+    if (List.TYPE_STATE_BY_TYPE[values.list.type] === List.TypeStates.CLOSED) {
       values.isClosed = true;
     }
 

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

@@ -39,6 +39,15 @@ module.exports = {
 
     await sails.helpers.taskLists.deleteRelated(taskLists);
 
+    await Task.qm.update(
+      {
+        linkedCardId: cardIdOrIds,
+      },
+      {
+        linkedCardId: null,
+      },
+    );
+
     const { fileReferences } = await Attachment.qm.delete({
       cardId: cardIdOrIds,
     });

server/api/helpers/cards/duplicate-one.js

@@ -147,7 +147,7 @@ module.exports = {
     const nextTaskLists = await TaskList.qm.create(nextTaskListsValues);
 
     const nextTasksValues = tasks.map((task) => ({
-      ..._.pick(task, ['assigneeUserId', 'position', 'name', 'isCompleted']),
+      ..._.pick(task, ['linkedCardId', 'assigneeUserId', 'position', 'name', 'isCompleted']),
       taskListId: nextTaskListIdByTaskListId[task.taskListId],
     }));
 
@@ -172,9 +172,9 @@ module.exports = {
       const nextCoverAttachmentId = nextAttachmentIdByAttachmentId[inputs.record.coverAttachmentId];
 
       if (nextCoverAttachmentId) {
-        card = await Card.qm.updateOne(card.id, {
+        ({ card } = await Card.qm.updateOne(card.id, {
           coverAttachmentId: nextCoverAttachmentId,
-        });
+        }));
       }
     }
 

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

@@ -386,18 +386,23 @@ module.exports = {
           values.prevListId = null;
         }
 
+        const typeState = List.TYPE_STATE_BY_TYPE[values.list.type];
+
         if (inputs.record.isClosed) {
-          if (values.list.type === List.Types.ACTIVE) {
+          if (typeState === List.TypeStates.OPENED) {
             values.isClosed = false;
           }
-        } else if (values.list.type === List.Types.CLOSED) {
+        } else if (typeState === List.TypeStates.CLOSED) {
           values.isClosed = true;
         }
 
         values.listChangedAt = new Date().toISOString();
       }
 
-      card = await Card.qm.updateOne(inputs.record.id, values);
+      const updateResult = await Card.qm.updateOne(inputs.record.id, values);
+
+      ({ card } = updateResult);
+      const { tasks } = updateResult;
 
       if (!card) {
         return card;
@@ -491,6 +496,32 @@ module.exports = {
         }
       }
 
+      if (tasks) {
+        const taskListIds = sails.helpers.utils.mapRecords(tasks, 'taskListId', true);
+        const taskLists = await TaskList.qm.getByIds(taskListIds);
+        const taskListById = _.keyBy(taskLists, 'id');
+
+        const cardIds = sails.helpers.utils.mapRecords(taskLists, 'cardId', true);
+        const cards = await Card.qm.getByIds(cardIds);
+        const cardById = _.keyBy(cards, 'id');
+
+        const boardIdByTaskId = tasks.reduce(
+          (result, task) => ({
+            ...result,
+            [task.id]: cardById[taskListById[task.taskListId].cardId].boardId,
+          }),
+          {},
+        );
+
+        tasks.forEach((task) => {
+          sails.sockets.broadcast(`board:${boardIdByTaskId[task.id]}`, 'taskUpdate', {
+            item: task,
+          });
+        });
+
+        // TODO: send webhooks
+      }
+
       sails.helpers.utils.sendWebhooks.with({
         webhooks,
         event: Webhook.Events.CARD_UPDATE,

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

@@ -29,7 +29,7 @@ module.exports = {
   async fn(inputs) {
     const trashList = await List.qm.getOneTrashByBoardId(inputs.board.id);
 
-    const cards = await Card.qm.update(
+    const { cards } = await Card.qm.update(
       {
         listId: inputs.record.id,
       },

server/api/helpers/lists/move-cards.js

@@ -55,7 +55,7 @@ module.exports = {
       values.prevListId = null;
     }
 
-    const cards = await Card.qm.update(
+    const { cards } = await Card.qm.update(
       {
         listId: inputs.record.id,
       },

server/api/helpers/lists/sort-one.js

@@ -78,8 +78,8 @@ module.exports = {
     }
 
     cards = await Promise.all(
-      cards.map((card, index) =>
-        Card.qm.updateOne(
+      cards.map(async (card, index) => {
+        const { card: nextCard } = await Card.qm.updateOne(
           {
             id: card.id,
             listId: card.listId,
@@ -87,8 +87,10 @@ module.exports = {
           {
             position: POSITION_GAP * (index + 1),
           },
-        ),
-      ),
+        );
+
+        return nextCard;
+      }),
     );
 
     sails.sockets.broadcast(

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

@@ -33,28 +33,6 @@ module.exports = {
   async fn(inputs) {
     const { values } = inputs;
 
-    if (values.type) {
-      let isClosed;
-      if (values.type === List.Types.CLOSED) {
-        if (inputs.record.type === List.Types.ACTIVE) {
-          isClosed = true;
-        }
-      } else if (inputs.record.type === List.Types.CLOSED) {
-        isClosed = false;
-      }
-
-      if (!_.isUndefined(isClosed)) {
-        await Card.qm.update(
-          {
-            listId: inputs.record.id,
-          },
-          {
-            isClosed,
-          },
-        );
-      }
-    }
-
     if (!_.isUndefined(values.position)) {
       const lists = await sails.helpers.boards.getFiniteListsById(
         inputs.board.id,
@@ -94,7 +72,7 @@ module.exports = {
       }
     }
 
-    const list = await List.qm.updateOne(inputs.record.id, values);
+    const { list, tasks } = await List.qm.updateOne(inputs.record.id, values);
 
     if (list) {
       sails.sockets.broadcast(
@@ -106,6 +84,32 @@ module.exports = {
         inputs.request,
       );
 
+      if (tasks) {
+        const taskListIds = sails.helpers.utils.mapRecords(tasks, 'taskListId', true);
+        const taskLists = await TaskList.qm.getByIds(taskListIds);
+        const taskListById = _.keyBy(taskLists, 'id');
+
+        const cardIds = sails.helpers.utils.mapRecords(taskLists, 'cardId', true);
+        const cards = await Card.qm.getByIds(cardIds);
+        const cardById = _.keyBy(cards, 'id');
+
+        const boardIdByTaskId = tasks.reduce(
+          (result, task) => ({
+            ...result,
+            [task.id]: cardById[taskListById[task.taskListId].cardId].boardId,
+          }),
+          {},
+        );
+
+        tasks.forEach((task) => {
+          sails.sockets.broadcast(`board:${boardIdByTaskId[task.id]}`, 'taskUpdate', {
+            item: task,
+          });
+        });
+
+        // TODO: send webhooks
+      }
+
       const webhooks = await Webhook.qm.getAll();
 
       sails.helpers.utils.sendWebhooks.with({

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

@@ -34,9 +34,17 @@ module.exports = {
     },
   },
 
+  exists: {
+    linkedCardOrNameMustBeInValues: {},
+  },
+
   async fn(inputs) {
     const { values } = inputs;
 
+    if (!values.linkedCard && !values.name) {
+      throw 'linkedCardOrNameMustBeInValues';
+    }
+
     const tasks = await Task.qm.getByTaskListId(values.taskList.id);
 
     const { position, repositions } = sails.helpers.utils.insertToPositionables(
@@ -67,6 +75,17 @@ module.exports = {
       // TODO: send webhooks
     }
 
+    if (values.linkedCard) {
+      Object.assign(values, {
+        linkedCardId: values.linkedCard.id,
+        name: values.linkedCard.name,
+      });
+
+      if (values.linkedCard.isClosed) {
+        values.isCompleted = true;
+      }
+    }
+
     const task = await Task.qm.createOne({
       ...values,
       position,

server/api/hooks/query-methods/models/Card.js

@@ -200,9 +200,69 @@ const getOneById = (id, { listId } = {}) => {
   return Card.findOne(criteria);
 };
 
-const update = (criteria, values) => Card.update(criteria).set(values).fetch();
+const update = async (criteria, values) => {
+  if (!_.isUndefined(values.isClosed)) {
+    return sails.getDatastore().transaction(async (db) => {
+      const cards = await Card.update(criteria).set(values).fetch().usingConnection(db);
 
-const updateOne = (criteria, values) => Card.updateOne(criteria).set({ ...values });
+      let tasks = [];
+      if (card) {
+        tasks = await Task.update({
+          linkedCardId: sails.helpers.utils.mapRecords(cards),
+        })
+          .set({
+            isCompleted: card.isClosed,
+          })
+          .fetch()
+          .usingConnection(db);
+      }
+
+      return {
+        cards,
+        tasks,
+      };
+    });
+  }
+
+  const cards = await Card.update(criteria).set(values).fetch();
+
+  return {
+    cards,
+  };
+};
+
+const updateOne = async (criteria, values) => {
+  if (!_.isUndefined(values.isClosed)) {
+    return sails.getDatastore().transaction(async (db) => {
+      const card = await Card.updateOne(criteria)
+        .set({ ...values })
+        .usingConnection(db);
+
+      let tasks = [];
+      if (card) {
+        tasks = await Task.update({
+          linkedCardId: card.id,
+        })
+          .set({
+            isCompleted: card.isClosed,
+          })
+          .fetch()
+          .usingConnection(db);
+      }
+
+      return {
+        card,
+        tasks,
+      };
+    });
+  }
+
+  const card = await Card.updateOne(criteria).set({ ...values });
+
+  return {
+    card,
+  };
+};
 
 // eslint-disable-next-line no-underscore-dangle
 const delete_ = (criteria) => Card.destroy(criteria).fetch();

server/api/hooks/query-methods/models/List.js

@@ -47,7 +47,67 @@ const getOneTrashByBoardId = (boardId) =>
     type: List.Types.TRASH,
   });
 
-const updateOne = (criteria, values) => List.updateOne(criteria).set({ ...values });
+const updateOne = async (criteria, values) => {
+  if (values.type) {
+    return sails.getDatastore().transaction(async (db) => {
+      const list = await List.updateOne(criteria)
+        .set({ ...values })
+        .usingConnection(db);
+
+      let cards = [];
+      let tasks = [];
+
+      if (list) {
+        const prevTypeState = List.TYPE_STATE_BY_TYPE[prevList.type];
+        const typeState = List.TYPE_STATE_BY_TYPE[list.type];
+
+        let isClosed;
+        if (prevTypeState === List.TypeStates.CLOSED && typeState === List.TypeStates.OPENED) {
+          isClosed = false;
+        } else if (
+          prevTypeState === List.TypeStates.OPENED &&
+          typeState === List.TypeStates.CLOSED
+        ) {
+          isClosed = true;
+        }
+
+        if (!_.isUndefined(isClosed)) {
+          cards = await Card.update({
+            listId: list.id,
+          })
+            .set({
+              isClosed,
+            })
+            .fetch()
+            .usingConnection(db);
+
+          if (cards.length > 0) {
+            tasks = await Task.update({
+              linkedCardId: sails.helpers.utils.mapRecords(cards),
+            })
+              .set({
+                isCompleted: isClosed,
+              })
+              .fetch()
+              .usingConnection(db);
+          }
+        }
+      }
+
+      return {
+        list,
+        cards,
+        tasks,
+      };
+    });
+  }
+
+  const list = await List.updateOne(criteria).set({ ...values });
+
+  return {
+    list,
+  };
+};
 
 // eslint-disable-next-line no-underscore-dangle
 const delete_ = (criteria) => List.destroy(criteria).fetch();

server/api/models/Card.js

@@ -48,16 +48,16 @@ module.exports = {
     stopwatch: {
       type: 'json',
     },
-    isClosed: {
-      type: 'boolean',
-      defaultsTo: false,
-      columnName: 'is_closed',
-    },
     commentsTotal: {
       type: 'number',
       defaultsTo: 0,
       columnName: 'comments_total',
     },
+    isClosed: {
+      type: 'boolean',
+      defaultsTo: false,
+      columnName: 'is_closed',
+    },
     listChangedAt: {
       type: 'ref',
       columnName: 'list_changed_at',

server/api/models/List.js

@@ -17,6 +17,11 @@ const Types = {
   TRASH: 'trash',
 };
 
+const TypeStates = {
+  OPENED: 'opened',
+  CLOSED: 'closed',
+};
+
 const SortFieldNames = {
   NAME: 'name',
   DUE_DATE: 'dueDate',
@@ -31,6 +36,11 @@ const SortOrders = {
 
 const FINITE_TYPES = [Types.ACTIVE, Types.CLOSED];
 
+const TYPE_STATE_BY_TYPE = {
+  [Types.ACTIVE]: TypeStates.OPENED,
+  [Types.CLOSED]: Types.CLOSED,
+};
+
 const COLORS = [
   'berry-red',
   'pumpkin-orange',
@@ -46,9 +56,11 @@ const COLORS = [
 
 module.exports = {
   Types,
+  TypeStates,
   SortFieldNames,
   SortOrders,
   FINITE_TYPES,
+  TYPE_STATE_BY_TYPE,
   COLORS,
 
   attributes: {

server/api/models/Task.js

@@ -43,6 +43,10 @@ module.exports = {
       required: true,
       columnName: 'task_list_id',
     },
+    linkedCardId: {
+      model: 'Card',
+      columnName: 'linked_card_id',
+    },
     assigneeUserId: {
       model: 'User',
       columnName: 'assignee_user_id',

server/config/i18n.js

@@ -25,11 +25,11 @@ module.exports.i18n = {
     'en-GB',
     'en-US',
     'es-ES',
+    'fi-FI',
     'fr-FR',
     'it-IT',
     'ru-RU',
     'tr-TR',
-    'fi-FI',
   ],
 
   /**

server/config/locales/fi-FI.json

@@ -0,0 +1,16 @@
+{
+	"Card Created": "Kortti luotu",
+	"Card Moved": "Kortti siirretty",
+	"New Comment": "Uusi kommentti",
+	"Test Title": "Testin otsikko",
+	"This is a test text message!": "Tämä on testiviesti!",
+	"This is a *test* **markdown** `message`!": "Tämä on *testi* **markdown** `viesti`!",
+	"This is a <i>test</i> <b>html</b> <code>message</code>": "Tämä on <i>testi</i> <b>html</b> <code>viesti</code>",
+	"You Were Added to Card": "Sinut lisättiin korttiin",
+	"You Were Mentioned in Comment": "Sinut mainittiin kommentissa",
+	"%s added you to %s on %s": "%s lisäsi sinut kohteeseen %s kohteessa %s",
+	"%s created %s in %s on %s": "%s loi %s kohteessa %s kohteessa %s",
+	"%s left a new comment to %s on %s": "%s jätti uuden kommentin kohteeseen %s kohteessa %s",
+	"%s mentioned you in %s on %s": "%s mainitsi sinut kohteessa %s kohteessa %s",
+	"%s moved %s from %s to %s on %s": "%s siirsi %s kohteesta %s kohteeseen %s kohteessa %s"
+}

server/db/migrations/20250709160208_add_ability_to_link_tasks_to_cards.js

@@ -0,0 +1,20 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+exports.up = async (knex) =>
+  knex.schema.alterTable('task', (table) => {
+    /* Columns */
+
+    table.bigInteger('linked_card_id');
+
+    /* Indexes */
+
+    table.index('linked_card_id');
+  });
+
+exports.down = (knex) =>
+  knex.schema.table('task', (table) => {
+    table.dropColumn('linked_card_id');
+  });