From 38134549c290c603f2473d959cda3f421fe1bc1c Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Wed, 17 Dec 2025 00:23:07 +0200
Subject: [PATCH 1/9] feat: Add button for import from Focalboard

---
 .../src/components/boards/AddBoardStep/AddBoardStep.jsx  | 9 ++++++++-
 client/src/components/boards/AddBoardStep/ImportStep.jsx | 3 +++
 client/src/locales/en-US/core.js                         | 1 +
 3 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
index de859a9b5..172b22d2a 100755
--- a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
+++ b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
@@ -22,6 +22,11 @@ const StepTypes = {
   IMPORT: 'IMPORT',
 };
 
+const IMPORT_TYPE_ICONS = {
+  trello: 'trello',
+  focalboard: 'file',
+};
+
 const AddBoardStep = React.memo(({ onClose }) => {
   const dispatch = useDispatch();
   const [t] = useTranslation();
@@ -84,6 +89,8 @@ const AddBoardStep = React.memo(({ onClose }) => {
     return <ImportStep onSelect={handleImportSelect} onBack={handleImportBack} />;
   }
 
+  const importIconName = data.import ? (IMPORT_TYPE_ICONS[data.import.type] || 'file') : 'arrow down';
+
   return (
     <>
       <Popup.Header>
@@ -111,7 +118,7 @@ const AddBoardStep = React.memo(({ onClose }) => {
               onClick={handleImportClick}
             >
               <Icon
-                name={data.import ? data.import.type : 'arrow down'}
+                name={importIconName}
                 className={styles.importButtonIcon}
               />
               {data.import ? data.import.file.name : t('action.import')}
diff --git a/client/src/components/boards/AddBoardStep/ImportStep.jsx b/client/src/components/boards/AddBoardStep/ImportStep.jsx
index 896d220e8..7decdbded 100644
--- a/client/src/components/boards/AddBoardStep/ImportStep.jsx
+++ b/client/src/components/boards/AddBoardStep/ImportStep.jsx
@@ -37,6 +37,9 @@ const ImportStep = React.memo(({ onSelect, onBack }) => {
         <FilePicker accept=".json" onSelect={(file) => handleFileSelect('trello', file)}>
           <Button fluid content={t('common.fromTrello')} icon="trello" className={styles.button} />
         </FilePicker>
+        <FilePicker accept=".jsonl" onSelect={(file) => handleFileSelect('focalboard', file)}>
+          <Button fluid content={t('common.fromFocalboard')} icon="trello" className={styles.button} />
+        </FilePicker>
       </Popup.Content>
     </>
   );
diff --git a/client/src/locales/en-US/core.js b/client/src/locales/en-US/core.js
index 34be10d1e..e4958d2a2 100644
--- a/client/src/locales/en-US/core.js
+++ b/client/src/locales/en-US/core.js
@@ -199,6 +199,7 @@ export default {
       forPersonalProjects: 'For personal projects.',
       forTeamBasedProjects: 'For team-based projects.',
       fromComputer_title: 'From Computer',
+      fromFocalboard: 'From Focalboard',
       fromTrello: 'From Trello',
       fullKeyIsHiddenForSecurityReasons:
         'The full key is hidden for security reasons. Regenerate it to create a new one.',

From 64962b6affcf294215ec8f8314bd59b1131a9559 Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Wed, 17 Dec 2025 21:04:29 +0200
Subject: [PATCH 2/9] feat: Basic import from Focalboard

---
 server/api/controllers/boards/create.js       |   9 +
 server/api/helpers/boards/create-one.js       |   4 +
 .../helpers/boards/import-from-focalboard.js  | 270 ++++++++++++++++++
 ...process-uploaded-focalboard-import-file.js | 152 ++++++++++
 server/api/models/Board.js                    |   1 +
 5 files changed, 436 insertions(+)
 create mode 100644 server/api/helpers/boards/import-from-focalboard.js
 create mode 100644 server/api/helpers/boards/process-uploaded-focalboard-import-file.js

diff --git a/server/api/controllers/boards/create.js b/server/api/controllers/boards/create.js
index 049fbdc15..0ba4ffc8a 100755
--- a/server/api/controllers/boards/create.js
+++ b/server/api/controllers/boards/create.js
@@ -200,6 +200,15 @@ module.exports = {
           type: inputs.importType,
           board: trelloBoard,
         };
+      } else if (inputs.importType === Board.ImportTypes.FOCALBOARD) {
+        const focalboardData = await sails.helpers.boards
+          .processUploadedFocalboardImportFile(file)
+          .intercept('invalidFile', () => Errors.INVALID_IMPORT_FILE);
+
+        boardImport = {
+          type: inputs.importType,
+          data: focalboardData,
+        };
       }
     }
 
diff --git a/server/api/helpers/boards/create-one.js b/server/api/helpers/boards/create-one.js
index a09a7252d..dec257c86 100644
--- a/server/api/helpers/boards/create-one.js
+++ b/server/api/helpers/boards/create-one.js
@@ -88,6 +88,10 @@ module.exports = {
       await sails.helpers.boards.importFromTrello(board, lists, inputs.import.board);
     }
 
+    if (inputs.import && inputs.import.type === Board.ImportTypes.FOCALBOARD) {
+      await sails.helpers.boards.importFromFocalboard(board, lists, inputs.import.data);
+    }
+
     scoper.board = board;
     scoper.boardMemberships = [boardMembership];
 
diff --git a/server/api/helpers/boards/import-from-focalboard.js b/server/api/helpers/boards/import-from-focalboard.js
new file mode 100644
index 000000000..c4fad2db9
--- /dev/null
+++ b/server/api/helpers/boards/import-from-focalboard.js
@@ -0,0 +1,270 @@
+/*!
+ * 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: {
+    board: {
+      type: 'ref',
+      required: true,
+    },
+    lists: {
+      type: 'ref',
+      required: true,
+    },
+    focalboardData: {
+      type: 'json',
+      required: true,
+    },
+  },
+
+  async fn(inputs) {
+    const { focalboardData } = inputs;
+
+    console.log('');
+    console.log('=== Starting Focalboard Import ===');
+    console.log(`Board: ${focalboardData.board?.title || 'Unknown'}`);
+    console.log(`Total views: ${focalboardData.views.length}`);
+    console.log(`Total cards: ${focalboardData.cards.length}`);
+    console.log(`Total text blocks: ${focalboardData.textBlocks.length}`);
+
+    // Find the board block
+    const boardBlock = focalboardData.board;
+    if (!boardBlock) {
+      throw new Error('No board block found in Focalboard data');
+    }
+
+    // Find the Kanban view
+    const kanbanView = focalboardData.views.find(
+      (view) => view.fields.viewType === 'board'
+    );
+    if (!kanbanView) {
+      throw new Error('No Kanban view found in Focalboard data');
+    }
+    console.log(`Using Kanban view: ${kanbanView.title}`);
+
+    // Find the column property (the one used for grouping in Kanban view)
+    const columnPropertyId = kanbanView.fields.groupById;
+    if (!columnPropertyId) {
+      throw new Error('No groupById property found in Kanban view');
+    }
+
+    const columnProperty = boardBlock.cardProperties.find(
+      (prop) => prop.id === columnPropertyId
+    );
+    if (!columnProperty) {
+      throw new Error('Column property not found in board');
+    }
+    console.log(`Column property: ${columnProperty.name} (${columnProperty.type})`);
+    console.log(`Total column options: ${columnProperty.options.length}`);
+
+    // Create lists from visible column options
+    const visibleOptionIds = kanbanView.fields.visibleOptionIds || [];
+    const listIdByOptionId = {};
+
+    console.log('');
+    console.log('--- Creating Lists ---');
+    console.log(`Visible columns: ${visibleOptionIds.length}`);
+
+    let createdListsCount = 0;
+    await Promise.all(
+      visibleOptionIds.map(async (optionId, index) => {
+        // Empty string in visibleOptionIds represents cards without a column value
+        if (optionId === '') {
+          console.log(`  [${index}] Skipping empty option ID`);
+          return;
+        }
+
+        const option = columnProperty.options.find((opt) => opt.id === optionId);
+        if (!option) {
+          console.log(`  [${index}] Option not found: ${optionId}`);
+          return;
+        }
+
+        const { id } = await List.qm.createOne({
+          boardId: inputs.board.id,
+          type: List.Types.ACTIVE,
+          position: POSITION_GAP * (index + 1),
+          name: option.value,
+        });
+
+        listIdByOptionId[optionId] = id;
+        createdListsCount++;
+        console.log(`  [${index}] Created list: "${option.value}" (position: ${POSITION_GAP * (index + 1)})`);
+      })
+    );
+
+    console.log(`Created ${createdListsCount} lists`);
+
+    // Create an "Unordered" list for cards not in cardOrder or without column
+    const { id: unorderedListId } = await List.qm.createOne({
+      boardId: inputs.board.id,
+      type: List.Types.ACTIVE,
+      position: POSITION_GAP * (visibleOptionIds.length + 1),
+      name: 'Unordered',
+    });
+    console.log(`Created "Unordered" list (position: ${POSITION_GAP * (visibleOptionIds.length + 1)})`);
+
+    // Get archive list
+    const { id: archiveListId } = inputs.lists.find(
+      (list) => list.type === List.Types.ARCHIVE
+    );
+
+    console.log('');
+    console.log('--- Grouping Cards by Column ---');
+
+    // Group cards by their column value
+    const cardsByColumn = {};
+    const cardOrder = kanbanView.fields.cardOrder || [];
+
+    console.log(`Cards in cardOrder: ${cardOrder.length}`);
+
+    // Initialize column groups
+    visibleOptionIds.forEach((optionId) => {
+      if (optionId !== '') {
+        cardsByColumn[optionId] = [];
+      }
+    });
+    cardsByColumn['unordered'] = [];
+
+    // Process cards in the order defined by cardOrder
+    let cardsInOrder = 0;
+    let cardsWithoutColumn = 0;
+    cardOrder.forEach((cardId) => {
+      const card = focalboardData.cards.find((c) => c.id === cardId);
+      if (!card) {
+        return;
+      }
+
+      cardsInOrder++;
+      const columnValue = card.fields.properties[columnPropertyId];
+
+      if (columnValue && listIdByOptionId[columnValue]) {
+        cardsByColumn[columnValue].push(card);
+      } else {
+        cardsByColumn['unordered'].push(card);
+        cardsWithoutColumn++;
+      }
+    });
+
+    console.log(`Cards processed from cardOrder: ${cardsInOrder}`);
+
+    // Add cards not in cardOrder to unordered
+    let cardsNotInOrder = 0;
+    focalboardData.cards.forEach((card) => {
+      if (!cardOrder.includes(card.id)) {
+        cardsByColumn['unordered'].push(card);
+        cardsNotInOrder++;
+      }
+    });
+
+    if (cardsNotInOrder > 0) {
+      console.log(`Cards not in cardOrder (added to Unordered): ${cardsNotInOrder}`);
+    }
+    if (cardsWithoutColumn > 0) {
+      console.log(`Cards without column assignment: ${cardsWithoutColumn}`);
+    }
+
+    // Log distribution
+    console.log('');
+    console.log('Card distribution by list:');
+    for (const [columnKey, cards] of Object.entries(cardsByColumn)) {
+      if (cards.length > 0) {
+        if (columnKey === 'unordered') {
+          console.log(`  Unordered: ${cards.length} cards`);
+        } else {
+          const option = columnProperty.options.find((opt) => opt.id === columnKey);
+          console.log(`  ${option?.value || columnKey}: ${cards.length} cards`);
+        }
+      }
+    }
+
+    console.log('');
+    console.log('--- Importing Cards ---');
+
+    // Create cards
+    const cardIdByFocalboardCardId = {};
+    let totalCardsCreated = 0;
+    let cardsWithoutTitle = 0;
+    let cardsWithDescription = 0;
+
+    for (const [columnKey, cards] of Object.entries(cardsByColumn)) {
+      const listId = columnKey === 'unordered'
+        ? unorderedListId
+        : listIdByOptionId[columnKey];
+
+      if (!listId) {
+        continue;
+      }
+
+      if (cards.length === 0) {
+        continue;
+      }
+
+      const listName = columnKey === 'unordered'
+        ? 'Unordered'
+        : columnProperty.options.find((opt) => opt.id === columnKey)?.value || columnKey;
+
+      console.log(`Processing list "${listName}"...`);
+
+      await Promise.all(
+        cards.map(async (focalboardCard, index) => {
+          let cardName = focalboardCard.title?.trim();
+          if (!cardName) {
+            cardName = 'Untitled';
+            console.log(`  ⚠ Card with empty title, using "Untitled" (ID: ${focalboardCard.id})`);
+            cardsWithoutTitle++;
+          }
+          // Find description from text blocks
+          const textBlocks = focalboardData.textBlocks.filter(
+            (block) => block.parentId === focalboardCard.id
+          );
+
+          // Only create description if we have non-empty text blocks
+          let description = null;
+          if (textBlocks.length > 0) {
+            const descriptionText = textBlocks
+              .map((block) => block.title?.trim())
+              .filter((text) => text) // Remove empty/null values
+              .join('\n\n');
+
+            // Only set description if we got actual content
+            if (descriptionText) {
+              description = descriptionText;
+              cardsWithDescription++;
+            }
+          }
+
+          const values = {
+            boardId: inputs.board.id,
+            type: Card.Types.PROJECT,
+            position: POSITION_GAP * (index + 1),
+            name: cardName,
+            description,
+            listChangedAt: new Date(focalboardCard.updateAt).toISOString(),
+          };
+
+          values.listId = listId;
+
+          const { id } = await Card.qm.createOne(values);
+          cardIdByFocalboardCardId[focalboardCard.id] = id;
+          totalCardsCreated++;
+        })
+      );
+
+      console.log(`  ✓ Created ${cards.length} cards`);
+    }
+
+    console.log('');
+    console.log('=== Import Complete ===');
+    console.log(`Total cards imported: ${totalCardsCreated}`);
+    if (cardsWithoutTitle > 0) {
+      console.log(`Cards without title (named "Untitled"): ${cardsWithoutTitle}`);
+    }
+    console.log(`Lists created: ${createdListsCount + 1} (including Unordered)`);
+    console.log('');
+  },
+};
diff --git a/server/api/helpers/boards/process-uploaded-focalboard-import-file.js b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
new file mode 100644
index 000000000..501798c5b
--- /dev/null
+++ b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
@@ -0,0 +1,152 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const fs = require('fs');
+const { rimraf } = require('rimraf');
+const readline = require('readline');
+
+module.exports = {
+  inputs: {
+    file: {
+      type: 'json',
+      required: true,
+    },
+  },
+
+  exits: {
+    invalidFile: {},
+  },
+
+  async fn(inputs) {
+    console.log('');
+    console.log('=== Processing Focalboard JSONL File ===');
+
+    const fileStream = fs.createReadStream(inputs.file.fd);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity,
+    });
+
+    const blocks = {
+      board: null,
+      views: [],
+      cards: [],
+      textBlocks: [],
+    };
+
+    // To log
+    let lineCount = 0;
+    let emptyLines = 0;
+    let parseErrors = 0;
+    const unknownBlockTypes = new Set()
+
+    try {
+      for await (const line of rl) {
+        lineCount++;
+
+        if (!line.trim()) {
+          emptyLines++;
+          continue;
+        }
+
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch (error) {
+          parseErrors++;
+          console.warn(`Parse error on line ${lineCount}: ${error.message}`);
+          await rimraf(inputs.file.fd);
+          throw 'invalidFile';
+        }
+
+        // Focalboard exports have two formats (for this version):
+        // 1. Board: {"type":"board","data":{...}}
+        // 2. Blocks: {"type":"block","data":{...}}
+
+        let block;
+        if (parsed.type === 'board' && parsed.data) {
+          // Board is exported as type: "board"
+          block = parsed.data;
+          blocks.board = block;
+          console.log(`Found board: "${block.title}"`);
+          continue;
+        } else if (parsed.type === 'block' && parsed.data) {
+          // Other blocks are type: "block"
+          block = parsed.data;
+        } else {
+          console.warn(`Skipping line ${lineCount}: not a valid structure (type: ${parsed.type})`);
+          continue;
+        }
+
+        switch (block.type) {
+          case 'board':
+            blocks.board = block;
+            console.log(`Found board: "${block.title}"`);
+            break;
+          case 'view':
+            blocks.views.push(block);
+            console.log(`Found view: "${block.title}" (type: ${block.fields?.viewType || 'unknown'})`);
+            break;
+          case 'card':
+            blocks.cards.push(block);
+            break;
+          case 'text':
+            blocks.textBlocks.push(block);
+            break;
+          // We can ignore other block types for now (comment, attachment, etc.)
+          default:
+            break;
+        }
+      }
+    } catch (error) {
+      await rimraf(inputs.file.fd);
+      if (error === 'invalidFile') {
+        throw error;
+      }
+      console.error('Unexpected error:', error);
+      throw 'invalidFile';
+    }
+
+    await rimraf(inputs.file.fd);
+
+    console.log('');
+    console.log('--- Parsing Summary ---');
+    console.log(`Total lines: ${lineCount}`);
+    console.log(`Empty lines: ${emptyLines}`);
+    console.log(`Board blocks: ${blocks.board ? 1 : 0}`);
+    console.log(`View blocks: ${blocks.views.length}`);
+    console.log(`Card blocks: ${blocks.cards.length}`);
+    console.log(`Text blocks: ${blocks.textBlocks.length}`);
+
+    if (unknownBlockTypes.size > 0) {
+      console.log(`Unknown block types (ignored): ${Array.from(unknownBlockTypes).join(', ')}`);
+    }
+
+    if (parseErrors > 0) {
+      console.warn(`Parse errors: ${parseErrors}`);
+    }
+
+    // Validate that we have the minimum required data
+    if (!blocks.board) {
+      console.error('ERROR: No board block found');
+      throw 'invalidFile';
+    }
+
+    if (blocks.views.length === 0) {
+      console.error('ERROR: No view blocks found');
+      throw 'invalidFile';
+    }
+
+    if (blocks.cards.length === 0) {
+      console.error('ERROR: No card blocks found');
+      throw 'invalidFile';
+    }
+
+    console.log('✓ File validated successfully');
+    console.log('');
+
+    return blocks;
+  },
+};
diff --git a/server/api/models/Board.js b/server/api/models/Board.js
index 3ff9ca4be..41df98425 100755
--- a/server/api/models/Board.js
+++ b/server/api/models/Board.js
@@ -96,6 +96,7 @@ const Views = {
 
 const ImportTypes = {
   TRELLO: 'trello',
+  FOCALBOARD: 'focalboard',
 };
 
 module.exports = {

From db888e6ba18e2f6fdac02782973d818fc3db567f Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Thu, 15 Jan 2026 17:00:29 +0200
Subject: [PATCH 3/9] feat: import from focalboard with labels

---
 .../helpers/boards/import-from-focalboard.js  | 329 ++++++++++--------
 ...process-uploaded-focalboard-import-file.js |  11 +
 .../utils/convert-focalboard-label-color.js   |  42 +++
 3 files changed, 245 insertions(+), 137 deletions(-)
 create mode 100644 server/api/helpers/utils/convert-focalboard-label-color.js

diff --git a/server/api/helpers/boards/import-from-focalboard.js b/server/api/helpers/boards/import-from-focalboard.js
index c4fad2db9..213db70f9 100644
--- a/server/api/helpers/boards/import-from-focalboard.js
+++ b/server/api/helpers/boards/import-from-focalboard.js
@@ -22,63 +22,86 @@ module.exports = {
   },
 
   async fn(inputs) {
-    const { focalboardData } = inputs;
+    const {
+      board: boardBlock,
+      views,
+      cards: focalboardCards,
+      textBlocks,
+      labels: focalboardLabels,
+      labelPropertyId,
+    } = inputs.focalboardData;
 
     console.log('');
     console.log('=== Starting Focalboard Import ===');
-    console.log(`Board: ${focalboardData.board?.title || 'Unknown'}`);
-    console.log(`Total views: ${focalboardData.views.length}`);
-    console.log(`Total cards: ${focalboardData.cards.length}`);
-    console.log(`Total text blocks: ${focalboardData.textBlocks.length}`);
-
-    // Find the board block
-    const boardBlock = focalboardData.board;
-    if (!boardBlock) {
-      throw new Error('No board block found in Focalboard data');
-    }
+    console.log(`Board: ${boardBlock.title || 'Unknown'}`);
+    console.log(`Total views: ${views.length}`);
+    console.log(`Total cards: ${focalboardCards.length}`);
+    console.log(`Total text blocks: ${textBlocks.length}`);
+    console.log(`Total labels: ${focalboardLabels.length}`);
 
     // Find the Kanban view
-    const kanbanView = focalboardData.views.find(
-      (view) => view.fields.viewType === 'board'
-    );
+    const kanbanView = views.find((view) => view.fields.viewType === 'board');
     if (!kanbanView) {
       throw new Error('No Kanban view found in Focalboard data');
     }
+
     console.log(`Using Kanban view: ${kanbanView.title}`);
 
     // Find the column property (the one used for grouping in Kanban view)
-    const columnPropertyId = kanbanView.fields.groupById;
-    if (!columnPropertyId) {
-      throw new Error('No groupById property found in Kanban view');
-    }
+    const columnPropertyId = kanbanView.fields?.groupById;
+    const columnProperty = boardBlock.cardProperties?.find((p) => p.id === columnPropertyId);
 
-    const columnProperty = boardBlock.cardProperties.find(
-      (prop) => prop.id === columnPropertyId
-    );
     if (!columnProperty) {
-      throw new Error('Column property not found in board');
+      throw new Error('Column property not found in Focalboard export');
     }
     console.log(`Column property: ${columnProperty.name} (${columnProperty.type})`);
     console.log(`Total column options: ${columnProperty.options.length}`);
 
-    // Create lists from visible column options
-    const visibleOptionIds = kanbanView.fields.visibleOptionIds || [];
-    const listIdByOptionId = {};
+    // =====================================================
+    // LABELS SECTION
+    // =====================================================
 
+    console.log('');
+    console.log('--- Creating Labels ---');
+
+    const labelIdByFocalboardLabelId = {};
+
+    if (focalboardLabels.length > 0) {
+      await Promise.all(
+        focalboardLabels.map(async (focalboardLabel, index) => {
+          const plankaColor = sails.helpers.utils.convertFocalboardLabelColor(focalboardLabel.color);
+
+          const { id } = await Label.qm.createOne({
+            boardId: inputs.board.id,
+            position: POSITION_GAP * (index + 1),
+            name: focalboardLabel.value || null,
+            color: plankaColor,
+          });
+
+          labelIdByFocalboardLabelId[focalboardLabel.id] = id;
+          console.log(`Created label: "${focalboardLabel.value}" (${focalboardLabel.color} → ${plankaColor})`);
+        }),
+      );
+    } else {
+      console.log('No labels to import');
+    }
+
+    console.log(`Total labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
+
+    // =====================================================
+    // LISTS SECTION
+    // =====================================================
     console.log('');
     console.log('--- Creating Lists ---');
+    const visibleOptionIds = kanbanView.fields?.visibleOptionIds || [];
+    const listIdByOptionId = {};
+
     console.log(`Visible columns: ${visibleOptionIds.length}`);
 
-    let createdListsCount = 0;
     await Promise.all(
       visibleOptionIds.map(async (optionId, index) => {
-        // Empty string in visibleOptionIds represents cards without a column value
-        if (optionId === '') {
-          console.log(`  [${index}] Skipping empty option ID`);
-          return;
-        }
-
         const option = columnProperty.options.find((opt) => opt.id === optionId);
+
         if (!option) {
           console.log(`  [${index}] Option not found: ${optionId}`);
           return;
@@ -92,179 +115,211 @@ module.exports = {
         });
 
         listIdByOptionId[optionId] = id;
-        createdListsCount++;
         console.log(`  [${index}] Created list: "${option.value}" (position: ${POSITION_GAP * (index + 1)})`);
       })
     );
 
-    console.log(`Created ${createdListsCount} lists`);
+    console.log(`  ✓ Created ${Object.keys(listIdByOptionId).length} lists`);
 
     // Create an "Unordered" list for cards not in cardOrder or without column
+    const unorderedListName = 'Unordered';
     const { id: unorderedListId } = await List.qm.createOne({
       boardId: inputs.board.id,
       type: List.Types.ACTIVE,
       position: POSITION_GAP * (visibleOptionIds.length + 1),
-      name: 'Unordered',
+      name: unorderedListName,
     });
-    console.log(`Created "Unordered" list (position: ${POSITION_GAP * (visibleOptionIds.length + 1)})`);
-
-    // Get archive list
-    const { id: archiveListId } = inputs.lists.find(
-      (list) => list.type === List.Types.ARCHIVE
-    );
+    console.log(`Created "${unorderedListName}" list (position: ${POSITION_GAP * (visibleOptionIds.length + 1)})`);
 
+    // =====================================================
+    // GROUP CARDS BY COLUMN
+    // =====================================================
     console.log('');
     console.log('--- Grouping Cards by Column ---');
 
-    // Group cards by their column value
-    const cardsByColumn = {};
+    // Build card order map
     const cardOrder = kanbanView.fields.cardOrder || [];
-
     console.log(`Cards in cardOrder: ${cardOrder.length}`);
 
-    // Initialize column groups
-    visibleOptionIds.forEach((optionId) => {
-      if (optionId !== '') {
-        cardsByColumn[optionId] = [];
-      }
+    // Group cards by their column assignment
+    const cardsByListId = {};
+
+    // Initialize lists
+    Object.values(listIdByOptionId).forEach((listId) => {
+      cardsByListId[listId] = [];
+    });
+    cardsByListId[unorderedListId] = [];
+
+    // Map Focalboard card IDs to card objects
+    const focalboardCardById = {};
+    focalboardCards.forEach((card) => {
+      focalboardCardById[card.id] = card;
     });
-    cardsByColumn['unordered'] = [];
 
-    // Process cards in the order defined by cardOrder
-    let cardsInOrder = 0;
+    // Process cards in cardOrder first (maintains order)
+    let processedFromCardOrder = 0;
     let cardsWithoutColumn = 0;
+    const processedCardIds = new Set();
+
     cardOrder.forEach((cardId) => {
-      const card = focalboardData.cards.find((c) => c.id === cardId);
-      if (!card) {
-        return;
-      }
+      const card = focalboardCardById[cardId];
+      if (!card) return;
 
-      cardsInOrder++;
-      const columnValue = card.fields.properties[columnPropertyId];
+      processedCardIds.add(cardId);
 
-      if (columnValue && listIdByOptionId[columnValue]) {
-        cardsByColumn[columnValue].push(card);
+      const columnValue = card.fields?.properties?.[columnPropertyId];
+      const listId = listIdByOptionId[columnValue];
+
+      if (listId) {
+        cardsByListId[listId].push(card);
       } else {
-        cardsByColumn['unordered'].push(card);
-        cardsWithoutColumn++;
+        cardsByListId[unorderedListId].push(card);
+        cardsWithoutColumn += 1;
       }
+
+      processedFromCardOrder += 1;
     });
 
-    console.log(`Cards processed from cardOrder: ${cardsInOrder}`);
+    console.log(`Cards processed from cardOrder: ${processedFromCardOrder }`);
+
+    // Process cards not in cardOrder - place by column value, or Unordered if no column
+    let cardsNotInCardOrder = 0;
+    focalboardCards.forEach((card) => {
+      if (!processedCardIds.has(card.id)) {
+        const columnValue = card.fields?.properties?.[columnPropertyId];
+        const listId = listIdByOptionId[columnValue];
+
+        if (listId) {
+          cardsByListId[listId].push(card);
+        } else {
+          cardsByListId[unorderedListId].push(card);
+          cardsWithoutColumn += 1;
+        }
 
-    // Add cards not in cardOrder to unordered
-    let cardsNotInOrder = 0;
-    focalboardData.cards.forEach((card) => {
-      if (!cardOrder.includes(card.id)) {
-        cardsByColumn['unordered'].push(card);
-        cardsNotInOrder++;
+        cardsNotInCardOrder += 1;
       }
     });
 
-    if (cardsNotInOrder > 0) {
-      console.log(`Cards not in cardOrder (added to Unordered): ${cardsNotInOrder}`);
-    }
-    if (cardsWithoutColumn > 0) {
-      console.log(`Cards without column assignment: ${cardsWithoutColumn}`);
-    }
+    console.log(`Cards not in cardOrder (added to "${unorderedListName}"): ${cardsNotInCardOrder}`);
+    console.log(`Cards without column assignment: ${cardsWithoutColumn}`);
 
-    // Log distribution
+    // Log carddistribution
     console.log('');
     console.log('Card distribution by list:');
-    for (const [columnKey, cards] of Object.entries(cardsByColumn)) {
-      if (cards.length > 0) {
-        if (columnKey === 'unordered') {
-          console.log(`  Unordered: ${cards.length} cards`);
-        } else {
-          const option = columnProperty.options.find((opt) => opt.id === columnKey);
-          console.log(`  ${option?.value || columnKey}: ${cards.length} cards`);
+    Object.entries(cardsByListId).forEach(([listId, cards]) => {
+      // Find list name
+      let listName = unorderedListName;
+      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
+        if (id === listId) {
+          const option = columnProperty.options?.find((o) => o.id === optionId);
+          listName = option?.value || 'Unknown';
+          break;
         }
       }
-    }
+      console.log(`  ${listName}: ${cards.length} cards`);
+    });
 
+    // =====================================================
+    // IMPORT CARDS
+    // =====================================================
     console.log('');
     console.log('--- Importing Cards ---');
 
-    // Create cards
-    const cardIdByFocalboardCardId = {};
-    let totalCardsCreated = 0;
+    // Build text block lookup by parent ID
+    const textBlocksByParentId = {};
+    textBlocks.forEach((block) => {
+      if (!textBlocksByParentId[block.parentId]) {
+        textBlocksByParentId[block.parentId] = [];
+      }
+      textBlocksByParentId[block.parentId].push(block);
+    });
+
+
+    let totalCardsImported = 0;
     let cardsWithoutTitle = 0;
-    let cardsWithDescription = 0;
+    let cardsWithDescriptions = 0;
+    let cardsWithLabels = 0;
 
-    for (const [columnKey, cards] of Object.entries(cardsByColumn)) {
-      const listId = columnKey === 'unordered'
-        ? unorderedListId
-        : listIdByOptionId[columnKey];
 
-      if (!listId) {
-        continue;
-      }
+    // Process each list
+    for (const [listId, cards] of Object.entries(cardsByListId)) {
+      if (cards.length === 0) continue;
 
-      if (cards.length === 0) {
-        continue;
+      // Find list name for logging
+      let listName = unorderedListName;
+      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
+        if (id === listId) {
+          const option = columnProperty.options?.find((o) => o.id === optionId);
+          listName = option?.value || 'Unknown';
+          break;
+        }
       }
 
-      const listName = columnKey === 'unordered'
-        ? 'Unordered'
-        : columnProperty.options.find((opt) => opt.id === columnKey)?.value || columnKey;
-
       console.log(`Processing list "${listName}"...`);
 
       await Promise.all(
         cards.map(async (focalboardCard, index) => {
-          let cardName = focalboardCard.title?.trim();
-          if (!cardName) {
-            cardName = 'Untitled';
-            console.log(`  ⚠ Card with empty title, using "Untitled" (ID: ${focalboardCard.id})`);
-            cardsWithoutTitle++;
-          }
-          // Find description from text blocks
-          const textBlocks = focalboardData.textBlocks.filter(
-            (block) => block.parentId === focalboardCard.id
-          );
-
-          // Only create description if we have non-empty text blocks
-          let description = null;
-          if (textBlocks.length > 0) {
-            const descriptionText = textBlocks
-              .map((block) => block.title?.trim())
-              .filter((text) => text) // Remove empty/null values
-              .join('\n\n');
-
-            // Only set description if we got actual content
-            if (descriptionText) {
-              description = descriptionText;
-              cardsWithDescription++;
-            }
+          // Build description from text blocks
+          const cardTextBlocks = textBlocksByParentId[focalboardCard.id] || [];
+          const descriptionParts = cardTextBlocks
+            .map((block) => block.title?.trim())
+            .filter((text) => text);
+
+          const description = descriptionParts.length > 0 ? descriptionParts.join('\n\n') : null;
+
+          if (description) {
+            cardsWithDescriptions += 1;
           }
 
-          const values = {
+          // Create card
+          const cardValues = {
             boardId: inputs.board.id,
+            listId,
             type: Card.Types.PROJECT,
             position: POSITION_GAP * (index + 1),
-            name: cardName,
+            name: focalboardCard.title?.trim() || 'Untitled',
             description,
             listChangedAt: new Date(focalboardCard.updateAt).toISOString(),
           };
 
-          values.listId = listId;
+          const { id: cardId } = await Card.qm.createOne(cardValues);
+          totalCardsImported++;
+
+          // Assign labels to card
+          if (labelPropertyId) {
+            const cardLabelIds = focalboardCard.fields?.properties?.[labelPropertyId];
+
+            if (Array.isArray(cardLabelIds) && cardLabelIds.length > 0) {
+              await Promise.all(
+                cardLabelIds.map(async (focalboardLabelId) => {
+                  const plankaLabelId = labelIdByFocalboardLabelId[focalboardLabelId];
+
+                  if (plankaLabelId) {
+                    await CardLabel.qm.createOne({
+                      cardId,
+                      labelId: plankaLabelId,
+                    });
+                  }
+                }),
+              );
 
-          const { id } = await Card.qm.createOne(values);
-          cardIdByFocalboardCardId[focalboardCard.id] = id;
-          totalCardsCreated++;
+              cardsWithLabels += 1;
+            }
+          }
         })
       );
 
-      console.log(`  ✓ Created ${cards.length} cards`);
+      console.log(`Created ${cards.length} cards`);
     }
 
     console.log('');
     console.log('=== Import Complete ===');
-    console.log(`Total cards imported: ${totalCardsCreated}`);
-    if (cardsWithoutTitle > 0) {
-      console.log(`Cards without title (named "Untitled"): ${cardsWithoutTitle}`);
-    }
-    console.log(`Lists created: ${createdListsCount + 1} (including Unordered)`);
+    console.log(`Total cards imported: ${totalCardsImported}`);
+    console.log(`Cards without title (named "Untitled"): ${cardsWithoutTitle}`);
+    console.log(`Cards with descriptions: ${cardsWithDescriptions}`);
+    console.log(`Cards with labels: ${cardsWithLabels}`);
+    console.log(`Labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
+    console.log(`Lists created: ${Object.keys(listIdByOptionId).length + 1} (including "${unorderedListName}")`);
     console.log('');
   },
 };
diff --git a/server/api/helpers/boards/process-uploaded-focalboard-import-file.js b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
index 501798c5b..f4bbd89c5 100644
--- a/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
+++ b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
@@ -34,6 +34,7 @@ module.exports = {
       views: [],
       cards: [],
       textBlocks: [],
+      labels: [],
     };
 
     // To log
@@ -80,6 +81,16 @@ module.exports = {
           continue;
         }
 
+        if (blocks.board) {
+          const labelProperty = blocks.board.cardProperties?.find(
+            p => p.name === 'Рубрика' || p.type === 'multiSelect' // Sysblok-specific
+          );
+          if (labelProperty?.options) {
+            blocks.labels = labelProperty.options;
+            blocks.labelPropertyId = labelProperty.id; // Need this for card assignment
+          }
+        }
+
         switch (block.type) {
           case 'board':
             blocks.board = block;
diff --git a/server/api/helpers/utils/convert-focalboard-label-color.js b/server/api/helpers/utils/convert-focalboard-label-color.js
new file mode 100644
index 000000000..414db19b3
--- /dev/null
+++ b/server/api/helpers/utils/convert-focalboard-label-color.js
@@ -0,0 +1,42 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * convert-focalboard-label-color.js
+ *
+ * @description :: Converts Focalboard color names to Planka label colors.
+ *
+ * Location: server/api/helpers/utils/convert-focalboard-label-color.js
+ */
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    focalboardColor: {
+      type: 'string',
+      description: 'Focalboard color name (e.g., "propColorYellow")',
+      required: true,
+    },
+  },
+
+  fn(inputs) {
+    const colorMap = {
+      propColorDefault: 'desert-sand',
+      propColorGray: 'grey-stone',
+      propColorBrown: 'light-cocoa',
+      propColorOrange: 'pumpkin-orange',
+      propColorYellow: 'egg-yellow',
+      propColorGreen: 'fresh-salad',
+      propColorTeal: 'turquoise-sea',
+      propColorBlue: 'lagoon-blue',
+      propColorPurple: 'sugar-plum',
+      propColorPink: 'pink-tulip',
+      propColorRed: 'berry-red',
+    };
+
+    return colorMap[inputs.focalboardColor] || 'desert-sand';
+  },
+};

From bb658015ce5b4f91bbf5a5069b576e1bf82cb3d8 Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Sat, 17 Jan 2026 03:08:09 +0200
Subject: [PATCH 4/9] feat: import deadline and part of custom fields

---
 .../boards/group-focalboard-cards-by-list.js  | 147 +++++++++
 .../helpers/boards/import-focalboard-cards.js | 234 ++++++++++++++
 .../boards/import-focalboard-custom-fields.js | 112 +++++++
 .../boards/import-focalboard-labels.js        |  58 ++++
 .../helpers/boards/import-focalboard-lists.js |  79 +++++
 .../helpers/boards/import-from-focalboard.js  | 304 ++++--------------
 .../utils/convert-focalboard-label-color.js   |   4 -
 .../helpers/utils/parse-focalboard-date.js    |  35 ++
 8 files changed, 730 insertions(+), 243 deletions(-)
 create mode 100644 server/api/helpers/boards/group-focalboard-cards-by-list.js
 create mode 100644 server/api/helpers/boards/import-focalboard-cards.js
 create mode 100644 server/api/helpers/boards/import-focalboard-custom-fields.js
 create mode 100644 server/api/helpers/boards/import-focalboard-labels.js
 create mode 100644 server/api/helpers/boards/import-focalboard-lists.js
 create mode 100644 server/api/helpers/utils/parse-focalboard-date.js

diff --git a/server/api/helpers/boards/group-focalboard-cards-by-list.js b/server/api/helpers/boards/group-focalboard-cards-by-list.js
new file mode 100644
index 000000000..365727be1
--- /dev/null
+++ b/server/api/helpers/boards/group-focalboard-cards-by-list.js
@@ -0,0 +1,147 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Groups Focalboard cards by their target Planka list.
+ *                 Processes cards in cardOrder first, then remaining cards.
+ */
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    focalboardCards: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard card blocks',
+    },
+    cardOrder: {
+      type: 'ref',
+      required: true,
+      description: 'Array of card IDs in display order from Kanban view',
+    },
+    columnPropertyId: {
+      type: 'string',
+      required: true,
+      description: 'Focalboard property ID used for column assignment',
+    },
+    listIdByOptionId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard option ID to Planka list ID',
+    },
+    unorderedListId: {
+      type: 'string',
+      required: true,
+      description: 'Planka list ID for cards without column assignment',
+    },
+    unorderedListName: {
+      type: 'string',
+      required: true,
+      description: 'Name of the unordered list (for logging)',
+    },
+    columnOptions: {
+      type: 'ref',
+      required: true,
+      description: 'Array of column property options (for logging)',
+    },
+  },
+
+  fn(inputs) {
+    const {
+      focalboardCards,
+      cardOrder,
+      columnPropertyId,
+      listIdByOptionId,
+      unorderedListId,
+      unorderedListName,
+      columnOptions,
+    } = inputs;
+
+    console.log('');
+    console.log('--- Grouping Cards by Column ---');
+    console.log(`Cards in cardOrder: ${cardOrder.length}`);
+
+    // Group cards by their column assignment
+    const cardsByListId = {};
+
+    // Initialize lists
+    Object.values(listIdByOptionId).forEach((listId) => {
+      cardsByListId[listId] = [];
+    });
+    cardsByListId[unorderedListId] = [];
+
+    // Map Focalboard card IDs to card objects
+    const focalboardCardById = {};
+    focalboardCards.forEach((card) => {
+      focalboardCardById[card.id] = card;
+    });
+
+    // Process cards in cardOrder first (maintains order)
+    let processedFromCardOrder = 0;
+    let cardsWithoutColumn = 0;
+    const processedCardIds = new Set();
+
+    cardOrder.forEach((cardId) => {
+      const card = focalboardCardById[cardId];
+      if (!card) return;
+
+      processedCardIds.add(cardId);
+
+      const columnValue = card.fields?.properties?.[columnPropertyId];
+      const listId = listIdByOptionId[columnValue];
+
+      if (listId) {
+        cardsByListId[listId].push(card);
+      } else {
+        cardsByListId[unorderedListId].push(card);
+        cardsWithoutColumn += 1;
+      }
+
+      processedFromCardOrder += 1;
+    });
+
+    console.log(`Cards processed from cardOrder: ${processedFromCardOrder}`);
+
+    // Process cards not in cardOrder - place by column value, or Unordered if no column
+    let cardsNotInCardOrder = 0;
+    focalboardCards.forEach((card) => {
+      if (!processedCardIds.has(card.id)) {
+        const columnValue = card.fields?.properties?.[columnPropertyId];
+        const listId = listIdByOptionId[columnValue];
+
+        if (listId) {
+          cardsByListId[listId].push(card);
+        } else {
+          cardsByListId[unorderedListId].push(card);
+          cardsWithoutColumn += 1;
+        }
+
+        cardsNotInCardOrder += 1;
+      }
+    });
+
+    console.log(`Cards not in cardOrder (added to "${unorderedListName}"): ${cardsNotInCardOrder}`);
+    console.log(`Cards without column assignment: ${cardsWithoutColumn}`);
+
+    // Log card distribution
+    console.log('');
+    console.log('Card distribution by list:');
+    Object.entries(cardsByListId).forEach(([listId, cards]) => {
+      // Find list name
+      let listName = unorderedListName;
+      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
+        if (id === listId) {
+          const option = columnOptions.find((o) => o.id === optionId);
+          listName = option?.value || 'Unknown';
+          break;
+        }
+      }
+      console.log(`  ${listName}: ${cards.length} cards`);
+    });
+
+    return cardsByListId;
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-cards.js b/server/api/helpers/boards/import-focalboard-cards.js
new file mode 100644
index 000000000..182d2f734
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-cards.js
@@ -0,0 +1,234 @@
+/*!
+ * 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');
+
+/**
+ * @description :: Creates Planka cards from grouped Focalboard card data.
+ *                 Handles descriptions, due dates, label assignments, and custom field values.
+ */
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create cards in',
+    },
+    cardsByListId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Planka list ID to array of Focalboard cards',
+    },
+    textBlocks: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard text blocks (for descriptions)',
+    },
+    dueDatePropertyId: {
+      type: 'string',
+      allowNull: true,
+      description: 'Focalboard property ID for due date (null if not found)',
+    },
+    labelPropertyId: {
+      type: 'string',
+      allowNull: true,
+      description: 'Focalboard property ID for labels (null if not found)',
+    },
+    labelIdByFocalboardLabelId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard label ID to Planka label ID',
+    },
+    listIdByOptionId: {
+      type: 'ref',
+      required: true,
+      description: 'Map of Focalboard option ID to Planka list ID (for logging)',
+    },
+    columnOptions: {
+      type: 'ref',
+      required: true,
+      description: 'Array of column property options (for logging)',
+    },
+    unorderedListName: {
+      type: 'string',
+      required: true,
+      description: 'Name of the unordered list (for logging)',
+    },
+    customFieldGroup: {
+      type: 'ref',
+      description: 'Planka CustomFieldGroup for this board (null if no custom fields)',
+    },
+    customFieldIdByFocalboardPropertyId: {
+      type: 'ref',
+      description: 'Map of Focalboard property ID to Planka custom field ID',
+    },
+  },
+
+  async fn(inputs) {
+    const {
+      boardId,
+      cardsByListId,
+      textBlocks,
+      dueDatePropertyId,
+      labelPropertyId,
+      labelIdByFocalboardLabelId,
+      listIdByOptionId,
+      columnOptions,
+      unorderedListName,
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+    } = inputs;
+
+    console.log('');
+    console.log('--- Importing Cards ---');
+
+    // Build text block lookup by parent ID
+    const textBlocksByParentId = {};
+    textBlocks.forEach((block) => {
+      if (!textBlocksByParentId[block.parentId]) {
+        textBlocksByParentId[block.parentId] = [];
+      }
+      textBlocksByParentId[block.parentId].push(block);
+    });
+
+    const stats = {
+      totalCardsImported: 0,
+      cardsWithoutTitle: 0,
+      cardsWithDescriptions: 0,
+      cardsWithLabels: 0,
+      cardsWithDueDate: 0,
+      cardsWithCustomFields: 0,
+      customFieldValuesCreated: 0,
+    };
+
+    const hasCustomFields = customFieldGroup && customFieldIdByFocalboardPropertyId &&
+      Object.keys(customFieldIdByFocalboardPropertyId).length > 0;
+
+    // Process each list
+    for (const [listId, cards] of Object.entries(cardsByListId)) {
+      if (cards.length === 0) continue;
+
+      // Find list name for logging
+      let listName = unorderedListName;
+      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
+        if (id === listId) {
+          const option = columnOptions.find((o) => o.id === optionId);
+          listName = option?.value || 'Unknown';
+          break;
+        }
+      }
+
+      console.log(`Processing list "${listName}"...`);
+
+      await Promise.all(
+        cards.map(async (focalboardCard, index) => {
+          // Build description from text blocks
+          const cardTextBlocks = textBlocksByParentId[focalboardCard.id] || [];
+          const descriptionParts = cardTextBlocks
+            .map((block) => block.title?.trim())
+            .filter((text) => text);
+
+          const description = descriptionParts.length > 0 ? descriptionParts.join('\n\n') : null;
+
+          if (description) {
+            stats.cardsWithDescriptions += 1;
+          }
+
+          // Extract due date from Focalboard properties
+          let dueDate = null;
+          if (dueDatePropertyId) {
+            const dueDateRaw = focalboardCard.fields?.properties?.[dueDatePropertyId];
+            dueDate = sails.helpers.utils.parseFocalboardDate(dueDateRaw);
+
+            if (dueDate) {
+              stats.cardsWithDueDate += 1;
+            }
+          }
+
+          // Create card
+          const cardValues = {
+            boardId,
+            listId,
+            type: Card.Types.PROJECT,
+            position: POSITION_GAP * (index + 1),
+            name: focalboardCard.title?.trim() || 'Untitled',
+            description,
+            dueDate,
+            listChangedAt: new Date(focalboardCard.updateAt).toISOString(),
+          };
+
+          if (!focalboardCard.title?.trim()) {
+            stats.cardsWithoutTitle += 1;
+          }
+
+          const { id: cardId } = await Card.qm.createOne(cardValues);
+          stats.totalCardsImported += 1;
+
+          // Assign labels to card
+          if (labelPropertyId) {
+            const cardLabelIds = focalboardCard.fields?.properties?.[labelPropertyId];
+
+            if (Array.isArray(cardLabelIds) && cardLabelIds.length > 0) {
+              await Promise.all(
+                cardLabelIds.map(async (focalboardLabelId) => {
+                  const plankaLabelId = labelIdByFocalboardLabelId[focalboardLabelId];
+
+                  if (plankaLabelId) {
+                    await CardLabel.qm.createOne({
+                      cardId,
+                      labelId: plankaLabelId,
+                    });
+                  }
+                }),
+              );
+
+              stats.cardsWithLabels += 1;
+            }
+          }
+
+          // Create custom field values
+          if (hasCustomFields) {
+            let cardHasCustomFields = false;
+
+            await Promise.all(
+              Object.entries(customFieldIdByFocalboardPropertyId).map(
+                async ([focalboardPropertyId, plankaCustomFieldId]) => {
+                  const rawValue = focalboardCard.fields?.properties?.[focalboardPropertyId];
+
+                  // Skip empty values
+                  if (rawValue === null || rawValue === undefined || rawValue === '') {
+                    return;
+                  }
+
+                  // Convert value to string (Planka stores all custom field values as strings)
+                  const content = String(rawValue);
+
+                  await CustomFieldValue.qm.createOrUpdateOne({
+                    cardId,
+                    customFieldGroupId: customFieldGroup.id,
+                    customFieldId: plankaCustomFieldId,
+                    content,
+                  });
+
+                  stats.customFieldValuesCreated += 1;
+                  cardHasCustomFields = true;
+                },
+              ),
+            );
+
+            if (cardHasCustomFields) {
+              stats.cardsWithCustomFields += 1;
+            }
+          }
+        }),
+      );
+
+      console.log(`Created ${cards.length} cards`);
+    }
+
+    return stats;
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-custom-fields.js b/server/api/helpers/boards/import-focalboard-custom-fields.js
new file mode 100644
index 000000000..47f2384c5
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-custom-fields.js
@@ -0,0 +1,112 @@
+/*!
+ * 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');
+
+/**
+ * @description :: Creates Planka custom field group and fields from Focalboard properties.
+ *                 Returns the group and field mapping for use during card import.
+ */
+
+// Custom field group name in Planka
+const CUSTOM_FIELD_GROUP_NAME = 'Custom fields';
+
+// Focalboard property names to import as custom fields
+// These will be looked up by name in boardBlock.cardProperties
+const CUSTOM_FIELD_NAMES_TO_IMPORT = [
+  'Автор',
+  'Google Doc',
+  'Редактор',
+  'Название поста',
+  'Иллюстратор',
+  'Обложка',
+  'Одобряющий',
+  'Trello URL',
+  'Текст',
+];
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create custom fields in',
+    },
+    cardProperties: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard card properties from boardBlock.cardProperties',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, cardProperties } = inputs;
+
+    console.log('');
+    console.log('--- Creating Custom Fields ---');
+
+    if (CUSTOM_FIELD_NAMES_TO_IMPORT.length === 0) {
+      console.log('No custom fields configured for import');
+      return {
+        customFieldGroup: null,
+        customFieldIdByFocalboardPropertyId: {},
+      };
+    }
+
+    // Find Focalboard properties by name
+    const propertiesToImport = [];
+    for (const fieldName of CUSTOM_FIELD_NAMES_TO_IMPORT) {
+      const property = cardProperties.find((p) => p.name === fieldName);
+      if (property) {
+        propertiesToImport.push(property);
+      } else {
+        console.log(`  Warning: Property "${fieldName}" not found in Focalboard data, skipping`);
+      }
+    }
+
+    if (propertiesToImport.length === 0) {
+      console.log('No matching custom fields found in Focalboard data');
+      return {
+        customFieldGroup: null,
+        customFieldIdByFocalboardPropertyId: {},
+      };
+    }
+
+    console.log(`Custom fields to import: ${propertiesToImport.length}`);
+
+
+    // Step 1: Create CustomFieldGroup for the board
+    const customFieldGroup = await CustomFieldGroup.qm.createOne({
+      boardId,
+      position: POSITION_GAP,
+      name: CUSTOM_FIELD_GROUP_NAME,
+    });
+
+    console.log(`Created custom field group: "${CUSTOM_FIELD_GROUP_NAME}" (${customFieldGroup.id})`);
+
+    // Step 2: Create CustomField entries for each configured property
+    const customFieldIdByFocalboardPropertyId = {};
+
+    await Promise.all(
+      propertiesToImport.map(async (focalboardProperty, index) => {
+        const customField = await CustomField.qm.createOne({
+          customFieldGroupId: customFieldGroup.id,
+          position: POSITION_GAP * (index + 1),
+          name: focalboardProperty.name,
+        });
+
+        customFieldIdByFocalboardPropertyId[focalboardProperty.id] = customField.id;
+        console.log(`  Created custom field: "${focalboardProperty.name}" (${focalboardProperty.type})`);
+      }),
+    );
+
+    console.log(`Total custom fields created: ${Object.keys(customFieldIdByFocalboardPropertyId).length}`);
+
+    return {
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+    };
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-labels.js b/server/api/helpers/boards/import-focalboard-labels.js
new file mode 100644
index 000000000..439c9925c
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-labels.js
@@ -0,0 +1,58 @@
+/*!
+ * 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');
+
+/**
+ * @description :: Creates Planka labels from Focalboard label data.
+ */
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create labels in',
+    },
+    focalboardLabels: {
+      type: 'ref',
+      required: true,
+      description: 'Array of Focalboard label options',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, focalboardLabels } = inputs;
+
+    console.log('');
+    console.log('--- Creating Labels ---');
+
+    const labelIdByFocalboardLabelId = {};
+
+    if (focalboardLabels.length > 0) {
+      await Promise.all(
+        focalboardLabels.map(async (focalboardLabel, index) => {
+          const plankaColor = sails.helpers.utils.convertFocalboardLabelColor(focalboardLabel.color);
+
+          const { id } = await Label.qm.createOne({
+            boardId,
+            position: POSITION_GAP * (index + 1),
+            name: focalboardLabel.value || null,
+            color: plankaColor,
+          });
+
+          labelIdByFocalboardLabelId[focalboardLabel.id] = id;
+          console.log(`Created label: "${focalboardLabel.value}" (${focalboardLabel.color} → ${plankaColor})`);
+        }),
+      );
+    } else {
+      console.log('No labels to import');
+    }
+
+    console.log(`Total labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
+
+    return labelIdByFocalboardLabelId;
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-lists.js b/server/api/helpers/boards/import-focalboard-lists.js
new file mode 100644
index 000000000..aef3f20b7
--- /dev/null
+++ b/server/api/helpers/boards/import-focalboard-lists.js
@@ -0,0 +1,79 @@
+/*!
+ * 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');
+
+/**
+ * @description :: Creates Planka lists from Focalboard column options.
+ */
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      required: true,
+      description: 'Planka board ID to create lists in',
+    },
+    visibleOptionIds: {
+      type: 'ref',
+      required: true,
+      description: 'Array of visible column option IDs from Kanban view',
+    },
+    columnOptions: {
+      type: 'ref',
+      required: true,
+      description: 'Array of column property options from Focalboard board',
+    },
+  },
+
+  async fn(inputs) {
+    const { boardId, visibleOptionIds, columnOptions } = inputs;
+
+    console.log('');
+    console.log('--- Creating Lists ---');
+    console.log(`Visible columns: ${visibleOptionIds.length}`);
+
+    const listIdByOptionId = {};
+
+    await Promise.all(
+      visibleOptionIds.map(async (optionId, index) => {
+        const option = columnOptions.find((opt) => opt.id === optionId);
+
+        if (!option) {
+          console.log(`  [${index}] Option not found: ${optionId}`);
+          return;
+        }
+
+        const { id } = await List.qm.createOne({
+          boardId,
+          type: List.Types.ACTIVE,
+          position: POSITION_GAP * (index + 1),
+          name: option.value,
+        });
+
+        listIdByOptionId[optionId] = id;
+        console.log(`  [${index}] Created list: "${option.value}" (position: ${POSITION_GAP * (index + 1)})`);
+      }),
+    );
+
+    console.log(`  ✓ Created ${Object.keys(listIdByOptionId).length} lists`);
+
+    // Create an "Unordered" list for cards not in cardOrder or without column
+    const unorderedListName = 'Unordered';
+    const { id: unorderedListId } = await List.qm.createOne({
+      boardId,
+      type: List.Types.ACTIVE,
+      position: POSITION_GAP * (visibleOptionIds.length + 1),
+      name: unorderedListName,
+    });
+    console.log(`Created "${unorderedListName}" list (position: ${POSITION_GAP * (visibleOptionIds.length + 1)})`);
+
+    return {
+      listIdByOptionId,
+      unorderedListId,
+      unorderedListName,
+    };
+  },
+};
diff --git a/server/api/helpers/boards/import-from-focalboard.js b/server/api/helpers/boards/import-from-focalboard.js
index 213db70f9..8089b96f3 100644
--- a/server/api/helpers/boards/import-from-focalboard.js
+++ b/server/api/helpers/boards/import-from-focalboard.js
@@ -3,7 +3,8 @@
  * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
  */
 
-const { POSITION_GAP } = require('../../../constants');
+// Focalboard property name for due date (will be looked up by name)
+const DUE_DATE_PROPERTY_NAME = 'Дедлайн';
 
 module.exports = {
   inputs: {
@@ -57,269 +58,94 @@ module.exports = {
     console.log(`Column property: ${columnProperty.name} (${columnProperty.type})`);
     console.log(`Total column options: ${columnProperty.options.length}`);
 
-    // =====================================================
-    // LABELS SECTION
-    // =====================================================
-
-    console.log('');
-    console.log('--- Creating Labels ---');
-
-    const labelIdByFocalboardLabelId = {};
-
-    if (focalboardLabels.length > 0) {
-      await Promise.all(
-        focalboardLabels.map(async (focalboardLabel, index) => {
-          const plankaColor = sails.helpers.utils.convertFocalboardLabelColor(focalboardLabel.color);
-
-          const { id } = await Label.qm.createOne({
-            boardId: inputs.board.id,
-            position: POSITION_GAP * (index + 1),
-            name: focalboardLabel.value || null,
-            color: plankaColor,
-          });
+    // Find the due date property by name
+    const dueDateProperty = boardBlock.cardProperties?.find(
+      (p) => p.name === DUE_DATE_PROPERTY_NAME && p.type === 'date'
+    );
+    const dueDatePropertyId = dueDateProperty?.id || null;
 
-          labelIdByFocalboardLabelId[focalboardLabel.id] = id;
-          console.log(`Created label: "${focalboardLabel.value}" (${focalboardLabel.color} → ${plankaColor})`);
-        }),
-      );
+    if (dueDatePropertyId) {
+      console.log(`Due date property found: "${DUE_DATE_PROPERTY_NAME}" (${dueDatePropertyId})`);
     } else {
-      console.log('No labels to import');
+      console.log(`Due date property "${DUE_DATE_PROPERTY_NAME}" not found, skipping due dates`);
     }
 
-    console.log(`Total labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
-
     // =====================================================
-    // LISTS SECTION
+    // IMPORT LABELS
     // =====================================================
-    console.log('');
-    console.log('--- Creating Lists ---');
-    const visibleOptionIds = kanbanView.fields?.visibleOptionIds || [];
-    const listIdByOptionId = {};
-
-    console.log(`Visible columns: ${visibleOptionIds.length}`);
-
-    await Promise.all(
-      visibleOptionIds.map(async (optionId, index) => {
-        const option = columnProperty.options.find((opt) => opt.id === optionId);
-
-        if (!option) {
-          console.log(`  [${index}] Option not found: ${optionId}`);
-          return;
-        }
-
-        const { id } = await List.qm.createOne({
-          boardId: inputs.board.id,
-          type: List.Types.ACTIVE,
-          position: POSITION_GAP * (index + 1),
-          name: option.value,
-        });
 
-        listIdByOptionId[optionId] = id;
-        console.log(`  [${index}] Created list: "${option.value}" (position: ${POSITION_GAP * (index + 1)})`);
-      })
+    const labelIdByFocalboardLabelId = await sails.helpers.boards.importFocalboardLabels(
+      inputs.board.id,
+      focalboardLabels,
     );
 
-    console.log(`  ✓ Created ${Object.keys(listIdByOptionId).length} lists`);
-
-    // Create an "Unordered" list for cards not in cardOrder or without column
-    const unorderedListName = 'Unordered';
-    const { id: unorderedListId } = await List.qm.createOne({
-      boardId: inputs.board.id,
-      type: List.Types.ACTIVE,
-      position: POSITION_GAP * (visibleOptionIds.length + 1),
-      name: unorderedListName,
-    });
-    console.log(`Created "${unorderedListName}" list (position: ${POSITION_GAP * (visibleOptionIds.length + 1)})`);
-
     // =====================================================
-    // GROUP CARDS BY COLUMN
+    // LISTS SECTION
     // =====================================================
-    console.log('');
-    console.log('--- Grouping Cards by Column ---');
-
-    // Build card order map
-    const cardOrder = kanbanView.fields.cardOrder || [];
-    console.log(`Cards in cardOrder: ${cardOrder.length}`);
-
-    // Group cards by their column assignment
-    const cardsByListId = {};
-
-    // Initialize lists
-    Object.values(listIdByOptionId).forEach((listId) => {
-      cardsByListId[listId] = [];
-    });
-    cardsByListId[unorderedListId] = [];
-
-    // Map Focalboard card IDs to card objects
-    const focalboardCardById = {};
-    focalboardCards.forEach((card) => {
-      focalboardCardById[card.id] = card;
-    });
-
-    // Process cards in cardOrder first (maintains order)
-    let processedFromCardOrder = 0;
-    let cardsWithoutColumn = 0;
-    const processedCardIds = new Set();
-
-    cardOrder.forEach((cardId) => {
-      const card = focalboardCardById[cardId];
-      if (!card) return;
-
-      processedCardIds.add(cardId);
-
-      const columnValue = card.fields?.properties?.[columnPropertyId];
-      const listId = listIdByOptionId[columnValue];
-
-      if (listId) {
-        cardsByListId[listId].push(card);
-      } else {
-        cardsByListId[unorderedListId].push(card);
-        cardsWithoutColumn += 1;
-      }
-
-      processedFromCardOrder += 1;
-    });
-
-    console.log(`Cards processed from cardOrder: ${processedFromCardOrder }`);
-
-    // Process cards not in cardOrder - place by column value, or Unordered if no column
-    let cardsNotInCardOrder = 0;
-    focalboardCards.forEach((card) => {
-      if (!processedCardIds.has(card.id)) {
-        const columnValue = card.fields?.properties?.[columnPropertyId];
-        const listId = listIdByOptionId[columnValue];
-
-        if (listId) {
-          cardsByListId[listId].push(card);
-        } else {
-          cardsByListId[unorderedListId].push(card);
-          cardsWithoutColumn += 1;
-        }
+    const { listIdByOptionId, unorderedListId, unorderedListName } =
+      await sails.helpers.boards.importFocalboardLists(
+        inputs.board.id,
+        kanbanView.fields?.visibleOptionIds || [],
+        columnProperty.options,
+      );
 
-        cardsNotInCardOrder += 1;
-      }
-    });
+    // =====================================================
+    // GROUP CARDS BY LIST
+    // =====================================================
+    const cardsByListId = sails.helpers.boards.groupFocalboardCardsByList(
+      focalboardCards,
+      kanbanView.fields.cardOrder || [],
+      columnPropertyId,
+      listIdByOptionId,
+      unorderedListId,
+      unorderedListName,
+      columnProperty.options,
+    );
 
-    console.log(`Cards not in cardOrder (added to "${unorderedListName}"): ${cardsNotInCardOrder}`);
-    console.log(`Cards without column assignment: ${cardsWithoutColumn}`);
+    // =====================================================
+    // IMPORT CUSTOM FIELDS
+    // =====================================================
 
-    // Log carddistribution
-    console.log('');
-    console.log('Card distribution by list:');
-    Object.entries(cardsByListId).forEach(([listId, cards]) => {
-      // Find list name
-      let listName = unorderedListName;
-      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
-        if (id === listId) {
-          const option = columnProperty.options?.find((o) => o.id === optionId);
-          listName = option?.value || 'Unknown';
-          break;
-        }
-      }
-      console.log(`  ${listName}: ${cards.length} cards`);
-    });
+    const { customFieldGroup, customFieldIdByFocalboardPropertyId } =
+    await sails.helpers.boards.importFocalboardCustomFields(
+      inputs.board.id,
+      boardBlock.cardProperties || [],
+    );
 
     // =====================================================
     // IMPORT CARDS
     // =====================================================
-    console.log('');
-    console.log('--- Importing Cards ---');
-
-    // Build text block lookup by parent ID
-    const textBlocksByParentId = {};
-    textBlocks.forEach((block) => {
-      if (!textBlocksByParentId[block.parentId]) {
-        textBlocksByParentId[block.parentId] = [];
-      }
-      textBlocksByParentId[block.parentId].push(block);
-    });
-
-
-    let totalCardsImported = 0;
-    let cardsWithoutTitle = 0;
-    let cardsWithDescriptions = 0;
-    let cardsWithLabels = 0;
-
-
-    // Process each list
-    for (const [listId, cards] of Object.entries(cardsByListId)) {
-      if (cards.length === 0) continue;
-
-      // Find list name for logging
-      let listName = unorderedListName;
-      for (const [optionId, id] of Object.entries(listIdByOptionId)) {
-        if (id === listId) {
-          const option = columnProperty.options?.find((o) => o.id === optionId);
-          listName = option?.value || 'Unknown';
-          break;
-        }
-      }
 
-      console.log(`Processing list "${listName}"...`);
-
-      await Promise.all(
-        cards.map(async (focalboardCard, index) => {
-          // Build description from text blocks
-          const cardTextBlocks = textBlocksByParentId[focalboardCard.id] || [];
-          const descriptionParts = cardTextBlocks
-            .map((block) => block.title?.trim())
-            .filter((text) => text);
-
-          const description = descriptionParts.length > 0 ? descriptionParts.join('\n\n') : null;
-
-          if (description) {
-            cardsWithDescriptions += 1;
-          }
-
-          // Create card
-          const cardValues = {
-            boardId: inputs.board.id,
-            listId,
-            type: Card.Types.PROJECT,
-            position: POSITION_GAP * (index + 1),
-            name: focalboardCard.title?.trim() || 'Untitled',
-            description,
-            listChangedAt: new Date(focalboardCard.updateAt).toISOString(),
-          };
-
-          const { id: cardId } = await Card.qm.createOne(cardValues);
-          totalCardsImported++;
-
-          // Assign labels to card
-          if (labelPropertyId) {
-            const cardLabelIds = focalboardCard.fields?.properties?.[labelPropertyId];
-
-            if (Array.isArray(cardLabelIds) && cardLabelIds.length > 0) {
-              await Promise.all(
-                cardLabelIds.map(async (focalboardLabelId) => {
-                  const plankaLabelId = labelIdByFocalboardLabelId[focalboardLabelId];
-
-                  if (plankaLabelId) {
-                    await CardLabel.qm.createOne({
-                      cardId,
-                      labelId: plankaLabelId,
-                    });
-                  }
-                }),
-              );
-
-              cardsWithLabels += 1;
-            }
-          }
-        })
-      );
+    const stats = await sails.helpers.boards.importFocalboardCards(
+      inputs.board.id,
+      cardsByListId,
+      textBlocks,
+      dueDatePropertyId,
+      labelPropertyId,
+      labelIdByFocalboardLabelId,
+      listIdByOptionId,
+      columnProperty.options,
+      unorderedListName,
+      customFieldGroup,
+      customFieldIdByFocalboardPropertyId,
+    );
 
-      console.log(`Created ${cards.length} cards`);
-    }
+    // =====================================================
+    // SUMMARY
+    // =====================================================
 
     console.log('');
     console.log('=== Import Complete ===');
-    console.log(`Total cards imported: ${totalCardsImported}`);
-    console.log(`Cards without title (named "Untitled"): ${cardsWithoutTitle}`);
-    console.log(`Cards with descriptions: ${cardsWithDescriptions}`);
-    console.log(`Cards with labels: ${cardsWithLabels}`);
+    console.log(`Total cards imported: ${stats.totalCardsImported}`);
+    console.log(`Cards without title (named "Untitled"): ${stats.cardsWithoutTitle}`);
+    console.log(`Cards with descriptions: ${stats.cardsWithDescriptions}`);
+    console.log(`Cards with labels: ${stats.cardsWithLabels}`);
+    console.log(`Cards with due date: ${stats.cardsWithDueDate}`);
+    console.log(`Cards with custom fields: ${stats.cardsWithCustomFields}`);
+    console.log(`Custom field values created: ${stats.customFieldValuesCreated}`);
     console.log(`Labels created: ${Object.keys(labelIdByFocalboardLabelId).length}`);
     console.log(`Lists created: ${Object.keys(listIdByOptionId).length + 1} (including "${unorderedListName}")`);
+    console.log(`Custom fields created: ${Object.keys(customFieldIdByFocalboardPropertyId).length}`);
     console.log('');
   },
 };
