feat: Add ability to move lists between boards (#1208)

2025-12-21 09:15:51 +03:00 · 2025-09-04 01:07:10 +03:00
parent 5f34a737bb
commit 9683227fbc
58 changed files with 950 additions and 263 deletions
--- a/server/api/helpers/cards/detach-custom-fields.js
+++ b/server/api/helpers/cards/detach-custom-fields.js
@@ -0,0 +1,279 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const { POSITION_GAP } = require('../../../constants');
+
+module.exports = {
+  inputs: {
+    idOrIds: {
+      type: 'json',
+      required: true,
+    },
+    boardId: {
+      type: 'ref',
+      required: true,
+    },
+    withBaseCustomFieldGroups: {
+      type: 'boolean',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    const cardIds = _.isString(inputs.idOrIds) ? [inputs.idOrIds] : inputs.idOrIds;
+
+    const boardCustomFieldGroups = await CustomFieldGroup.qm.getByBoardId(inputs.boardId);
+    const boardCustomFieldGroupIds = sails.helpers.utils.mapRecords(boardCustomFieldGroups);
+
+    const boardCustomFields =
+      await CustomField.qm.getByCustomFieldGroupIds(boardCustomFieldGroupIds);
+
+    const cardsCustomFieldGroups = await CustomFieldGroup.qm.getByCardIds(cardIds);
+    const customFieldGroupsByCardId = _.groupBy(cardsCustomFieldGroups, 'cardId');
+
+    let basedBoardCustomFieldGroups;
+    let basedCardCustomFieldGroups;
+    let baseCustomFieldGroupById;
+    let customFieldsByBaseCustomFieldGroupId;
+
+    if (inputs.withBaseCustomFieldGroups) {
+      basedBoardCustomFieldGroups = boardCustomFieldGroups.filter(
+        ({ baseCustomFieldGroupId }) => baseCustomFieldGroupId,
+      );
+
+      basedCardCustomFieldGroups = cardsCustomFieldGroups.filter(
+        ({ baseCustomFieldGroupId }) => baseCustomFieldGroupId,
+      );
+
+      const basedCustomFieldGroups = [
+        ...basedBoardCustomFieldGroups,
+        ...basedCardCustomFieldGroups,
+      ];
+
+      const baseCustomFieldGroupIds = sails.helpers.utils.mapRecords(
+        basedCustomFieldGroups,
+        'baseCustomFieldGroupId',
+        true,
+      );
+
+      const baseCustomFieldGroups = await BaseCustomFieldGroup.qm.getByIds(baseCustomFieldGroupIds);
+      baseCustomFieldGroupById = _.keyBy(baseCustomFieldGroups, 'id');
+
+      const baseCustomFields = await CustomField.qm.getByBaseCustomFieldGroupIds(
+        Object.keys(baseCustomFieldGroupById),
+      );
+
+      customFieldsByBaseCustomFieldGroupId = _.groupBy(baseCustomFields, 'baseCustomFieldGroupId');
+    }
+
+    let idsTotal = (boardCustomFieldGroups.length + boardCustomFields.length) * cardIds.length;
+
+    if (inputs.withBaseCustomFieldGroups) {
+      idsTotal += basedBoardCustomFieldGroups.reduce((result, customFieldGroup) => {
+        const customFieldsItem =
+          customFieldsByBaseCustomFieldGroupId[customFieldGroup.baseCustomFieldGroupId];
+
+        return result + (customFieldsItem ? customFieldsItem.length : 0) * cardIds.length;
+      }, 0);
+
+      idsTotal += basedCardCustomFieldGroups.reduce((result, customFieldGroup) => {
+        const customFieldsItem =
+          customFieldsByBaseCustomFieldGroupId[customFieldGroup.baseCustomFieldGroupId];
+
+        return result + (customFieldsItem ? customFieldsItem.length : 0);
+      }, 0);
+    }
+
+    const ids = await sails.helpers.utils.generateIds(idsTotal);
+
+    const nextCustomFieldGroupIdByCustomFieldGroupIdByCardId = {};
+    const nextCustomFieldGroupsValues = (
+      await Promise.all(
+        cardIds.map(async (cardId) => {
+          const customFieldGroupIdByCustomFieldGroupId = {};
+          const customFieldGroupsValues = boardCustomFieldGroups.map((customFieldGroup, index) => {
+            const id = ids.shift();
+            customFieldGroupIdByCustomFieldGroupId[customFieldGroup.id] = id;
+
+            const values = {
+              ..._.pick(customFieldGroup, ['baseCustomFieldGroupId', 'name']),
+              id,
+              cardId,
+              position: POSITION_GAP * (index + 1),
+            };
+
+            if (inputs.withBaseCustomFieldGroups && customFieldGroup.baseCustomFieldGroupId) {
+              values.baseCustomFieldGroupId = null;
+
+              if (!customFieldGroup.name) {
+                values.name =
+                  baseCustomFieldGroupById[customFieldGroup.baseCustomFieldGroupId].name;
+              }
+            }
+
+            return values;
+          });
+
+          nextCustomFieldGroupIdByCustomFieldGroupIdByCardId[cardId] =
+            customFieldGroupIdByCustomFieldGroupId;
+
+          if (customFieldGroupsValues.length > 0) {
+            const cardCustomFieldGroups = customFieldGroupsByCardId[cardId];
+
+            if (cardCustomFieldGroups && cardCustomFieldGroups.length > 0) {
+              const { position } = customFieldGroupsValues[customFieldGroupsValues.length - 1];
+
+              await Promise.all(
+                cardCustomFieldGroups.map((customFieldGroup) =>
+                  CustomFieldGroup.qm.updateOne(customFieldGroup.id, {
+                    position: customFieldGroup.position + position,
+                  }),
+                ),
+              );
+            }
+          }
+
+          return customFieldGroupsValues;
+        }),
+      )
+    ).flat();
+
+    await CustomFieldGroup.qm.create(nextCustomFieldGroupsValues);
+
+    if (inputs.withBaseCustomFieldGroups) {
+      await CustomFieldGroup.qm.update(
+        {
+          cardId: cardIds,
+          baseCustomFieldGroupId: {
+            '!=': null,
+          },
+        },
+        {
+          baseCustomFieldGroupId: null,
+        },
+      );
+
+      const unnamedCustomFieldGroups = basedCardCustomFieldGroups.filter(({ name }) => !name);
+
+      await Promise.all(
+        unnamedCustomFieldGroups.map((customFieldGroup) =>
+          CustomFieldGroup.qm.updateOne(customFieldGroup.id, {
+            name: baseCustomFieldGroupById[customFieldGroup.baseCustomFieldGroupId].name,
+          }),
+        ),
+      );
+    }
+
+    const nextCustomFieldIdByCustomFieldIdByCardId = {};
+    const nextCustomFieldsValues = cardIds.flatMap((cardId) => {
+      const customFieldIdByCustomFieldId = {};
+      const customFieldsValues = boardCustomFields.map((customField) => {
+        const id = ids.shift();
+        customFieldIdByCustomFieldId[customField.id] = id;
+
+        return {
+          ..._.pick(customField, ['name', 'showOnFrontOfCard', 'position']),
+          id,
+          customFieldGroupId:
+            nextCustomFieldGroupIdByCustomFieldGroupIdByCardId[cardId][
+              customField.customFieldGroupId
+            ],
+        };
+      });
+
+      nextCustomFieldIdByCustomFieldIdByCardId[cardId] = customFieldIdByCustomFieldId;
+      return customFieldsValues;
+    });
+
+    if (inputs.withBaseCustomFieldGroups) {
+      cardIds.forEach((cardId) => {
+        basedBoardCustomFieldGroups.forEach((customFieldGroup) => {
+          const customFieldsItem =
+            customFieldsByBaseCustomFieldGroupId[customFieldGroup.baseCustomFieldGroupId];
+
+          if (!customFieldsItem) {
+            return;
+          }
+
+          customFieldsItem.forEach((customField) => {
+            const id = ids.shift();
+
+            nextCustomFieldIdByCustomFieldIdByCardId[cardId][
+              `${customFieldGroup.id}:${customField.id}`
+            ] = id;
+
+            nextCustomFieldsValues.push({
+              ..._.pick(customField, ['name', 'showOnFrontOfCard', 'position']),
+              id,
+              customFieldGroupId:
+                nextCustomFieldGroupIdByCustomFieldGroupIdByCardId[cardId][customFieldGroup.id],
+            });
+          });
+        });
+      });
+
+      basedCardCustomFieldGroups.forEach((customFieldGroup) => {
+        const customFieldsItem =
+          customFieldsByBaseCustomFieldGroupId[customFieldGroup.baseCustomFieldGroupId];
+
+        if (!customFieldsItem) {
+          return;
+        }
+
+        customFieldsItem.forEach((customField) => {
+          const id = ids.shift();
+
+          nextCustomFieldIdByCustomFieldIdByCardId[customFieldGroup.cardId][
+            `${customFieldGroup.id}:${customField.id}`
+          ] = id;
+
+          nextCustomFieldsValues.push({
+            ..._.pick(customField, ['name', 'showOnFrontOfCard', 'position']),
+            id,
+            customFieldGroupId: customFieldGroup.id,
+          });
+        });
+      });
+    }
+
+    await CustomField.qm.create(nextCustomFieldsValues);
+
+    const customFieldGroupIds = boardCustomFieldGroupIds;
+    if (inputs.withBaseCustomFieldGroups) {
+      customFieldGroupIds.push(...sails.helpers.utils.mapRecords(basedCardCustomFieldGroups));
+    }
+
+    const customFieldValues = await CustomFieldValue.qm.getByCardIds(cardIds, {
+      customFieldGroupIdOrIds: customFieldGroupIds,
+    });
+
+    await Promise.all(
+      customFieldValues.map((customFieldValue) => {
+        const updateValues = {
+          customFieldGroupId:
+            nextCustomFieldGroupIdByCustomFieldGroupIdByCardId[customFieldValue.cardId][
+              customFieldValue.customFieldGroupId
+            ],
+        };
+
+        const nextCustomFieldIdByCustomFieldId =
+          nextCustomFieldIdByCustomFieldIdByCardId[customFieldValue.cardId];
+
+        if (nextCustomFieldIdByCustomFieldId) {
+          const nextCustomFieldId =
+            nextCustomFieldIdByCustomFieldId[
+              `${customFieldValue.customFieldGroupId}:${customFieldValue.customFieldId}`
+            ] || nextCustomFieldIdByCustomFieldId[customFieldValue.customFieldId];
+
+          if (nextCustomFieldId) {
+            updateValues.customFieldId = nextCustomFieldId;
+          }
+        }
+
+        return CustomFieldValue.qm.updateOne(customFieldValue.id, updateValues);
+      }),
+    );
+  },
+};