diff --git a/server/api/helpers/utils/convert-focalboard-label-color.js b/server/api/helpers/utils/convert-focalboard-label-color.js
index 414db19b3..0660d60e2 100644
--- a/server/api/helpers/utils/convert-focalboard-label-color.js
+++ b/server/api/helpers/utils/convert-focalboard-label-color.js
@@ -4,11 +4,7 @@
  */
 
 /**
- * convert-focalboard-label-color.js
- *
  * @description :: Converts Focalboard color names to Planka label colors.
- *
- * Location: server/api/helpers/utils/convert-focalboard-label-color.js
  */
 
 module.exports = {
diff --git a/server/api/helpers/utils/parse-focalboard-date.js b/server/api/helpers/utils/parse-focalboard-date.js
new file mode 100644
index 000000000..d10ff9816
--- /dev/null
+++ b/server/api/helpers/utils/parse-focalboard-date.js
@@ -0,0 +1,35 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @description :: Parses Focalboard date property value to ISO string.
+ *                 Focalboard stores dates as JSON string: '{"to":1633002840000}' or '{"from":1633002840000}'
+ */
+
+module.exports = {
+  sync: true,
+
+  inputs: {
+    dateValue: {
+      type: 'string',
+      description: 'Focalboard date value as JSON string (e.g., \'{"to":1633002840000}\')',
+    },
+  },
+
+  fn(inputs) {
+    if (!inputs.dateValue) return null;
+
+    try {
+      const dateJson = JSON.parse(inputs.dateValue);
+      const timestamp = dateJson.to || dateJson.from;
+
+      if (!timestamp) return null;
+
+      return new Date(timestamp).toISOString();
+    } catch (error) {
+      return null;
+    }
+  },
+};

From 24baaeec00c7831391809d7b7b942a01c54dcdeb Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Sun, 18 Jan 2026 18:11:36 +0200
Subject: [PATCH 5/9] fix: focalboard cards considered uncompleted to dueDate

---
 server/api/helpers/boards/import-focalboard-cards.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/server/api/helpers/boards/import-focalboard-cards.js b/server/api/helpers/boards/import-focalboard-cards.js
index 182d2f734..74792769d 100644
--- a/server/api/helpers/boards/import-focalboard-cards.js
+++ b/server/api/helpers/boards/import-focalboard-cards.js
@@ -157,6 +157,7 @@ module.exports = {
             name: focalboardCard.title?.trim() || 'Untitled',
             description,
             dueDate,
+            isDueCompleted: dueDate ? false : null,
             listChangedAt: new Date(focalboardCard.updateAt).toISOString(),
           };
 

From 23b03ce428ad142542f10ae9393c14889824288c Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Mon, 19 Jan 2026 00:09:01 +0200
Subject: [PATCH 6/9] feat: server accepts setup

---
 server/api/controllers/boards/create.js       |  18 +-
 server/api/controllers/focalboard/preview.js  | 199 +++++++++++++++++
 .../boards/import-focalboard-custom-fields.js |  45 +---
 .../helpers/boards/import-from-focalboard.js  |  69 +++---
 .../helpers/boards/parse-focalboard-file.js   | 155 +++++++++++++
 ...process-uploaded-focalboard-import-file.js | 204 +++++++-----------
 server/config/routes.js                       |   2 +
 7 files changed, 492 insertions(+), 200 deletions(-)
 create mode 100644 server/api/controllers/focalboard/preview.js
 create mode 100644 server/api/helpers/boards/parse-focalboard-file.js

diff --git a/server/api/controllers/boards/create.js b/server/api/controllers/boards/create.js
index 0ba4ffc8a..428001a85 100755
--- a/server/api/controllers/boards/create.js
+++ b/server/api/controllers/boards/create.js
@@ -49,6 +49,10 @@
  *                 type: string
  *                 format: binary
  *                 description: Import file
+*               importMapping:
+ *                 type: string
+ *                 description: JSON object with property mappings for Focalboard import
+ *                 example: '{"columnPropertyId":"...","labelPropertyId":"...","dueDatePropertyId":"...","customFieldPropertyIds":["...","..."]}'
  *               requestId:
  *                 type: string
  *                 maxLength: 128
@@ -139,6 +143,10 @@ module.exports = {
       type: 'string',
       isIn: Object.values(Board.ImportTypes),
     },
+    importMapping: {
+      type: 'json',
+      description: 'Property mappings for Focalboard import: { columnPropertyId, labelPropertyId, dueDatePropertyId, customFieldPropertyIds[] }',
+    },
     requestId: {
       type: 'string',
       isNotEmptyString: true,
@@ -201,8 +209,16 @@ module.exports = {
           board: trelloBoard,
         };
       } else if (inputs.importType === Board.ImportTypes.FOCALBOARD) {
+        const mapping = inputs.importMapping || {};
+
         const focalboardData = await sails.helpers.boards
-          .processUploadedFocalboardImportFile(file)
+          .processUploadedFocalboardImportFile.with({
+            file,
+            columnPropertyId: mapping.columnPropertyId,
+            labelPropertyId: mapping.labelPropertyId,
+            dueDatePropertyId: mapping.dueDatePropertyId,
+            customFieldPropertyIds: mapping.customFieldPropertyIds || [],
+          })
           .intercept('invalidFile', () => Errors.INVALID_IMPORT_FILE);
 
         boardImport = {
diff --git a/server/api/controllers/focalboard/preview.js b/server/api/controllers/focalboard/preview.js
new file mode 100644
index 000000000..696f509df
--- /dev/null
+++ b/server/api/controllers/focalboard/preview.js
@@ -0,0 +1,199 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+/**
+ * @swagger
+ * /focalboard/preview:
+ *   post:
+ *     summary: Preview Focalboard import file
+ *     description: Parses a Focalboard JSONL export file and returns available properties for user selection before import.
+ *     tags:
+ *       - Focalboard
+ *     operationId: previewFocalboardImport
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         multipart/form-data:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - file
+ *             properties:
+ *               file:
+ *                 type: string
+ *                 format: binary
+ *                 description: Focalboard JSONL export file
+ *     responses:
+ *       200:
+ *         description: File parsed successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               required:
+ *                 - board
+ *                 - properties
+ *                 - views
+ *               properties:
+ *                 board:
+ *                   type: object
+ *                   properties:
+ *                     id:
+ *                       type: string
+ *                     title:
+ *                       type: string
+ *                     description:
+ *                       type: string
+ *                 properties:
+ *                   type: array
+ *                   description: Available card properties for mapping
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                       name:
+ *                         type: string
+ *                       type:
+ *                         type: string
+ *                         enum: [text, number, select, multiSelect, date, person, multiPerson, file, checkbox, url, email, phone, createdTime, createdBy, updatedTime, updatedBy, unknown]
+ *                       options:
+ *                         type: array
+ *                         description: Options for select/multiSelect properties
+ *                         items:
+ *                           type: object
+ *                           properties:
+ *                             id:
+ *                               type: string
+ *                             value:
+ *                               type: string
+ *                             color:
+ *                               type: string
+ *                 views:
+ *                   type: array
+ *                   description: Available views (for column property detection)
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                       title:
+ *                         type: string
+ *                       type:
+ *                         type: string
+ *                       groupById:
+ *                         type: string
+ *                         description: Property ID used for column grouping in this view
+ *                 stats:
+ *                   type: object
+ *                   properties:
+ *                     totalCards:
+ *                       type: number
+ *                     totalTextBlocks:
+ *                       type: number
+ *       401:
+ *         $ref: '#/components/responses/Unauthorized'
+ *       422:
+ *         description: File upload or parsing error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 code:
+ *                   type: string
+ *                 message:
+ *                   type: string
+ */
+
+const Errors = {
+  NO_FILE_WAS_UPLOADED: {
+    noFileWasUploaded: 'No file was uploaded',
+  },
+  INVALID_FILE: {
+    invalidFile: 'Invalid Focalboard export file',
+  },
+};
+
+module.exports = {
+  inputs: {},
+
+  exits: {
+    noFileWasUploaded: {
+      responseType: 'unprocessableEntity',
+    },
+    invalidFile: {
+      responseType: 'unprocessableEntity',
+    },
+    uploadError: {
+      responseType: 'unprocessableEntity',
+    },
+  },
+
+  async fn(inputs, exits) {
+    // Require authentication
+    const { currentUser } = this.req;
+    if (!currentUser) {
+      throw { unauthorized: 'Unauthorized' };
+    }
+
+    // Receive uploaded file
+    let files;
+    try {
+      files = await sails.helpers.utils.receiveFile(this.req.file('file'), false);
+    } catch (error) {
+      return exits.uploadError(error.message);
+    }
+
+    if (files.length === 0) {
+      throw Errors.NO_FILE_WAS_UPLOADED;
+    }
+
+    const file = _.last(files);
+
+    // Parse the Focalboard file
+    let focalboardData;
+    try {
+      focalboardData = await sails.helpers.boards.parseFocalboardFile(file);
+    } catch (error) {
+      if (error === 'invalidFile' || error.code === 'invalidFile') {
+        throw Errors.INVALID_FILE;
+      }
+      throw error;
+    }
+
+    const { board, views, cards, textBlocks } = focalboardData;
+
+    // Build response with properties for user selection
+    const properties = (board.cardProperties || []).map((prop) => ({
+      id: prop.id,
+      name: prop.name,
+      type: prop.type,
+      options: prop.options || [],
+    }));
+
+    // Extract view info for column property detection
+    const viewsInfo = views.map((view) => ({
+      id: view.id,
+      title: view.title,
+      type: view.fields?.viewType || 'unknown',
+      groupById: view.fields?.groupById || null,
+    }));
+
+    return exits.success({
+      board: {
+        id: board.id,
+        title: board.title,
+        description: board.description || null,
+      },
+      properties,
+      views: viewsInfo,
+      stats: {
+        totalCards: cards.length,
+        totalTextBlocks: textBlocks.length,
+      },
+    });
+  },
+};
diff --git a/server/api/helpers/boards/import-focalboard-custom-fields.js b/server/api/helpers/boards/import-focalboard-custom-fields.js
index 47f2384c5..07201ae07 100644
--- a/server/api/helpers/boards/import-focalboard-custom-fields.js
+++ b/server/api/helpers/boards/import-focalboard-custom-fields.js
@@ -13,20 +13,6 @@ const { POSITION_GAP } = require('../../../constants');
 // Custom field group name in Planka
 const CUSTOM_FIELD_GROUP_NAME = 'Custom fields';
 
-// Focalboard property names to import as custom fields
-// These will be looked up by name in boardBlock.cardProperties
-const CUSTOM_FIELD_NAMES_TO_IMPORT = [
-  'Автор',
-  'Google Doc',
-  'Редактор',
-  'Название поста',
-  'Иллюстратор',
-  'Обложка',
-  'Одобряющий',
-  'Trello URL',
-  'Текст',
-];
-
 module.exports = {
   inputs: {
     boardId: {
@@ -34,47 +20,28 @@ module.exports = {
       required: true,
       description: 'Planka board ID to create custom fields in',
     },
-    cardProperties: {
+    customFieldProperties: {
       type: 'ref',
       required: true,
-      description: 'Array of Focalboard card properties from boardBlock.cardProperties',
+      description: 'Array of Focalboard property objects to import as custom fields',
     },
   },
 
   async fn(inputs) {
-    const { boardId, cardProperties } = inputs;
+    const { boardId, customFieldProperties } = inputs;
 
     console.log('');
     console.log('--- Creating Custom Fields ---');
 
-    if (CUSTOM_FIELD_NAMES_TO_IMPORT.length === 0) {
-      console.log('No custom fields configured for import');
-      return {
-        customFieldGroup: null,
-        customFieldIdByFocalboardPropertyId: {},
-      };
-    }
-
-    // Find Focalboard properties by name
-    const propertiesToImport = [];
-    for (const fieldName of CUSTOM_FIELD_NAMES_TO_IMPORT) {
-      const property = cardProperties.find((p) => p.name === fieldName);
-      if (property) {
-        propertiesToImport.push(property);
-      } else {
-        console.log(`  Warning: Property "${fieldName}" not found in Focalboard data, skipping`);
-      }
-    }
-
-    if (propertiesToImport.length === 0) {
-      console.log('No matching custom fields found in Focalboard data');
+    if (!customFieldProperties || customFieldProperties.length === 0) {
+      console.log('No custom fields to import');
       return {
         customFieldGroup: null,
         customFieldIdByFocalboardPropertyId: {},
       };
     }
 
-    console.log(`Custom fields to import: ${propertiesToImport.length}`);
+    console.log(`Custom fields to import: ${customFieldProperties.length}`);
 
 
     // Step 1: Create CustomFieldGroup for the board
diff --git a/server/api/helpers/boards/import-from-focalboard.js b/server/api/helpers/boards/import-from-focalboard.js
index 8089b96f3..eb4838c2b 100644
--- a/server/api/helpers/boards/import-from-focalboard.js
+++ b/server/api/helpers/boards/import-from-focalboard.js
@@ -3,8 +3,10 @@
  * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
  */
 
-// Focalboard property name for due date (will be looked up by name)
-const DUE_DATE_PROPERTY_NAME = 'Дедлайн';
+/**
+ * @description :: Main orchestrator for Focalboard import.
+ *                 Coordinates labels, lists, cards, and custom fields import.
+ */
 
 module.exports = {
   inputs: {
@@ -28,18 +30,14 @@ module.exports = {
       views,
       cards: focalboardCards,
       textBlocks,
+      // User selections (from processUploadedFocalboardImportFile)
+      columnProperty,
       labels: focalboardLabels,
       labelPropertyId,
+      dueDatePropertyId,
+      customFieldProperties,
     } = inputs.focalboardData;
 
-    console.log('');
-    console.log('=== Starting Focalboard Import ===');
-    console.log(`Board: ${boardBlock.title || 'Unknown'}`);
-    console.log(`Total views: ${views.length}`);
-    console.log(`Total cards: ${focalboardCards.length}`);
-    console.log(`Total text blocks: ${textBlocks.length}`);
-    console.log(`Total labels: ${focalboardLabels.length}`);
-
     // Find the Kanban view
     const kanbanView = views.find((view) => view.fields.viewType === 'board');
     if (!kanbanView) {
@@ -47,27 +45,27 @@ module.exports = {
     }
 
     console.log(`Using Kanban view: ${kanbanView.title}`);
-
-    // Find the column property (the one used for grouping in Kanban view)
-    const columnPropertyId = kanbanView.fields?.groupById;
-    const columnProperty = boardBlock.cardProperties?.find((p) => p.id === columnPropertyId);
-
-    if (!columnProperty) {
-      throw new Error('Column property not found in Focalboard export');
-    }
     console.log(`Column property: ${columnProperty.name} (${columnProperty.type})`);
     console.log(`Total column options: ${columnProperty.options.length}`);
 
-    // Find the due date property by name
-    const dueDateProperty = boardBlock.cardProperties?.find(
-      (p) => p.name === DUE_DATE_PROPERTY_NAME && p.type === 'date'
-    );
-    const dueDatePropertyId = dueDateProperty?.id || null;
+    if (labelPropertyId) {
+      console.log(`Label property ID: ${labelPropertyId}`);
+      console.log(`Total labels: ${focalboardLabels.length}`);
+    } else {
+      console.log('No label property selected');
+    }
 
     if (dueDatePropertyId) {
-      console.log(`Due date property found: "${DUE_DATE_PROPERTY_NAME}" (${dueDatePropertyId})`);
+      console.log(`Due date property ID: ${dueDatePropertyId}`);
     } else {
-      console.log(`Due date property "${DUE_DATE_PROPERTY_NAME}" not found, skipping due dates`);
+      console.log('No due date property selected');
+    }
+
+    if (customFieldProperties && customFieldProperties.length > 0) {
+      console.log(`Custom fields to import: ${customFieldProperties.length}`);
+      customFieldProperties.forEach((p) => console.log(`  - ${p.name} (${p.type})`));
+    } else {
+      console.log('No custom fields selected');
     }
 
     // =====================================================
@@ -76,7 +74,7 @@ module.exports = {
 
     const labelIdByFocalboardLabelId = await sails.helpers.boards.importFocalboardLabels(
       inputs.board.id,
-      focalboardLabels,
+      focalboardLabels || [],
     );
 
     // =====================================================
@@ -92,6 +90,9 @@ module.exports = {
     // =====================================================
     // GROUP CARDS BY LIST
     // =====================================================
+
+    const columnPropertyId = columnProperty.id;
+
     const cardsByListId = sails.helpers.boards.groupFocalboardCardsByList(
       focalboardCards,
       kanbanView.fields.cardOrder || [],
@@ -106,11 +107,17 @@ module.exports = {
     // IMPORT CUSTOM FIELDS
     // =====================================================
 
-    const { customFieldGroup, customFieldIdByFocalboardPropertyId } =
-    await sails.helpers.boards.importFocalboardCustomFields(
-      inputs.board.id,
-      boardBlock.cardProperties || [],
-    );
+    let customFieldGroup = null;
+    let customFieldIdByFocalboardPropertyId = {};
+
+    if (customFieldProperties && customFieldProperties.length > 0) {
+      const result = await sails.helpers.boards.importFocalboardCustomFields(
+        inputs.board.id,
+        customFieldProperties,
+      );
+      customFieldGroup = result.customFieldGroup;
+      customFieldIdByFocalboardPropertyId = result.customFieldIdByFocalboardPropertyId;
+    }
 
     // =====================================================
     // IMPORT CARDS
diff --git a/server/api/helpers/boards/parse-focalboard-file.js b/server/api/helpers/boards/parse-focalboard-file.js
new file mode 100644
index 000000000..91dbe00f6
--- /dev/null
+++ b/server/api/helpers/boards/parse-focalboard-file.js
@@ -0,0 +1,155 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+const fs = require('fs');
+const { rimraf } = require('rimraf');
+const readline = require('readline');
+
+/**
+ * @description :: Parses a Focalboard JSONL export file and returns structured data.
+ *                 Used by both preview endpoint and import flow.
+ */
+
+module.exports = {
+  inputs: {
+    file: {
+      type: 'json',
+      required: true,
+      description: 'Uploaded file object with fd (file descriptor)',
+    },
+  },
+
+  exits: {
+    invalidFile: {},
+  },
+
+  async fn(inputs) {
+    console.log('');
+    console.log('=== Parsing Focalboard JSONL File ===');
+
+    const fileStream = fs.createReadStream(inputs.file.fd);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity,
+    });
+
+    const data = {
+      board: null,
+      views: [],
+      cards: [],
+      textBlocks: [],
+    };
+
+    let lineCount = 0;
+    let emptyLines = 0;
+    let parseErrors = 0;
+    const unknownBlockTypes = new Set();
+
+    try {
+      for await (const line of rl) {
+        lineCount++;
+
+        if (!line.trim()) {
+          emptyLines++;
+          continue;
+        }
+
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch (error) {
+          parseErrors++;
+          console.warn(`Parse error on line ${lineCount}: ${error.message}`);
+          await rimraf(inputs.file.fd);
+          throw 'invalidFile';
+        }
+
+        // Focalboard exports have two formats:
+        // 1. Board: {"type":"board","data":{...}}
+        // 2. Blocks: {"type":"block","data":{...}}
+
+        let block;
+        if (parsed.type === 'board' && parsed.data) {
+          block = parsed.data;
+          data.board = block;
+          console.log(`Found board: "${block.title}"`);
+          continue;
+        } else if (parsed.type === 'block' && parsed.data) {
+          block = parsed.data;
+        } else {
+          console.warn(`Skipping line ${lineCount}: not a valid structure (type: ${parsed.type})`);
+          continue;
+        }
+
+        switch (block.type) {
+          case 'board':
+            data.board = block;
+            console.log(`Found board: "${block.title}"`);
+            break;
+          case 'view':
+            data.views.push(block);
+            console.log(`Found view: "${block.title}" (type: ${block.fields?.viewType || 'unknown'})`);
+            break;
+          case 'card':
+            data.cards.push(block);
+            break;
+          case 'text':
+            data.textBlocks.push(block);
+            break;
+          default:
+            unknownBlockTypes.add(block.type);
+            break;
+        }
+      }
+    } catch (error) {
+      await rimraf(inputs.file.fd);
+      if (error === 'invalidFile') {
+        throw error;
+      }
+      console.error('Unexpected error:', error);
+      throw 'invalidFile';
+    }
+
+    await rimraf(inputs.file.fd);
+
+    console.log('');
+    console.log('--- Parsing Summary ---');
+    console.log(`Total lines: ${lineCount}`);
+    console.log(`Empty lines: ${emptyLines}`);
+    console.log(`Board: ${data.board ? data.board.title : 'NOT FOUND'}`);
+    console.log(`Views: ${data.views.length}`);
+    console.log(`Cards: ${data.cards.length}`);
+    console.log(`Text blocks: ${data.textBlocks.length}`);
+
+    if (unknownBlockTypes.size > 0) {
+      console.log(`Unknown block types (ignored): ${Array.from(unknownBlockTypes).join(', ')}`);
+    }
+
+    if (parseErrors > 0) {
+      console.warn(`Parse errors: ${parseErrors}`);
+    }
+
+    // Validate minimum required data
+    if (!data.board) {
+      console.error('ERROR: No board block found');
+      throw 'invalidFile';
+    }
+
+    if (data.views.length === 0) {
+      console.error('ERROR: No view blocks found');
+      throw 'invalidFile';
+    }
+
+    if (data.cards.length === 0) {
+      console.error('ERROR: No card blocks found');
+      throw 'invalidFile';
+    }
+
+    console.log('✓ File parsed successfully');
+    console.log('');
+
+    return data;
+  },
+}
diff --git a/server/api/helpers/boards/process-uploaded-focalboard-import-file.js b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
index f4bbd89c5..879802136 100644
--- a/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
+++ b/server/api/helpers/boards/process-uploaded-focalboard-import-file.js
@@ -3,15 +3,32 @@
  * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
  */
 
-const fs = require('fs');
-const { rimraf } = require('rimraf');
-const readline = require('readline');
+/**
+ * @description :: Processes a Focalboard JSONL file for import, applying user's property selections.
+ */
 
 module.exports = {
   inputs: {
     file: {
       type: 'json',
       required: true,
+      description: 'Uploaded file object',
+    },
+    columnPropertyId: {
+      type: 'string',
+      description: 'Focalboard property ID to use for columns/lists',
+    },
+    labelPropertyId: {
+      type: 'string',
+      description: 'Focalboard property ID to use for labels',
+    },
+    dueDatePropertyId: {
+      type: 'string',
+      description: 'Focalboard property ID to use for due dates',
+    },
+    customFieldPropertyIds: {
+      type: 'ref',
+      description: 'Array of Focalboard property IDs to import as custom fields',
     },
   },
 
@@ -20,144 +37,73 @@ module.exports = {
   },
 
   async fn(inputs) {
-    console.log('');
-    console.log('=== Processing Focalboard JSONL File ===');
-
-    const fileStream = fs.createReadStream(inputs.file.fd);
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity,
-    });
-
-    const blocks = {
-      board: null,
-      views: [],
-      cards: [],
-      textBlocks: [],
-      labels: [],
-    };
-
-    // To log
-    let lineCount = 0;
-    let emptyLines = 0;
-    let parseErrors = 0;
-    const unknownBlockTypes = new Set()
-
-    try {
-      for await (const line of rl) {
-        lineCount++;
-
-        if (!line.trim()) {
-          emptyLines++;
-          continue;
-        }
-
-        let parsed;
-        try {
-          parsed = JSON.parse(line);
-        } catch (error) {
-          parseErrors++;
-          console.warn(`Parse error on line ${lineCount}: ${error.message}`);
-          await rimraf(inputs.file.fd);
-          throw 'invalidFile';
-        }
-
-        // Focalboard exports have two formats (for this version):
-        // 1. Board: {"type":"board","data":{...}}
-        // 2. Blocks: {"type":"block","data":{...}}
-
-        let block;
-        if (parsed.type === 'board' && parsed.data) {
-          // Board is exported as type: "board"
-          block = parsed.data;
-          blocks.board = block;
-          console.log(`Found board: "${block.title}"`);
-          continue;
-        } else if (parsed.type === 'block' && parsed.data) {
-          // Other blocks are type: "block"
-          block = parsed.data;
-        } else {
-          console.warn(`Skipping line ${lineCount}: not a valid structure (type: ${parsed.type})`);
-          continue;
-        }
 
-        if (blocks.board) {
-          const labelProperty = blocks.board.cardProperties?.find(
-            p => p.name === 'Рубрика' || p.type === 'multiSelect' // Sysblok-specific
-          );
-          if (labelProperty?.options) {
-            blocks.labels = labelProperty.options;
-            blocks.labelPropertyId = labelProperty.id; // Need this for card assignment
-          }
-        }
-
-        switch (block.type) {
-          case 'board':
-            blocks.board = block;
-            console.log(`Found board: "${block.title}"`);
-            break;
-          case 'view':
-            blocks.views.push(block);
-            console.log(`Found view: "${block.title}" (type: ${block.fields?.viewType || 'unknown'})`);
-            break;
-          case 'card':
-            blocks.cards.push(block);
-            break;
-          case 'text':
-            blocks.textBlocks.push(block);
-            break;
-          // We can ignore other block types for now (comment, attachment, etc.)
-          default:
-            break;
-        }
-      }
-    } catch (error) {
-      await rimraf(inputs.file.fd);
-      if (error === 'invalidFile') {
-        throw error;
-      }
-      console.error('Unexpected error:', error);
+    const {
+      file,
+      columnPropertyId,
+      labelPropertyId,
+      dueDatePropertyId,
+      customFieldPropertyIds,
+    } = inputs;
+
+    const data = await sails.helpers.boards
+    .parseFocalboardFile(file)
+    .intercept('invalidFile', () => 'invalidFile');
+    const { board, views, cards, textBlocks } = data;
+
+    // Find the Kanban view
+    const kanbanView = views.find((view) => view.fields?.viewType === 'board');
+    if (!kanbanView) {
+      console.error('ERROR: No Kanban view found');
       throw 'invalidFile';
     }
 
-    await rimraf(inputs.file.fd);
-
-    console.log('');
-    console.log('--- Parsing Summary ---');
-    console.log(`Total lines: ${lineCount}`);
-    console.log(`Empty lines: ${emptyLines}`);
-    console.log(`Board blocks: ${blocks.board ? 1 : 0}`);
-    console.log(`View blocks: ${blocks.views.length}`);
-    console.log(`Card blocks: ${blocks.cards.length}`);
-    console.log(`Text blocks: ${blocks.textBlocks.length}`);
-
-    if (unknownBlockTypes.size > 0) {
-      console.log(`Unknown block types (ignored): ${Array.from(unknownBlockTypes).join(', ')}`);
-    }
+    // Determine column property (user selection or from view)
+    const effectiveColumnPropertyId = columnPropertyId || kanbanView.fields?.groupById;
+    const columnProperty = board.cardProperties?.find((p) => p.id === effectiveColumnPropertyId);
 
-    if (parseErrors > 0) {
-      console.warn(`Parse errors: ${parseErrors}`);
-    }
-
-    // Validate that we have the minimum required data
-    if (!blocks.board) {
-      console.error('ERROR: No board block found');
+    if (!columnProperty) {
+      console.error('ERROR: Column property not found');
       throw 'invalidFile';
     }
 
-    if (blocks.views.length === 0) {
-      console.error('ERROR: No view blocks found');
-      throw 'invalidFile';
+    // Determine label property
+    let labels = [];
+    let effectiveLabelPropertyId = labelPropertyId;
+
+    if (effectiveLabelPropertyId) {
+      const labelProperty = board.cardProperties?.find((p) => p.id === effectiveLabelPropertyId);
+      if (labelProperty?.options) {
+        labels = labelProperty.options;
+      }
     }
 
-    if (blocks.cards.length === 0) {
-      console.error('ERROR: No card blocks found');
-      throw 'invalidFile';
+    // Determine custom fields to import
+    let customFieldProperties = [];
+    if (customFieldPropertyIds && customFieldPropertyIds.length > 0) {
+      customFieldProperties = board.cardProperties?.filter(
+        (p) => customFieldPropertyIds.includes(p.id)
+      ) || [];
     }
 
-    console.log('✓ File validated successfully');
     console.log('');
-
-    return blocks;
+    console.log('--- Import Configuration ---');
+    console.log(`Column property: ${columnProperty.name} (${columnProperty.id})`);
+    console.log(`Label property: ${effectiveLabelPropertyId ? 'Yes' : 'None'}`);
+    console.log(`Due date property: ${dueDatePropertyId ? 'Yes' : 'None'}`);
+    console.log(`Custom fields: ${customFieldProperties.length}`);
+
+    return {
+      board,
+      views,
+      cards,
+      textBlocks,
+      // Mapping configuration
+      columnProperty,
+      labels,
+      labelPropertyId: effectiveLabelPropertyId,
+      dueDatePropertyId,
+      customFieldProperties,
+    };
   },
 };
diff --git a/server/config/routes.js b/server/config/routes.js
index 0392166e1..06d0869a6 100644
--- a/server/config/routes.js
+++ b/server/config/routes.js
@@ -195,6 +195,8 @@ module.exports.routes = {
   'POST /api/notification-services/:id/test': 'notification-services/test',
   'DELETE /api/notification-services/:id': 'notification-services/delete',
 
+  'POST /api/focalboard/preview': 'focalboard/preview',
+
   'GET /preloaded-favicons/*': {
     fn: staticDirServer('/preloaded-favicons', () =>
       path.join(

From 9d24e5bc276b12e5356aab1a0c9c56c2d5ca65c0 Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Tue, 20 Jan 2026 00:38:59 +0200
Subject: [PATCH 7/9] feat: frontend accepts setup v1

---
 client/src/api/boards.js                      |  40 ++-
 client/src/api/http.js                        |  22 +-
 .../boards/AddBoardStep/AddBoardStep.jsx      |  13 +
 .../AddBoardStep/FocalboardMappingStep.jsx    | 312 ++++++++++++++++++
 .../FocalboardMappingStep.module.scss         | 118 +++++++
 .../boards/AddBoardStep/ImportStep.jsx        |  57 +++-
 client/src/locales/en-US/core.js              |  10 +
 client/src/sagas/core/services/boards.js      |  56 +++-
 server/api/controllers/boards/create.js       |  19 +-
 .../boards/import-focalboard-custom-fields.js |   2 +-
 10 files changed, 611 insertions(+), 38 deletions(-)
 create mode 100644 client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
 create mode 100644 client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss

diff --git a/client/src/api/boards.js b/client/src/api/boards.js
index c804b4ded..b1db0ea03 100755
--- a/client/src/api/boards.js
+++ b/client/src/api/boards.js
@@ -7,14 +7,25 @@ import http from './http';
 import socket from './socket';
 import { transformCard } from './cards';
 import { transformAttachment } from './attachments';
+import { getAccessToken } from '../utils/access-token-storage';
+import Config from '../constants/Config';
 
 /* Actions */
 
 const createBoard = (projectId, data, headers) =>
   socket.post(`/projects/${projectId}/boards`, data, headers);
 
-const createBoardWithImport = (projectId, data, requestId, headers) =>
-  http.post(`/projects/${projectId}/boards?requestId=${requestId}`, data, headers);
+const createBoardWithImport = (projectId, data, requestId, headers) => {
+  const { importMapping, ...formDataFields } = data;
+
+  let url = `/projects/${projectId}/boards?requestId=${requestId}`;
+  if (importMapping) {
+    url += `&importMapping=${encodeURIComponent(importMapping)}`;
+  }
+
+  return http.post(url, formDataFields, headers);
+}
+
 
 const getBoard = (id, subscribe, headers) =>
   socket
@@ -32,10 +43,35 @@ const updateBoard = (id, data, headers) => socket.patch(`/boards/${id}`, data, h
 
 const deleteBoard = (id, headers) => socket.delete(`/boards/${id}`, undefined, headers);
 
+const previewFocalboardImport = (file) => {
+  const accessToken = getAccessToken();
+
+  const formData = new FormData();
+  formData.append('file', file);
+
+  return fetch(`${Config.SERVER_BASE_URL}/api/focalboard/preview`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+    body: formData,
+    credentials: 'include',
+  })
+    .then((response) => {
+      if (!response.ok) {
+        return response.json().then((body) => {
+          throw body;
+        });
+      }
+      return response.json();
+    });
+};
+
 export default {
   createBoard,
   createBoardWithImport,
   getBoard,
   updateBoard,
   deleteBoard,
+  previewFocalboardImport,
 };
diff --git a/client/src/api/http.js b/client/src/api/http.js
index 4d5ceca1a..ae140e3b1 100755
--- a/client/src/api/http.js
+++ b/client/src/api/http.js
@@ -10,13 +10,23 @@ const http = {};
 // TODO: add all methods
 ['GET', 'POST', 'DELETE'].forEach((method) => {
   http[method.toLowerCase()] = (url, data, headers) => {
-    const formData =
-      data &&
-      Object.keys(data).reduce((result, key) => {
-        result.append(key, data[key]);
+    console.log('http.js received data:', data);
 
-        return result;
-      }, new FormData());
+  const formData =
+    data &&
+    Object.keys(data).reduce((result, key) => {
+      console.log(`Appending to FormData: ${key} =`, data[key]);
+      result.append(key, data[key]);
+      return result;
+    }, new FormData());
+
+  // Log what's in FormData
+  if (formData) {
+    console.log('FormData entries:');
+    for (let [key, value] of formData.entries()) {
+      console.log(`  ${key}:`, value);
+    }
+  }
 
     return fetch(`${Config.SERVER_BASE_URL}/api${url}`, {
       method,
diff --git a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
index 172b22d2a..a0c1a24c6 100755
--- a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
+++ b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
@@ -42,6 +42,7 @@ const AddBoardStep = React.memo(({ onClose }) => {
   const [nameFieldRef, handleNameFieldRef] = useNestedRef('inputRef');
 
   const handleSubmit = useCallback(() => {
+    console.log('AddBoardStep submitting data:', data);
     const cleanData = {
       ...data,
       name: data.name.trim(),
@@ -52,12 +53,24 @@ const AddBoardStep = React.memo(({ onClose }) => {
       return;
     }
 
+    // Transform import data for API
+    if (cleanData.import) {
+      const { type, file, mapping } = cleanData.import;
+      cleanData.import = {
+        type,
+        file,
+        // Include mapping for Focalboard imports
+        ...(mapping && { mapping }),
+      };
+    }
+
     dispatch(entryActions.createBoardInCurrentProject(cleanData));
     onClose();
   }, [onClose, dispatch, data, nameFieldRef]);
 
   const handleImportSelect = useCallback(
     (nextImport) => {
+      console.log('AddBoardStep received import:', nextImport);
       setData((prevData) => ({
         ...prevData,
         import: nextImport,
diff --git a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
new file mode 100644
index 000000000..e5b14f4ac
--- /dev/null
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
@@ -0,0 +1,312 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+import React, { useCallback, useEffect, useState, useMemo } from 'react';
+import PropTypes from 'prop-types';
+import { useTranslation } from 'react-i18next';
+import { Button, Checkbox, Dropdown, Form, Loader, Message } from 'semantic-ui-react';
+import { Popup } from '../../../lib/custom-ui';
+
+import api from '../../../api';
+
+import styles from './FocalboardMappingStep.module.scss';
+
+// Property types that can be used for each mapping
+const COLUMN_TYPES = ['select'];
+const LABEL_TYPES = ['select', 'multiSelect'];
+const DUE_DATE_TYPES = ['date'];
+const CUSTOM_FIELD_TYPES = ['text', 'url', 'number', 'email', 'phone', 'checkbox', 'date'];
+
+const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
+  const [t] = useTranslation();
+
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [previewData, setPreviewData] = useState(null);
+
+  // User selections
+  const [columnPropertyId, setColumnPropertyId] = useState(null);
+  const [labelPropertyId, setLabelPropertyId] = useState(null);
+  const [dueDatePropertyId, setDueDatePropertyId] = useState(null);
+  const [customFieldPropertyIds, setCustomFieldPropertyIds] = useState([]);
+
+  // Fetch preview data on mount
+  useEffect(() => {
+    let cancelled = false;
+
+    const fetchPreview = async () => {
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const data = await api.previewFocalboardImport(file);
+
+        if (cancelled) return;
+
+        setPreviewData(data);
+
+        // Auto-select column property from Kanban view
+        const kanbanView = data.views.find((v) => v.type === 'board');
+        if (kanbanView?.groupById) {
+          setColumnPropertyId(kanbanView.groupById);
+        }
+      } catch (err) {
+        if (cancelled) return;
+        setError(err.message || 'Failed to parse file');
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    };
+
+    fetchPreview();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [file]);
+
+  // Filter properties by type for each dropdown
+  const columnOptions = useMemo(() => {
+    if (!previewData) return [];
+    return previewData.properties
+      .filter((p) => COLUMN_TYPES.includes(p.type))
+      .map((p) => ({
+        key: p.id,
+        value: p.id,
+        text: `${p.name} (${p.options?.length || 0} options)`,
+      }));
+  }, [previewData]);
+
+  const labelOptions = useMemo(() => {
+    if (!previewData) return [];
+    return [
+      { key: 'none', value: '', text: t('common.none') },
+      ...previewData.properties
+        .filter((p) => LABEL_TYPES.includes(p.type))
+        .map((p) => ({
+          key: p.id,
+          value: p.id,
+          text: `${p.name} (${p.options?.length || 0} options)`,
+        })),
+    ];
+  }, [previewData, t]);
+
+  const dueDateOptions = useMemo(() => {
+    if (!previewData) return [];
+    return [
+      { key: 'none', value: '', text: t('common.none') },
+      ...previewData.properties
+        .filter((p) => DUE_DATE_TYPES.includes(p.type))
+        .map((p) => ({
+          key: p.id,
+          value: p.id,
+          text: p.name,
+        })),
+    ];
+  }, [previewData, t]);
+
+  const customFieldProperties = useMemo(() => {
+    if (!previewData) return [];
+    return previewData.properties.filter((p) => CUSTOM_FIELD_TYPES.includes(p.type));
+  }, [previewData]);
+
+  // Handlers
+  const handleColumnChange = useCallback((_, { value }) => {
+    setColumnPropertyId(value);
+  }, []);
+
+  const handleLabelChange = useCallback((_, { value }) => {
+    setLabelPropertyId(value);
+  }, []);
+
+  const handleDueDateChange = useCallback((_, { value }) => {
+    setDueDatePropertyId(value);
+  }, []);
+
+  const handleCustomFieldToggle = useCallback((propertyId) => {
+    setCustomFieldPropertyIds((prev) =>
+      prev.includes(propertyId)
+        ? prev.filter((id) => id !== propertyId)
+        : [...prev, propertyId]
+    );
+  }, []);
+
+  const handleSelectAllCustomFields = useCallback(() => {
+    setCustomFieldPropertyIds(customFieldProperties.map((p) => p.id));
+  }, [customFieldProperties]);
+
+  const handleDeselectAllCustomFields = useCallback(() => {
+    setCustomFieldPropertyIds([]);
+  }, []);
+
+  const handleSubmit = useCallback(() => {
+    if (!columnPropertyId) return;
+
+    const importData = {
+      type: 'focalboard',
+      file,
+      mapping: {
+        columnPropertyId,
+        labelPropertyId: labelPropertyId || undefined,
+        dueDatePropertyId: dueDatePropertyId || undefined,
+        customFieldPropertyIds: customFieldPropertyIds.length > 0 ? customFieldPropertyIds : undefined,
+      },
+    };
+    console.log('FocalboardMappingStep sending:', importData);
+    onSelect(importData);
+  }, [file, columnPropertyId, labelPropertyId, dueDatePropertyId, customFieldPropertyIds, onSelect, onBack]);
+
+  // Loading state
+  if (isLoading) {
+    return (
+      <>
+        <Popup.Header onBack={onBack}>
+          {t('common.focalboardImport', { context: 'title' })}
+        </Popup.Header>
+        <Popup.Content>
+          <div className={styles.loaderWrapper}>
+            <Loader active inline="centered" />
+            <p>{t('common.parsingFile')}</p>
+          </div>
+        </Popup.Content>
+      </>
+    );
+  }
+
+  // Error state
+  if (error) {
+    return (
+      <>
+        <Popup.Header onBack={onBack}>
+          {t('common.focalboardImport', { context: 'title' })}
+        </Popup.Header>
+        <Popup.Content>
+          <Message negative>
+            <Message.Header>{t('common.error')}</Message.Header>
+            <p>{error}</p>
+          </Message>
+        </Popup.Content>
+      </>
+    );
+  }
+
+  return (
+    <>
+      <Popup.Header onBack={onBack}>
+        {t('common.focalboardImport', { context: 'title' })}
+      </Popup.Header>
+      <Popup.Content>
+        <div className={styles.boardInfo}>
+          <strong>{previewData.board.title}</strong>
+          <span className={styles.stats}>
+            {t('common.cardsCount', { count: previewData.stats.totalCards })}
+          </span>
+        </div>
+
+        <Form onSubmit={handleSubmit}>
+          {/* Columns (required) */}
+          <div className={styles.section}>
+            <div className={styles.label}>
+              {t('common.columns')} <span className={styles.required}>*</span>
+            </div>
+            <Dropdown
+              fluid
+              selection
+              options={columnOptions}
+              value={columnPropertyId}
+              placeholder={t('common.selectProperty')}
+              onChange={handleColumnChange}
+            />
+          </div>
+
+          {/* Labels (optional) */}
+          <div className={styles.section}>
+            <div className={styles.label}>{t('common.labels')}</div>
+            <Dropdown
+              fluid
+              selection
+              options={labelOptions}
+              value={labelPropertyId || ''}
+              placeholder={t('common.selectProperty')}
+              onChange={handleLabelChange}
+            />
+          </div>
+
+          {/* Due Date (optional) */}
+          <div className={styles.section}>
+            <div className={styles.label}>{t('common.byDueDate')}</div>
+            <Dropdown
+              fluid
+              selection
+              options={dueDateOptions}
+              value={dueDatePropertyId || ''}
+              placeholder={t('common.selectProperty')}
+              onChange={handleDueDateChange}
+            />
+          </div>
+
+          {/* Custom Fields (optional, multiple) */}
+          {customFieldProperties.length > 0 && (
+            <div className={styles.section}>
+              <div className={styles.labelWithActions}>
+                <span className={styles.label}>{t('common.customFields_title')}</span>
+                <div className={styles.actions}>
+                  <Button
+                    type="button"
+                    className={styles.actionButton}
+                    onClick={handleSelectAllCustomFields}
+                  >
+                    {t('action.selectAll')}
+                  </Button>
+                  <Button
+                    type="button"
+                    className={styles.actionButton}
+                    onClick={handleDeselectAllCustomFields}
+                  >
+                    {t('action.deselectAll')}
+                  </Button>
+                </div>
+              </div>
+              <div className={styles.checkboxList}>
+                {customFieldProperties.map((property) => (
+                  <div key={property.id} className={styles.checkboxItem}>
+                    <Checkbox
+                      checked={customFieldPropertyIds.includes(property.id)}
+                      label={
+                        <label className={styles.checkboxLabel}>
+                          <span>{property.name}</span>
+                          <span className={styles.propertyType}>{property.type}</span>
+                        </label>
+                      }
+                      onChange={() => handleCustomFieldToggle(property.id)}
+                    />
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          <Button
+            positive
+            fluid
+            content={t('action.import')}
+            disabled={!columnPropertyId}
+            className={styles.submitButton}
+          />
+        </Form>
+      </Popup.Content>
+    </>
+  );
+});
+
+FocalboardMappingStep.propTypes = {
+  file: PropTypes.instanceOf(File).isRequired,
+  onSelect: PropTypes.func.isRequired,
+  onBack: PropTypes.func.isRequired,
+};
+
+export default FocalboardMappingStep;
diff --git a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
new file mode 100644
index 000000000..933533053
--- /dev/null
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
@@ -0,0 +1,118 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
+ :global(#app) {
+  .loaderWrapper {
+    padding: 32px 0;
+    text-align: center;
+
+    p {
+      color: #6b808c;
+      margin-top: 16px;
+    }
+  }
+
+  .boardInfo {
+    background: rgba(9, 30, 66, 0.04);
+    border-radius: 3px;
+    margin-bottom: 12px;
+    padding: 10px 12px;
+
+    strong {
+      color: #172b4d;
+      display: block;
+      margin-bottom: 2px;
+    }
+  }
+
+  .stats {
+    color: #6b808c;
+    font-size: 12px;
+  }
+
+  .section {
+    margin-bottom: 12px;
+  }
+
+  .label {
+    color: #444444;
+    font-size: 12px;
+    font-weight: bold;
+    padding-bottom: 6px;
+  }
+
+  .required {
+    color: #eb5a46;
+  }
+
+  .labelWithActions {
+    align-items: center;
+    display: flex;
+    justify-content: space-between;
+    padding-bottom: 6px;
+
+    .label {
+      padding-bottom: 0;
+    }
+  }
+
+  .actions {
+    display: flex;
+    gap: 4px;
+  }
+
+  .actionButton {
+    background: transparent !important;
+    box-shadow: none !important;
+    color: #6b808c !important;
+    font-size: 11px !important;
+    font-weight: normal !important;
+    padding: 4px 8px !important;
+    text-decoration: underline;
+
+    &:hover {
+      background: rgba(9, 30, 66, 0.08) !important;
+      color: #092d42 !important;
+    }
+  }
+
+  .checkboxList {
+    background: rgba(9, 30, 66, 0.04);
+    border-radius: 3px;
+    max-height: 180px;
+    overflow-y: auto;
+    padding: 4px;
+  }
+
+  .checkboxItem {
+    border-radius: 3px;
+    padding: 6px 8px;
+
+    &:hover {
+      background: rgba(9, 30, 66, 0.08);
+    }
+  }
+
+  .checkboxLabel {
+    align-items: center;
+    display: flex !important;
+    justify-content: space-between;
+    width: 100%;
+  }
+
+  .propertyType {
+    background: rgba(9, 30, 66, 0.08);
+    border-radius: 3px;
+    color: #6b808c;
+    font-size: 10px;
+    margin-left: 8px;
+    padding: 2px 6px;
+    text-transform: uppercase;
+  }
+
+  .submitButton {
+    margin-top: 8px;
+  }
+}
diff --git a/client/src/components/boards/AddBoardStep/ImportStep.jsx b/client/src/components/boards/AddBoardStep/ImportStep.jsx
index 7decdbded..abd075f42 100644
--- a/client/src/components/boards/AddBoardStep/ImportStep.jsx
+++ b/client/src/components/boards/AddBoardStep/ImportStep.jsx
@@ -3,28 +3,61 @@
  * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
  */
 
-import React, { useCallback } from 'react';
+import React, { useCallback, useState } from 'react';
 import PropTypes from 'prop-types';
 import { useTranslation } from 'react-i18next';
 import { Button } from 'semantic-ui-react';
 import { FilePicker, Popup } from '../../../lib/custom-ui';
 
+import FocalboardMappingStep from './FocalboardMappingStep';
+
 import styles from './ImportStep.module.scss';
 
 const ImportStep = React.memo(({ onSelect, onBack }) => {
   const [t] = useTranslation();
 
-  const handleFileSelect = useCallback(
-    (type, file) => {
-      onSelect({
-        type,
-        file,
-      });
+// For Focalboard: we need an intermediate step to select property mappings
+const [focalboardFile, setFocalboardFile] = useState(null);
+
+const handleTrelloFileSelect = useCallback(
+  (file) => {
+    onSelect({
+      type: 'trello',
+      file,
+    });
+    onBack();
+  },
+  [onSelect, onBack],
+);
+
+const handleFocalboardFileSelect = useCallback((file) => {
+  // Don't go back yet - show mapping step first
+  setFocalboardFile(file);
+}, []);
 
-      onBack();
-    },
-    [onSelect, onBack],
+const handleFocalboardMappingSelect = useCallback(
+  (importData) => {
+    onSelect(importData);
+    // Go all the way back to AddBoardStep
+    onBack();
+  },
+  [onSelect],
+);
+
+const handleFocalboardMappingBack = useCallback(() => {
+  setFocalboardFile(null);
+}, []);
+
+// Show Focalboard mapping step if file is selected
+if (focalboardFile) {
+  return (
+    <FocalboardMappingStep
+      file={focalboardFile}
+      onSelect={handleFocalboardMappingSelect}
+      onBack={handleFocalboardMappingBack}
+    />
   );
+}
 
   return (
     <>
@@ -34,10 +67,10 @@ const ImportStep = React.memo(({ onSelect, onBack }) => {
         })}
       </Popup.Header>
       <Popup.Content>
-        <FilePicker accept=".json" onSelect={(file) => handleFileSelect('trello', file)}>
+        <FilePicker accept=".json" onSelect={(file) => onSelect={handleTrelloFileSelect}}>
           <Button fluid content={t('common.fromTrello')} icon="trello" className={styles.button} />
         </FilePicker>
-        <FilePicker accept=".jsonl" onSelect={(file) => handleFileSelect('focalboard', file)}>
+        <FilePicker accept=".jsonl" onSelect={handleFocalboardFileSelect}>
           <Button fluid content={t('common.fromFocalboard')} icon="trello" className={styles.button} />
         </FilePicker>
       </Popup.Content>
diff --git a/client/src/locales/en-US/core.js b/client/src/locales/en-US/core.js
index e4958d2a2..7b52fe18f 100644
--- a/client/src/locales/en-US/core.js
+++ b/client/src/locales/en-US/core.js
@@ -109,6 +109,8 @@ export default {
       canOnlyViewBoard: 'Can only view the board.',
       cardActions_title: 'Card Actions',
       cardNotFound_title: 'Card Not Found',
+      cardsCount: "{{count}} cards",
+      cardsCount_plural: "{{count}} cards",
       cardsOnThisListAreAvailableToAllBoardMembers:
         'Cards on this list are available to all board members.',
       cardsOnThisListAreCompleteAndReadyToBeArchived:
@@ -192,10 +194,12 @@ export default {
       enterListTitle: 'Enter list title...',
       enterTaskDescription: 'Enter task description...',
       events: 'Events',
+      error: "Error",
       excludedEvents: 'Excluded events',
       expandTaskListsByDefault: 'Expand task lists by default',
       filterByLabels_title: 'Filter By Labels',
       filterByMembers_title: 'Filter By Members',
+      focalboardImport_title: "Focalboard Import",
       forPersonalProjects: 'For personal projects.',
       forTeamBasedProjects: 'For team-based projects.',
       fromComputer_title: 'From Computer',
@@ -241,6 +245,7 @@ export default {
       newUsername: 'New username',
       newVersionAvailable: 'New version available',
       newestFirst: 'Newest first',
+      none: "None",
       noApiKeyCreated: 'No API key created.',
       noBoards: 'No boards',
       noCardsFound: 'No cards found.',
@@ -256,6 +261,7 @@ export default {
       optional_inline: 'optional',
       organization: 'Organization',
       others: 'Others',
+      parsingFile: "Parsing file...",
       passwordIsSet: 'Password is set',
       phone: 'Phone',
       plankaUsesAppriseToSendNotificationsToOver100PopularServices:
@@ -291,6 +297,7 @@ export default {
       selectOrder_title: 'Select Order',
       selectPermissions_title: 'Select Permissions',
       selectProject: 'Select project',
+      selectProperty: "Select property...",
       selectRole_title: 'Select Role',
       selectType_title: 'Select Type',
       sequentialDisplayOfCards: 'Sequential display of cards.',
@@ -388,6 +395,7 @@ export default {
       archiveCards: 'Archive cards',
       archiveCards_title: 'Archive Cards',
       assignAsOwner: 'Assign as owner',
+      back: "Back",
       cancel: 'Cancel',
       copy: 'Copy',
       copyCard_title: 'Copy Card',
@@ -429,6 +437,7 @@ export default {
       deleteUser: 'Delete user',
       deleteUser_title: 'Delete User',
       deleteWebhook: 'Delete webhook',
+      deselectAll: "Deselect All",
       dismissAll: 'Dismiss all',
       download: 'Download',
       duplicateCard_title: 'Duplicate Card',
@@ -474,6 +483,7 @@ export default {
       restoreToList: 'Restore to {{list}}',
       returnToBoard: 'Return to board',
       save: 'Save',
+      selectAll: "Select All",
       sendTestEmail: 'Send test email',
       showActive: 'Show active',
       showAllAttachments: 'Show all attachments ({{hidden}} hidden)',
diff --git a/client/src/sagas/core/services/boards.js b/client/src/sagas/core/services/boards.js
index 77a405343..7a4c3f805 100644
--- a/client/src/sagas/core/services/boards.js
+++ b/client/src/sagas/core/services/boards.js
@@ -16,6 +16,10 @@ import ActionTypes from '../../../constants/ActionTypes';
 import ModalTypes from '../../../constants/ModalTypes';
 
 export function* createBoard(projectId, { import: boardImport, ...data }) {
+
+  console.log('Saga received boardImport:', boardImport);
+  console.log('Saga boardImport.mapping:', boardImport?.mapping);
+
   const localId = yield call(createLocalId);
 
   const nextData = {
@@ -40,22 +44,42 @@ export function* createBoard(projectId, { import: boardImport, ...data }) {
   let boardMemberships;
 
   try {
-    ({
-      item: board,
-      included: { boardMemberships },
-    } = yield boardImport
-      ? call(
-          request,
-          api.createBoardWithImport,
-          projectId,
-          {
-            ...nextData,
-            importType: boardImport.type,
-            importFile: boardImport.file,
-          },
-          localId,
-        )
-      : call(request, api.createBoard, projectId, nextData));
+    if (boardImport) {
+      // Build import payload
+      const importPayload = {
+        ...nextData,
+        importType: boardImport.type,
+        importFile: boardImport.file,
+      };
+
+      // Add mapping for Focalboard imports
+      if (boardImport.type === 'focalboard' && boardImport.mapping) {
+        importPayload.importMapping = JSON.stringify(boardImport.mapping);
+      }
+
+      console.log('Saga importPayload:', importPayload);
+  console.log('importMapping value:', importPayload.importMapping);
+  console.log('importPayload keys:', Object.keys(importPayload));
+console.log('importPayload.importMapping:', importPayload.importMapping);
+console.log('typeof importMapping:', typeof importPayload.importMapping);
+
+      ({
+        item: board,
+        included: { boardMemberships },
+      } = yield call(
+        request,
+        api.createBoardWithImport,
+        projectId,
+        importPayload,
+        localId,
+      ));
+    } else {
+      ({
+        item: board,
+
+        included: { boardMemberships },
+      } = yield call(request, api.createBoard, projectId, nextData));
+    }
   } catch (error) {
     yield put(actions.createBoard.failure(localId, error));
     return;
diff --git a/server/api/controllers/boards/create.js b/server/api/controllers/boards/create.js
index 428001a85..fdd7931a3 100755
--- a/server/api/controllers/boards/create.js
+++ b/server/api/controllers/boards/create.js
@@ -170,6 +170,11 @@ module.exports = {
   },
 
   async fn(inputs, exits) {
+    console.log('Raw request body:', this.req.body);
+  console.log('All params:', this.req.allParams());
+    console.log('All inputs:', JSON.stringify(inputs, null, 2));
+  console.log('importMapping specifically:', inputs.importMapping);
+  console.log('importType:', inputs.importType);
     const { currentUser } = this.req;
 
     const project = await Project.qm.getOneById(inputs.projectId);
@@ -209,7 +214,19 @@ module.exports = {
           board: trelloBoard,
         };
       } else if (inputs.importType === Board.ImportTypes.FOCALBOARD) {
-        const mapping = inputs.importMapping || {};
+        console.log('typeof importMapping:', typeof inputs.importMapping);
+        let mapping = inputs.importMapping || {};
+
+        if (typeof mapping === 'string') {
+          try {
+            mapping = JSON.parse(mapping);
+          } catch (e) {
+            console.error('Failed to parse importMapping:', e);
+            mapping = {};
+          }
+        }
+
+        console.log('Parsed mapping:', mapping);
 
         const focalboardData = await sails.helpers.boards
           .processUploadedFocalboardImportFile.with({
diff --git a/server/api/helpers/boards/import-focalboard-custom-fields.js b/server/api/helpers/boards/import-focalboard-custom-fields.js
index 07201ae07..c4edf66b9 100644
--- a/server/api/helpers/boards/import-focalboard-custom-fields.js
+++ b/server/api/helpers/boards/import-focalboard-custom-fields.js
@@ -57,7 +57,7 @@ module.exports = {
     const customFieldIdByFocalboardPropertyId = {};
 
     await Promise.all(
-      propertiesToImport.map(async (focalboardProperty, index) => {
+      customFieldProperties.map(async (focalboardProperty, index) => {
         const customField = await CustomField.qm.createOne({
           customFieldGroupId: customFieldGroup.id,
           position: POSITION_GAP * (index + 1),

From 763a0f79e6752e10d7749e14edd273788203b70f Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Wed, 21 Jan 2026 00:18:30 +0200
Subject: [PATCH 8/9] feat: frontend accepts setup v2

---
 client/src/api/http.js                        |  10 --
 .../boards/AddBoardStep/AddBoardStep.jsx      |   3 +-
 .../AddBoardStep/FocalboardMappingStep.jsx    | 105 +++++++++++++-----
 .../FocalboardMappingStep.module.scss         |  43 ++++++-
 .../boards/AddBoardStep/ImportStep.jsx        |  80 ++++++-------
 client/src/locales/en-US/core.js              |   2 +
 client/src/sagas/core/services/boards.js      |   9 --
 server/api/controllers/boards/create.js       |   8 --
 server/api/controllers/focalboard/preview.js  |  11 +-
 .../convert-focalboard-label-color.js         |   0
 .../boards/import-focalboard-labels.js        |   1 -
 .../parse-focalboard-date.js                  |   0
 .../helpers/boards/parse-focalboard-file.js   |  38 +++++--
 13 files changed, 198 insertions(+), 112 deletions(-)
 rename server/api/helpers/{utils => boards}/convert-focalboard-label-color.js (100%)
 rename server/api/helpers/{utils => boards}/parse-focalboard-date.js (100%)

diff --git a/client/src/api/http.js b/client/src/api/http.js
index ae140e3b1..88bd9493d 100755
--- a/client/src/api/http.js
+++ b/client/src/api/http.js
@@ -10,24 +10,14 @@ const http = {};
 // TODO: add all methods
 ['GET', 'POST', 'DELETE'].forEach((method) => {
   http[method.toLowerCase()] = (url, data, headers) => {
-    console.log('http.js received data:', data);
 
   const formData =
     data &&
     Object.keys(data).reduce((result, key) => {
-      console.log(`Appending to FormData: ${key} =`, data[key]);
       result.append(key, data[key]);
       return result;
     }, new FormData());
 
-  // Log what's in FormData
-  if (formData) {
-    console.log('FormData entries:');
-    for (let [key, value] of formData.entries()) {
-      console.log(`  ${key}:`, value);
-    }
-  }
-
     return fetch(`${Config.SERVER_BASE_URL}/api${url}`, {
       method,
       headers,
diff --git a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
index a0c1a24c6..a6e7a4837 100755
--- a/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
+++ b/client/src/components/boards/AddBoardStep/AddBoardStep.jsx
@@ -42,7 +42,6 @@ const AddBoardStep = React.memo(({ onClose }) => {
   const [nameFieldRef, handleNameFieldRef] = useNestedRef('inputRef');
 
   const handleSubmit = useCallback(() => {
-    console.log('AddBoardStep submitting data:', data);
     const cleanData = {
       ...data,
       name: data.name.trim(),
@@ -70,10 +69,10 @@ const AddBoardStep = React.memo(({ onClose }) => {
 
   const handleImportSelect = useCallback(
     (nextImport) => {
-      console.log('AddBoardStep received import:', nextImport);
       setData((prevData) => ({
         ...prevData,
         import: nextImport,
+        name: nextImport.boardTitle || prevData.name,
       }));
     },
     [setData],
diff --git a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
index e5b14f4ac..f098a41f3 100644
--- a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.jsx
@@ -17,7 +17,15 @@ import styles from './FocalboardMappingStep.module.scss';
 const COLUMN_TYPES = ['select'];
 const LABEL_TYPES = ['select', 'multiSelect'];
 const DUE_DATE_TYPES = ['date'];
-const CUSTOM_FIELD_TYPES = ['text', 'url', 'number', 'email', 'phone', 'checkbox', 'date'];
+
+// Supported custom field types (stored as strings in Planka)
+const SUPPORTED_CUSTOM_FIELD_TYPES = ['text', 'url', 'number', 'email', 'phone', 'checkbox'];
+
+// All custom field types to show (excluding column/label types)
+const ALL_CUSTOM_FIELD_TYPES = [
+  'text', 'url', 'number', 'email', 'phone', 'checkbox', 'date',
+  'person', 'multiPerson', 'file', 'createdTime', 'createdBy', 'updatedTime', 'updatedBy',
+];
 
 const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
   const [t] = useTranslation();
@@ -27,6 +35,7 @@ const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
   const [previewData, setPreviewData] = useState(null);
 
   // User selections
+  const [useBoardTitle, setUseBoardTitle] = useState(true);
   const [columnPropertyId, setColumnPropertyId] = useState(null);
   const [labelPropertyId, setLabelPropertyId] = useState(null);
   const [dueDatePropertyId, setDueDatePropertyId] = useState(null);
@@ -109,12 +118,33 @@ const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
     ];
   }, [previewData, t]);
 
+  // Get all custom field properties (excluding those used for columns/labels)
   const customFieldProperties = useMemo(() => {
     if (!previewData) return [];
-    return previewData.properties.filter((p) => CUSTOM_FIELD_TYPES.includes(p.type));
+    return previewData.properties.filter((p) =>
+      ALL_CUSTOM_FIELD_TYPES.includes(p.type) &&
+      !COLUMN_TYPES.includes(p.type) &&
+      !LABEL_TYPES.includes(p.type)
+    );
   }, [previewData]);
 
+  // Get only supported custom field IDs (for select all)
+  const supportedCustomFieldIds = useMemo(() => {
+    return customFieldProperties
+      .filter((p) => SUPPORTED_CUSTOM_FIELD_TYPES.includes(p.type))
+      .map((p) => p.id);
+  }, [customFieldProperties]);
+
+  // Check if a property type is supported
+  const isTypeSupported = useCallback((type) => {
+    return SUPPORTED_CUSTOM_FIELD_TYPES.includes(type);
+  }, []);
+
   // Handlers
+  const handleUseBoardTitleChange = useCallback(() => {
+    setUseBoardTitle((prev) => !prev);
+  }, []);
+
   const handleColumnChange = useCallback((_, { value }) => {
     setColumnPropertyId(value);
   }, []);
@@ -127,7 +157,10 @@ const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
     setDueDatePropertyId(value);
   }, []);
 
-  const handleCustomFieldToggle = useCallback((propertyId) => {
+  const handleCustomFieldToggle = useCallback((propertyId, isSupported) => {
+    // Only allow toggling supported types
+    if (!isSupported) return;
+
     setCustomFieldPropertyIds((prev) =>
       prev.includes(propertyId)
         ? prev.filter((id) => id !== propertyId)
@@ -136,8 +169,8 @@ const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
   }, []);
 
   const handleSelectAllCustomFields = useCallback(() => {
-    setCustomFieldPropertyIds(customFieldProperties.map((p) => p.id));
-  }, [customFieldProperties]);
+    setCustomFieldPropertyIds(supportedCustomFieldIds);
+  }, [supportedCustomFieldIds]);
 
   const handleDeselectAllCustomFields = useCallback(() => {
     setCustomFieldPropertyIds([]);
@@ -146,19 +179,19 @@ const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
   const handleSubmit = useCallback(() => {
     if (!columnPropertyId) return;
 
-    const importData = {
+    // Just call onSelect - ImportStep will handle navigation
+    onSelect({
       type: 'focalboard',
       file,
+      boardTitle: useBoardTitle ? previewData.board.title : null,
       mapping: {
         columnPropertyId,
         labelPropertyId: labelPropertyId || undefined,
         dueDatePropertyId: dueDatePropertyId || undefined,
         customFieldPropertyIds: customFieldPropertyIds.length > 0 ? customFieldPropertyIds : undefined,
       },
-    };
-    console.log('FocalboardMappingStep sending:', importData);
-    onSelect(importData);
-  }, [file, columnPropertyId, labelPropertyId, dueDatePropertyId, customFieldPropertyIds, onSelect, onBack]);
+    });
+  }, [file, useBoardTitle, previewData, columnPropertyId, labelPropertyId, dueDatePropertyId, customFieldPropertyIds, onSelect]);
 
   // Loading state
   if (isLoading) {
@@ -201,7 +234,18 @@ const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
       </Popup.Header>
       <Popup.Content>
         <div className={styles.boardInfo}>
-          <strong>{previewData.board.title}</strong>
+          <div className={styles.boardTitleRow}>
+            <Checkbox
+              checked={useBoardTitle}
+              onChange={handleUseBoardTitleChange}
+            />
+            <strong
+              className={useBoardTitle ? styles.boardTitleActive : styles.boardTitleInactive}
+              onClick={handleUseBoardTitleChange}
+            >
+              {previewData.board.title}
+            </strong>
+          </div>
           <span className={styles.stats}>
             {t('common.cardsCount', { count: previewData.stats.totalCards })}
           </span>
@@ -272,20 +316,31 @@ const FocalboardMappingStep = React.memo(({ file, onSelect, onBack }) => {
                 </div>
               </div>
               <div className={styles.checkboxList}>
-                {customFieldProperties.map((property) => (
-                  <div key={property.id} className={styles.checkboxItem}>
-                    <Checkbox
-                      checked={customFieldPropertyIds.includes(property.id)}
-                      label={
-                        <label className={styles.checkboxLabel}>
-                          <span>{property.name}</span>
-                          <span className={styles.propertyType}>{property.type}</span>
-                        </label>
-                      }
-                      onChange={() => handleCustomFieldToggle(property.id)}
-                    />
-                  </div>
-                ))}
+                {customFieldProperties.map((property) => {
+                  const supported = isTypeSupported(property.type);
+                  return (
+                    <div
+                      key={property.id}
+                      className={`${styles.checkboxItem} ${!supported ? styles.checkboxItemDisabled : ''}`}
+                    >
+                      <Checkbox
+                        checked={customFieldPropertyIds.includes(property.id)}
+                        disabled={!supported}
+                        label={
+                          <label className={styles.checkboxLabel}>
+                            <span className={!supported ? styles.propertyNameDisabled : ''}>
+                              {property.name}
+                            </span>
+                            <span className={`${styles.propertyType} ${!supported ? styles.propertyTypeUnsupported : ''}`}>
+                              {supported ? property.type : t('common.unsupported')}
+                            </span>
+                          </label>
+                        }
+                        onChange={() => handleCustomFieldToggle(property.id, supported)}
+                      />
+                    </div>
+                  );
+                })}
               </div>
             </div>
           )}
diff --git a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
index 933533053..aee179240 100644
--- a/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
+++ b/client/src/components/boards/AddBoardStep/FocalboardMappingStep.module.scss
@@ -19,11 +19,31 @@
     border-radius: 3px;
     margin-bottom: 12px;
     padding: 10px 12px;
+  }
+
+  .boardTitleRow {
+    align-items: center;
+    display: flex;
+    gap: 8px;
+    margin-bottom: 4px;
+  }
+
+  .boardTitleActive {
+    color: #172b4d;
+    cursor: pointer;
+
+    &:hover {
+      text-decoration: underline;
+    }
+  }
+
+  .boardTitleInactive {
+    color: #6b808c;
+    cursor: pointer;
+    text-decoration: line-through;
 
-    strong {
+    &:hover {
       color: #172b4d;
-      display: block;
-      margin-bottom: 2px;
     }
   }
 
@@ -95,6 +115,14 @@
     }
   }
 
+  .checkboxItemDisabled {
+    opacity: 0.6;
+
+    &:hover {
+      background: transparent;
+    }
+  }
+
   .checkboxLabel {
     align-items: center;
     display: flex !important;
@@ -102,6 +130,10 @@
     width: 100%;
   }
 
+  .propertyNameDisabled {
+    color: #6b808c;
+  }
+
   .propertyType {
     background: rgba(9, 30, 66, 0.08);
     border-radius: 3px;
@@ -112,6 +144,11 @@
     text-transform: uppercase;
   }
 
+  .propertyTypeUnsupported {
+    background: rgba(235, 90, 70, 0.1);
+    color: #eb5a46;
+  }
+
   .submitButton {
     margin-top: 8px;
   }
diff --git a/client/src/components/boards/AddBoardStep/ImportStep.jsx b/client/src/components/boards/AddBoardStep/ImportStep.jsx
index abd075f42..238612e88 100644
--- a/client/src/components/boards/AddBoardStep/ImportStep.jsx
+++ b/client/src/components/boards/AddBoardStep/ImportStep.jsx
@@ -16,48 +16,50 @@ import styles from './ImportStep.module.scss';
 const ImportStep = React.memo(({ onSelect, onBack }) => {
   const [t] = useTranslation();
 
-// For Focalboard: we need an intermediate step to select property mappings
-const [focalboardFile, setFocalboardFile] = useState(null);
+  // For Focalboard: we need an intermediate step to select property mappings
+  const [focalboardFile, setFocalboardFile] = useState(null);
 
-const handleTrelloFileSelect = useCallback(
-  (file) => {
-    onSelect({
-      type: 'trello',
-      file,
-    });
-    onBack();
-  },
-  [onSelect, onBack],
-);
+  const handleTrelloFileSelect = useCallback(
+    (file) => {
+      onSelect({
+        type: 'trello',
+        file,
+      });
+      onBack();
+    },
+    [onSelect, onBack],
+  );
 
-const handleFocalboardFileSelect = useCallback((file) => {
-  // Don't go back yet - show mapping step first
-  setFocalboardFile(file);
-}, []);
+  const handleFocalboardFileSelect = useCallback((file) => {
+    // Don't go back yet - show mapping step first
+    setFocalboardFile(file);
+  }, []);
 
-const handleFocalboardMappingSelect = useCallback(
-  (importData) => {
-    onSelect(importData);
-    // Go all the way back to AddBoardStep
-    onBack();
-  },
-  [onSelect],
-);
+  const handleFocalboardMappingSelect = useCallback(
+    (importData) => {
+      // importData includes: type, file, boardTitle, mapping
+      onSelect(importData);
+      // Go all the way back to AddBoardStep
+      onBack();
+    },
+    [onSelect, onBack],
+  );
 
-const handleFocalboardMappingBack = useCallback(() => {
-  setFocalboardFile(null);
-}, []);
+  const handleFocalboardMappingBack = useCallback(() => {
+    // Go back to file selection (within ImportStep)
+    setFocalboardFile(null);
+  }, []);
 
-// Show Focalboard mapping step if file is selected
-if (focalboardFile) {
-  return (
-    <FocalboardMappingStep
-      file={focalboardFile}
-      onSelect={handleFocalboardMappingSelect}
-      onBack={handleFocalboardMappingBack}
-    />
-  );
-}
+  // Show Focalboard mapping step if file is selected
+  if (focalboardFile) {
+    return (
+      <FocalboardMappingStep
+        file={focalboardFile}
+        onSelect={handleFocalboardMappingSelect}
+        onBack={handleFocalboardMappingBack}
+      />
+    );
+  }
 
   return (
     <>
@@ -67,11 +69,11 @@ if (focalboardFile) {
         })}
       </Popup.Header>
       <Popup.Content>
-        <FilePicker accept=".json" onSelect={(file) => onSelect={handleTrelloFileSelect}}>
+        <FilePicker accept=".json" onSelect={handleTrelloFileSelect}>
           <Button fluid content={t('common.fromTrello')} icon="trello" className={styles.button} />
         </FilePicker>
         <FilePicker accept=".jsonl" onSelect={handleFocalboardFileSelect}>
-          <Button fluid content={t('common.fromFocalboard')} icon="trello" className={styles.button} />
+          <Button fluid content={t('common.fromFocalboard')} icon="file" className={styles.button} />
         </FilePicker>
       </Popup.Content>
     </>
diff --git a/client/src/locales/en-US/core.js b/client/src/locales/en-US/core.js
index 7b52fe18f..0bfe19797 100644
--- a/client/src/locales/en-US/core.js
+++ b/client/src/locales/en-US/core.js
@@ -120,6 +120,7 @@ export default {
       clientHostnameInEhlo: 'Client hostname in EHLO',
       closed: 'Closed',
       color: 'Color',
+      columns: 'Columns',
       comments: 'Comments',
       contentExceedsLimit: 'Content exceeds {{limit}}',
       contentOfThisAttachmentIsTooBigToDisplay: 'Content of this attachment is too big to display.',
@@ -330,6 +331,7 @@ export default {
       typeNameToConfirm: 'Type the name to confirm.',
       typeTitleToConfirm: 'Type the title to confirm.',
       unsavedChanges: 'Unsaved changes',
+      unsupported: 'Unsupported',
       uploadFailedFileIsTooBig: 'Upload failed: File is too big.',
       uploadFailedNotEnoughStorageSpace: 'Upload failed: Not enough storage space.',
       uploadedImages: 'Uploaded images',
diff --git a/client/src/sagas/core/services/boards.js b/client/src/sagas/core/services/boards.js
index 7a4c3f805..841b0115d 100644
--- a/client/src/sagas/core/services/boards.js
+++ b/client/src/sagas/core/services/boards.js
@@ -17,9 +17,6 @@ import ModalTypes from '../../../constants/ModalTypes';
 
 export function* createBoard(projectId, { import: boardImport, ...data }) {
 
-  console.log('Saga received boardImport:', boardImport);
-  console.log('Saga boardImport.mapping:', boardImport?.mapping);
-
   const localId = yield call(createLocalId);
 
   const nextData = {
@@ -57,12 +54,6 @@ export function* createBoard(projectId, { import: boardImport, ...data }) {
         importPayload.importMapping = JSON.stringify(boardImport.mapping);
       }
 
-      console.log('Saga importPayload:', importPayload);
-  console.log('importMapping value:', importPayload.importMapping);
-  console.log('importPayload keys:', Object.keys(importPayload));
-console.log('importPayload.importMapping:', importPayload.importMapping);
-console.log('typeof importMapping:', typeof importPayload.importMapping);
-
       ({
         item: board,
         included: { boardMemberships },
diff --git a/server/api/controllers/boards/create.js b/server/api/controllers/boards/create.js
index fdd7931a3..548e66b4b 100755
--- a/server/api/controllers/boards/create.js
+++ b/server/api/controllers/boards/create.js
@@ -170,11 +170,6 @@ module.exports = {
   },
 
   async fn(inputs, exits) {
-    console.log('Raw request body:', this.req.body);
-  console.log('All params:', this.req.allParams());
-    console.log('All inputs:', JSON.stringify(inputs, null, 2));
-  console.log('importMapping specifically:', inputs.importMapping);
-  console.log('importType:', inputs.importType);
     const { currentUser } = this.req;
 
     const project = await Project.qm.getOneById(inputs.projectId);
@@ -214,7 +209,6 @@ module.exports = {
           board: trelloBoard,
         };
       } else if (inputs.importType === Board.ImportTypes.FOCALBOARD) {
-        console.log('typeof importMapping:', typeof inputs.importMapping);
         let mapping = inputs.importMapping || {};
 
         if (typeof mapping === 'string') {
@@ -226,8 +220,6 @@ module.exports = {
           }
         }
 
-        console.log('Parsed mapping:', mapping);
-
         const focalboardData = await sails.helpers.boards
           .processUploadedFocalboardImportFile.with({
             file,
diff --git a/server/api/controllers/focalboard/preview.js b/server/api/controllers/focalboard/preview.js
index 696f509df..621bfe0aa 100644
--- a/server/api/controllers/focalboard/preview.js
+++ b/server/api/controllers/focalboard/preview.js
@@ -156,7 +156,10 @@ module.exports = {
     // Parse the Focalboard file
     let focalboardData;
     try {
-      focalboardData = await sails.helpers.boards.parseFocalboardFile(file);
+      focalboardData = await sails.helpers.boards.parseFocalboardFile.with({
+        file,
+        previewOnly: true,
+      });
     } catch (error) {
       if (error === 'invalidFile' || error.code === 'invalidFile') {
         throw Errors.INVALID_FILE;
@@ -164,7 +167,7 @@ module.exports = {
       throw error;
     }
 
-    const { board, views, cards, textBlocks } = focalboardData;
+    const { board, views, cardCount, textBlockCount } = focalboardData;
 
     // Build response with properties for user selection
     const properties = (board.cardProperties || []).map((prop) => ({
@@ -191,8 +194,8 @@ module.exports = {
       properties,
       views: viewsInfo,
       stats: {
-        totalCards: cards.length,
-        totalTextBlocks: textBlocks.length,
+        totalCards: cardCount,
+        totalTextBlocks: textBlockCount,
       },
     });
   },
diff --git a/server/api/helpers/utils/convert-focalboard-label-color.js b/server/api/helpers/boards/convert-focalboard-label-color.js
similarity index 100%
rename from server/api/helpers/utils/convert-focalboard-label-color.js
rename to server/api/helpers/boards/convert-focalboard-label-color.js
diff --git a/server/api/helpers/boards/import-focalboard-labels.js b/server/api/helpers/boards/import-focalboard-labels.js
index 439c9925c..d1702a530 100644
--- a/server/api/helpers/boards/import-focalboard-labels.js
+++ b/server/api/helpers/boards/import-focalboard-labels.js
@@ -44,7 +44,6 @@ module.exports = {
           });
 
           labelIdByFocalboardLabelId[focalboardLabel.id] = id;
-          console.log(`Created label: "${focalboardLabel.value}" (${focalboardLabel.color} → ${plankaColor})`);
         }),
       );
     } else {
diff --git a/server/api/helpers/utils/parse-focalboard-date.js b/server/api/helpers/boards/parse-focalboard-date.js
similarity index 100%
rename from server/api/helpers/utils/parse-focalboard-date.js
rename to server/api/helpers/boards/parse-focalboard-date.js
diff --git a/server/api/helpers/boards/parse-focalboard-file.js b/server/api/helpers/boards/parse-focalboard-file.js
index 91dbe00f6..06c6d65dd 100644
--- a/server/api/helpers/boards/parse-focalboard-file.js
+++ b/server/api/helpers/boards/parse-focalboard-file.js
@@ -19,6 +19,11 @@ module.exports = {
       required: true,
       description: 'Uploaded file object with fd (file descriptor)',
     },
+    previewOnly: {
+      type: 'boolean',
+      defaultsTo: false,
+      description: 'If true, only parse board and views (faster for preview)',
+    },
   },
 
   exits: {
@@ -28,6 +33,7 @@ module.exports = {
   async fn(inputs) {
     console.log('');
     console.log('=== Parsing Focalboard JSONL File ===');
+    const { previewOnly } = inputs;
 
     const fileStream = fs.createReadStream(inputs.file.fd);
     const rl = readline.createInterface({
@@ -45,6 +51,8 @@ module.exports = {
     let lineCount = 0;
     let emptyLines = 0;
     let parseErrors = 0;
+    let cardCount = 0;
+    let textBlockCount = 0;
     const unknownBlockTypes = new Set();
 
     try {
@@ -79,25 +87,27 @@ module.exports = {
         } else if (parsed.type === 'block' && parsed.data) {
           block = parsed.data;
         } else {
-          console.warn(`Skipping line ${lineCount}: not a valid structure (type: ${parsed.type})`);
+          // console.warn(`Skipping line ${lineCount}: not a valid structure (type: ${parsed.type})`);
           continue;
         }
 
         switch (block.type) {
-          case 'board':
-            data.board = block;
-            console.log(`Found board: "${block.title}"`);
-            break;
           case 'view':
             data.views.push(block);
-            console.log(`Found view: "${block.title}" (type: ${block.fields?.viewType || 'unknown'})`);
             break;
           case 'card':
-            data.cards.push(block);
+            if (previewOnly) {
+              cardCount++;
+            } else {
+              data.cards.push(block);
+            }
             break;
           case 'text':
-            data.textBlocks.push(block);
-            break;
+            if (previewOnly) {
+              textBlockCount++;
+            } else {
+              data.textBlocks.push(block);
+            }
           default:
             unknownBlockTypes.add(block.type);
             break;
@@ -142,11 +152,17 @@ module.exports = {
       throw 'invalidFile';
     }
 
-    if (data.cards.length === 0) {
-      console.error('ERROR: No card blocks found');
+    // For full parsing, validate cards exist
+    if (!previewOnly && data.cards.length === 0) {
       throw 'invalidFile';
     }
 
+    // In preview mode, add counts to data
+    if (previewOnly) {
+      data.cardCount = cardCount;
+      data.textBlockCount = textBlockCount;
+    }
+
     console.log('✓ File parsed successfully');
     console.log('');
 

From b5d4008520ca983eb73a1c395af954c50f24a7ac Mon Sep 17 00:00:00 2001
From: Nastasia <lisitsinan@gmail.com>
Date: Fri, 23 Jan 2026 15:09:12 +0200
Subject: [PATCH 9/9] fix: utils to helpers

---
 server/api/helpers/boards/import-focalboard-cards.js  | 2 +-
 server/api/helpers/boards/import-focalboard-labels.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/server/api/helpers/boards/import-focalboard-cards.js b/server/api/helpers/boards/import-focalboard-cards.js
index 74792769d..4e1cce293 100644
--- a/server/api/helpers/boards/import-focalboard-cards.js
+++ b/server/api/helpers/boards/import-focalboard-cards.js
@@ -141,7 +141,7 @@ module.exports = {
           let dueDate = null;
           if (dueDatePropertyId) {
             const dueDateRaw = focalboardCard.fields?.properties?.[dueDatePropertyId];
-            dueDate = sails.helpers.utils.parseFocalboardDate(dueDateRaw);
+            dueDate = sails.helpers.boards.parseFocalboardDate(dueDateRaw);
 
             if (dueDate) {
               stats.cardsWithDueDate += 1;
diff --git a/server/api/helpers/boards/import-focalboard-labels.js b/server/api/helpers/boards/import-focalboard-labels.js
index d1702a530..93be0d24c 100644
--- a/server/api/helpers/boards/import-focalboard-labels.js
+++ b/server/api/helpers/boards/import-focalboard-labels.js
@@ -34,7 +34,7 @@ module.exports = {
     if (focalboardLabels.length > 0) {
       await Promise.all(
         focalboardLabels.map(async (focalboardLabel, index) => {
-          const plankaColor = sails.helpers.utils.convertFocalboardLabelColor(focalboardLabel.color);
+          const plankaColor = sails.helpers.boards.convertFocalboardLabelColor(focalboardLabel.color);
 
           const { id } = await Label.qm.createOne({
             boardId,