Commit Graph
155 Commits
Author SHA1 Message Date
Lauri Ojansivu b7589737f5 File docs/Features the way the WeKan menus are.
A feature's guide now sits under the menu it is used from, read from the
templates rather than from where somebody once put it: Header-Bar,
All-Boards, Pages, Board-Header (search and every Board View), Board-Sidebar
(Board Settings, Filter, Members, Labels, Archive), Rules, Swimlanes, Lists,
Cards, Member-Settings, Admin-Panel and Login-Page. Topics used from several
menus (editor, history, theme, translations, email, troubleshooting) are in
General.

- Each area has a README mapping its menu entries to their guides and to the
  template or server module that implements them. Board-Header/README.md
  lists all 40 Board View entries with the template boardBody.jade renders;
  five views (Table, Calendar Mode, Time, Timeline, Map) have no guide of
  their own yet and say so.
- Board-View.md listed 25 views while BOARD_VIEWS has 40; it now lists all
  of them with their English labels.
- Pages keep their file names. Where a released changelog links an old path,
  a "# Moved" page stays there and points to the new one; test-menu.sh skips
  folders holding only those.
- Undo was filed under Login; it is General/Undo now.
- Every link in docs, code comments, scripts and tests follows the move;
  docsLinksResolve checks them all.

Tests that read a doc follow it to its new place. boardViewSettings now fails
when Board-View.md or Board-Header/README.md differs from BOARD_VIEWS, or
names a template boardBody.jade does not render.

Thanks to xet7 !
2026-10-16 23:45:35 +03:00
Lauri Ojansivu 51238ed8ad Import: attachment files of Jira, Nextcloud Deck, OpenProject, Asana and GitLab.
Their exports name attachments without carrying the files, so the files
were reported as a loss. Each service documents where a file is
downloaded, behind the same sign-in as its API:

- Jira: fields.attachment[].content (/rest/api/3/attachment/content/<id>),
  Basic email:API token; Jira's redirect to its media store is followed
  without the sign-in.
- Deck: /index.php/apps/deck/api/v1.0|v1.1/boards/../stacks/../cards/..
  /attachments/<id>, Basic user:app password, OCS-APIRequest: true.
- OpenProject: _links.downloadLocation, relative to the instance, Basic
  apikey:<key>.
- Asana: GET /attachments/<gid>?opt_fields=download_url with a personal
  access token, then the signed download_url without it; a file the
  export embeds (export_boards.pl) is taken as it is; one kept on Google
  Drive and the like is a link, reported.
- GitLab: a private project's /uploads/ link through
  /api/v4/projects/<id>/uploads/<secret>/<file> (17.4+), Bearer token.

The import page asks for the address, user and token under "Attachment
files" for these five (the REST import takes the same as attachmentAuth).
They go with that one import: held beside the creator in a WeakMap, never
stored or logged, the token field emptied on Import, and sent ONLY to
the origin the member typed - an export names any URL it likes. Every
download is the import's SSRF-guarded fetch, which validates each hop
and drops Authorization on a cross-origin redirect. A file that cannot
be fetched is on the loss report with its reason. Unticking Attachments
leaves them out (Jira's per-issue field is pruned too).

Zenkit is left out: it publishes no way to download a file.

Tests: importAttachmentAuth.test.cjs (each service's request, the
sign-in only to its origin, malformed sign-ins, never stored or
logged), the parser tests pin the attachment lists, a Meteor test
imports an embedded Asana file onto its card and shows a Jira file is
reported without a sign-in and that the sign-in never reaches an address
the guard refuses, and import-attachment-auth.e2e.js the page (not run
here). Not run against the live services.

Thanks to xet7 !
2026-10-15 01:27:26 +03:00
Lauri Ojansivu cc0b8c60ba Jira import: closed sprints, rebuilt from the issues.
Jira's sprint report has no documented API, so a closed sprint was
reported and skipped. It is now imported as closed, with its start and
close snapshots rebuilt from documented issue data: the Sprint field,
status and resolution at the sprint's start and completion dates, from
each issue's change history (expand=changelog), or from the issues as
they are now when there is none. The snapshots are marked partial. A
closed sprint with no start or completion date is still reported.

Thanks to xet7 !
2026-10-15 00:46:39 +03:00
Lauri Ojansivu 46e30f01e4 Import: Planka, Microsoft To Do, KanbanFlow, Basecamp, Google Tasks and Google Keep from their APIs.
Decided on 2026-10-14. On the import page each of the six asks for what
its service needs - a self-hosted Planka its address, username and
password; the others an access token (Basecamp also its account id) -
lists what that account can import, and fetches the chosen board, list
or project. The credentials go with each call and are used for that
call's requests only; they are never stored or logged, and the page
clears secret fields once a fetch has used them. The fetched JSON fills
the import text box and the import goes on as for a pasted export: the
service's parser (models/lib/<key>ApiFormat.js) into the generalized
importer, with the members step and the loss report. The same JSON can
be pasted, or posted to POST /api/boards/import/<key>.

- server/apiImport.js: apiImportList and apiImportFetch, signed in only,
  off with the Admin Panel's import switch, not in Sandstorm, rate
  limited; credentials checked against the service's own fields
  (models/lib/apiImportServices.js).
- server/lib/apiImportRequest.js: every request through the SSRF guard -
  pinned address, no redirects, bounded in time and size - so a Planka
  address cannot point the server at its own network; an administrator
  can allow such a host with API_IMPORT_ALLOWED_PRIVATE_HOSTS. An error
  names only the origin and the status.
- models/lib/apiImport/<key>.js: each service's client, plain Node with
  the request injected, paging bounded and the token only in a header.
- Each has a docs page under docs/Features/ImportExport/, listed in the
  coverage index and External-Tools.md.

Tests: tests/<key>ApiImport.test.cjs (client with a fake request, every
parsed field, wrong shapes), tests/apiImport.test.cjs (credentials, the
gate, the wiring, the shapes refused), api-import.e2e.js (the form for
every service, fetched JSON imported through the page, refusals incl. a
private address). Live tests, read only, run from build.sh / build.bat ->
Tests -> Live tests with your own accounts (releases/live-tests/README.md);
they were not run here. New strings translated in all locales.

Also: the release risk baseline allows the services' API addresses, and
the guards that count import creators, list the import sources and pin
the platform fetch() calls know the new ones.

Thanks to xet7 !
2026-10-14 22:57:15 +03:00
Lauri Ojansivu d6c1d6fce1 List Sync: write WeKan's changes back to GitLab.
#2698. A list synced from GitLab gets a Sync option of its own, off by
default: Write changes back to GitLab. With it, every Sync run first
sends what members did on the list's cards, then reads GitLab, so the
read finds both sides agreeing:

- a title or description edited in WeKan, when the issue still has the
  text both sides last agreed on - the local-only edit the reconcile
  already keeps. The Source footer Sync adds is not sent; when both sides
  changed, nothing is written and it stays a conflict to resolve;
- a card archived in WeKan closes its open issue, and restoring a card
  WeKan closed reopens it (syncClosedByWeKan); an issue GitLab closed is
  never reopened by WeKan;
- a comment written in WeKan becomes a note, and keeps the note's id
  (syncCommentId) so the comments sync does not bring it back twice.

Only what happens after it was switched on is sent (writeBackSince), at
most 100 writes a run. Every write is fenced by the list's Sync
reservation, goes through the same address checks as the reads (no
redirects, PUT or POST to an issue or its notes only), and records on
the WeKan side only while the card or comment is still as planned. A
refused write is shown in the Sync popup (syncWriteBackError, beside
syncSource because the run's list writes match syncSource whole) and the
read sync still runs. Not in Sandstorm, whose bridge only reads.

Tests: tests/listSyncWriteBack.test.cjs (the plan with GitLab's shapes,
the parser's footer, every negative - conflict, legacy card, old
archive or comment, foreign card, issue GitLab closed - and the wiring),
server/lib/tests/listSyncWriteBack.tests.js (end to end through
syncOneList against a fake GitLab). The live test,
releases/live-tests/gitlab-write-back.mjs, runs from build.sh / build.bat
-> Tests -> Live tests with the glab login releases/mirror.sh uses, on one
scratch issue in a private project of that account; it is human-run and
was not run here. releases/live-tests/run.mjs runs every live test and
skips a service with no login.

Also: the English variants get the SQRL and Windows sign-in strings
(their key order follows en.i18n.json); buildScriptParity accounts for
the scripts CI runs inside their own environments; new strings
translated in all locales.

Thanks to xet7 !
2026-10-14 22:08:34 +03:00
Lauri Ojansivu 326d9bbf61 Board View / Version Control, issue files and synced issue details.
Version Control shows the board as a GitHub or Gitea issue tracker in the
board's own theme: cards are issues (open, or closed when archived, in a
Closed or Done list, or closed upstream), the board's labels are labels,
labels with a due date and the importers' milestone: labels are
milestones, comments are the conversation and attachments are the files.
The issue list takes GitHub's search words (is:open, label:, milestone:,
author:, assignee:@me, no:label, sort:). New issue, Close and Reopen write
through the ordinary collections, so the History tab - the board's
history table - shows them and Restore undoes them. Import links open the
GitHub, GitLab, Gitea and Forgejo importers, and each synced list has a
Sync now button.

The GitHub, GitLab, Gitea and Forgejo importers bring each issue's files:
user-attachments and user-images links, GitLab uploads, and Gitea and
Forgejo assets, downloaded through the import's SSRF guard and stored as
card attachments in Admin Panel / Attachments / Default Storage.

List sync has a new option, Comments, labels, state and files, off by
default: comments come from one paged repository-wide list (GitHub,
Gitea) or each issue's notes (GitLab), keyed by the tracker's ids, so a
second run writes only what changed, and nothing written in WeKan is
changed. Gitea issues are fetched without pull requests, and a rate
limited answer is waited out once or ends the run with the time to retry.

A public board's Show on / Default on Public Board settings are for the
public: visitors and non-members get them, read-only, and the board's own
members get the private side, so any view - Version Control, Email, Chat
and the rest - can be the read-only public view.

The card menu has a QR code of the card's link, drawn in the browser by
WeKan's own encoder, which the tests check module for module against
qrcode-svg.

The new strings are translated in every locale.

Thanks to xet7 !

Fixes #2015.
2026-10-14 12:09:34 +03:00
Lauri Ojansivu 88d00e02f1 Export boards to Trello, keep swimlanes as labels, and reach Trello from Sandstorm.
Export to Trello: Board Settings -> Export -> Trello creates the board in
Trello through its API with the saved key and token: labels, lists, cards,
checklists, comments, attachment files, and archived lists and cards. It
runs as a server job from the board export, with the same access check.

Swimlanes: Trello has none, so each swimlane is exported as a label named
"Swimlane: <title>". The Swimlanes by Blue Cat Power-Up groups Trello cards
into rows by label, and every Trello import turns those labels back into
swimlanes.

Sandstorm: a grain has no network of its own. Allow access to Trello opens
the Sandstorm Powerbox for https://api.trello.com/1, like the Sandstorm
WordPress app reaches wordpress.org; the access token is kept per user on
the server, and Trello import and export go through the bridge proxy.

Thanks to xet7 !
2026-10-13 14:20:56 +03:00
Lauri Ojansivu 5b04b4b47c Reorganize docs: platform pages under docs/Platforms, and update their links.
The autoupdate design pages move from docs/Design/Autoupdate to where their
platform lives: the per-OS pages to docs/Platforms/FOSS/OS/OS-future-alternatives,
Snap-Core and Snap-Ondra-Gantt to Container/Snap, UCS and Nextcloud to
Container/Docker, and Platforms.md to docs/Platforms. docs/Platforms/FOSS/Cloud
is split into Container/Docker (Helm, OpenShift, CloudFoundry) and
FOSS/CloudFlare; Friend and UCS move under Container/Docker; Leo moves to
Features/ImportExport/Leo.

Every link to a moved page is updated: relative links in the docs, including
the moved pages' own links to the rest of the tree, full docs/ paths in the
workflows, tests and comments, and the Upcoming CHANGELOG entry. Released and
archived CHANGELOG sections are records and keep their original links.
tests/docsLinksResolve.test.cjs passes.

Thanks to xet7 !
2026-10-11 19:53:18 +03:00
Lauri Ojansivu c80a656901 Read every import source through one path and one file chooser, from one description of the sources.
models/lib/importSources.js describes every import source once: its name,
which files its chooser accepts, whether its export can be pasted, what a
file is sent as, whether a .zip is one export of the tool, and which
importer creates the board. The import page's list of sources, its file
chooser and its text box, "Import many boards" and the test of api.py's
lists all read it.

The page had a branch per source - one each for Excel and the four other
workbook tools, Vikunja, Notion, Plane, the text formats, CSV, Trello's and
WeKan's files - each reading its file its own way, and four file choosers.
It now has one: the chosen file is read by the reader "Import many boards"
uses, or the pasted text is read, then only the steps a source really has of
its own run (the column mapping of CSV and Excel, the empty-export check of
WeKan, Jira's estimate field, Trello's workspace, Taiga's slimming), then the
people step every source shares. Kanboard's people come from the server's
parser like every generalized source's, so its own client mapper is gone.
Every source can now be chosen as a file, not only pasted.

Thanks to xet7 !
2026-10-09 13:13:37 +03:00
Lauri Ojansivu 86652c8718 Ask for the columns of a CSV or Excel import, apply Owner, and import WeKan's own Excel export.
A CSV, TSV or Excel import now shows which column is which card field
before importing, pre-filled from the header names - English names and
WeKan's own export column names in every language - and asks for what is
missing: a file with no list column gets one list, named on the page,
instead of one list per row. Unused columns can be kept as text custom
fields. The choice goes to the server as csvMapping, checked before
anything is written, and the REST import and api.py take one too.

The Owner column is applied, as are swimlane, received date, parent card,
spent time, overtime and archived. A TSV value containing a comma stays one
value. A dropdown custom field value that is not one of its items is skipped
instead of failing the import.

An Excel workbook is read sheet by sheet, its header found in row 1 or where
WeKan's export puts it, in any language; formula cells are read as their
results and rich text as text. WeKan's own Excel export imports, and a
workbook with many boards - each on its own sheet, as Export all boards
writes it - imports as many boards; the Activity sheet is skipped.

Thanks to xet7 !
2026-10-09 12:52:21 +03:00
Lauri Ojansivu 594867bab7 Import Kanboard task links as parent cards and dependencies, and GitHub comments as card comments.
Kanboard task links were only reported as losses. They now become WeKan
data: "is a child of" and "is a parent of" make the parent card, and blocks,
is blocked by, duplicates, is duplicated by, fixes, is fixed by and relates
to make dependencies of the matching type; the milestone pair becomes
related-to and is reported. Kanboard stores each link from both tasks, so
the two rows of one link become one parent link or one dependency. Rows from
getAllTaskLinks, getTaskLinkById and links grouped by label are read; an
unknown label, a link to a task not in the file and a second parent are
reported. The Kanboard export writes parents and dependencies back as task
links from both ends, so the file round-trips. The docs no longer claim typed
custom fields for Kanboard, which has none.

GitHub, Gitea and Forgejo issues put their embedded comments into the card
description; each now becomes a card comment with its author and date, and
the description is left as the issue wrote it. A comment without text, and
comments counted on the issue but not embedded, are reported.

The Jira instruction's endpoint literal is the current search
(GET /rest/api/3/search/jql) in every locale too, as code literals are copied
from English; the translation suites that pinned the old one follow.

Thanks to xet7 !
2026-10-09 12:27:59 +03:00
Lauri Ojansivu 73db241bd4 Choose who an import's people become, for every import, and stream imported attachments.
Every import page now asks once what the people named in the file become
(models/lib/importMembersMode.js): existing users chosen in the map-members
step, placeholder users that keep the original username and name and cannot
log in, to be mapped to real users later, or all the person importing. All
five creators read the same mapping. The generalized importer, which used to
drop people nobody mapped, now makes placeholders for them, as Trello and
WeKan imports do, and offers its people for mapping by reading the file with
the same parser (importBoard with previewPeople, which creates nothing).
Import many boards offers placeholders or the importer. The REST import, the
WeKan .zip route and the Trello route take the mode too.

A WeKan .zip imported as a new board no longer puts its attachment files
inline in memory within a 512 MB budget: the full-board importer streams each
from the archive into storage, as the import into an existing board does.
Both, and the Trello importer when given a stream, go through one helper
(server/lib/importAttachmentStream.js) that holds every imported attachment
to the Admin Panel's upload limit and to none when none is set, skipping a
file whose stated size is over it and stopping one that grows past it.

The import page instructions name Jira's current search (GET
/rest/api/3/search/jql with fields=*all, paged by nextPageToken), Todoist's
Manage data > Export as CSV and Planner's Export as Excel.

Thanks to xet7 !
2026-10-09 12:20:36 +03:00
Lauri Ojansivu 7858d84e12 Import and export many boards at once for every format, and document each format in its own directory.
Import many boards: on the import page of every source, several export
files, or one .zip holding them, each become their own board through the
same path a single import of that file takes, and the page lists what each
file became (models/lib/importManyFiles.js). A .zip that is itself one
export (Vikunja, Notion, Plane, WeKan with attachments) stays one board.
One board per project: for the generalized importer, each swimlane the
import would make - a project, folder or list of the tool - becomes its own
board (models/lib/importSplit.js), so an export of a whole app imports as
many boards, as a Trello .zip does. Kanri's all-data export now reads every
board, not only the first, so it splits into one board per Kanri board.

Export all boards: All Boards sidebar, or Multi-Selection for the selected
boards, downloads every board the user may export in one format, each
checked as its own export is. Excel is one workbook with a sheet per board,
named after the board; every other format is a .zip with one file per board
(server/routes/exportAllBoards.js). The per-format bytes are made in one
place, server/lib/renderExternalExport.js, for the board route and this.

A WeKan .zip export imports as a new board from All Boards, unpacked on the
server with its attachments (it was refused in the browser). api.py gains
importboardsfrom and exportallboards, sends every source in the shape the
import page sends, and fetches Excel, PDF, CSV and TSV exports from their
own routes and writes them as bytes.

Fixed while documenting: a Trello Butler rule's list name kept its case,
so the rule fires; the HTML export fetches the board JSON by URL instead of
a link the export popup no longer has; Tasks.org exports time spent;
Nextcloud Deck's done flag marks the due date done.

docs/Features/ImportExport has a directory per format with the steps to
import and export it, one board and many, and its details, moved from
Format-Coverage.md, which is now the index and the shared contract.
tests/importExportDocsCoverage.test.cjs fails when a format has no page.

Thanks to xet7 !
2026-10-09 10:33:37 +03:00
Lauri Ojansivu 2ea4d09678 Document every import and export format WeKan supports.
docs/Features/ImportExport/External-Tools.md listed ten tools while WeKan
reads and writes more than fifty. It now lists every tool and file, grouped
into project and task tools, issue trackers, plain text and outlines, and
WeKan's own formats: where in each tool to get the file, what WeKan writes
back, and which tools are not supported yet and why. The README's import and
export lists link to it and name the Wrike workflow, the Board Settings
export page points to it and to the Wrike workflow, and the historical
wishes in Sync.md say which have been done since.

tests/importExportDocsCoverage.test.cjs fails when a source on the import
page or a format in the export menu is missing from the page, so it cannot
go stale again.

Thanks to xet7 !
2026-10-09 09:48:54 +03:00
Lauri Ojansivu a78b4aa744 Export Wrike Excel with Wrike's custom workflow statuses, and import and export Wrike workflows as lists and rules.
The Wrike Excel export wrote the WeKan list as a custom column named WeKan
list, which Wrike reads as a custom field rather than a status. It now
writes the five workflow columns of Wrike's import help article: Default
task workflow on folder rows, and on task rows Workflow (named after the
board), Status (the list's status group) and Custom Status (the list).
Wrike applies a custom status only when that workflow exists, matching
case, so the board's lists are also exported as that workflow: the JSON of
Wrike's GET /workflows, one custom status per list with the nearest Wrike
color. That JSON is the only exchange format, since Wrike has no file
import or export of workflows.

A list's status group comes from the board's rules. A "moved to this list,
mark complete" rule makes it Completed (Cancelled when its name says so), a
"mark incomplete" rule makes it Active (or Deferred), otherwise the name
decides. In Rules > Import / Export, a pasted Wrike workflow adds a list for
each status the board lacks, after the previous status's list, and adds the
rules that do what Wrike's status groups do. Those rules show in the list,
Workflow and Blocks views. A server method does this as a board admin and
adds nothing twice. Wrike's own automation rules have no export, import or
API, so they cannot be carried over.

The Wrike import reads Custom Status as the list and a single Workflow as
the board title. It reports a status group the status name does not imply,
since only the workflow import's rules keep it.

tests/wrikeWorkflow.test.cjs and tests/wrikeFormat.test.cjs cover the
workflow, rules, colors, refusals and round trips. Two new Playwright cases
import a workbook with the workflow columns and apply a Wrike workflow
through the Rules popup twice, and the export audit fetches the workflow.
New text is in English, pending Transifex.

Thanks to xet7 !
2026-10-09 09:48:47 +03:00
Lauri Ojansivu d21a263393 Import boards from Plane issue exports.
Plane's Workspace Settings > Exports .zip is read with its CSV, JSON or XLSX
files (one per project, as Plane's export task and IssueExportSerializer
write them), or one of those files chosen or pasted: states become lists,
projects swimlanes, and parents, labels, dates, links and comments keep
their places, with priority, estimate and cycle as custom fields. Plane has
no import of its own to export to, so this is import only.

Thanks to xet7 !
2026-10-08 22:12:50 +03:00
Lauri Ojansivu b7d3274780 Import and export boards as Notion Markdown & CSV exports.
Notion's Markdown & CSV export is read as the downloaded .zip (opened on the
server under size limits) or as one database CSV: database properties map to
lists, people, dates, tags and custom fields, and page Markdown becomes the
card description. Export writes a database CSV that Notion's CSV import
reads, and which imports back.

Thanks to xet7 !
2026-10-08 22:01:22 +03:00
Lauri Ojansivu 6c9ffd63d4 Import and export boards as Redmine issue CSV.
Redmine's issue list "Also available in: CSV" export is read by its English
column names: each status becomes a list, issues become cards with the
tracker as a label, assignee, author, dates, parent task and related issues,
and priority, category, target version, estimated time, % Done and custom
fields become custom fields. Export writes the same CSV, which imports back.

Thanks to xet7 !
2026-10-08 21:55:27 +03:00
Lauri Ojansivu edb808e266 Import and export boards as Businessmap (Kanbanize) Excel workbooks.
Businessmap's Advanced Search "Configure results" Excel download is read by
its English column names: Column becomes lists and Lane swimlanes, owners,
tags, color, dates, comments and parent links keep their places, and
Priority, Size, Type and other columns become custom fields. Export writes
the same workbook, which imports back.

Thanks to xet7 !
2026-10-08 21:49:11 +03:00
Lauri Ojansivu 7aa90f7a00 Import and export boards as Teamwork.com Excel task import templates.
Teamwork.com imports tasks into a project from an Excel template (List or
Table view > ... > Import Tasks) whose help article names ten columns:
Tasklist, Task, Description, Assign to, Start date, Due date, Priority,
Estimated time, Tags and Status. Teamwork documents no export in that
layout, so the template is what is read and written. Task lists become
lists and tasks cards; a "-", "#" or ">" before a task name, doubled per
level, makes it a subtask card of the nearest shallower task above, in
its parent's list. Comma-separated Assign to e-mails become the owner and
assignees, Start and Due date the start and due dates (date cells, ISO,
or the site's numeric format with day/month order decided for the whole
file), Tags labels, Priority low/medium/high and Estimated time (25,
01:30, 1h 15m, 1h, 2 hours) the custom fields Priority and Estimated time
(hours), and Status Complete the checkbox field Complete with the due
date marked done. Other columns, unknown values, unreadable dates and
estimates, nameless rows and subtasks without or skipping a parent level
are reported; an .xls file is refused with a request to save it as .xlsx.
Export writes the template with date cells, HH:MM estimates and subtasks
after their parents.

tests/teamworkFormat.test.cjs builds the template with ExcelJS and covers
the subtask levels, every estimate form, the negatives and the round
trip; a Playwright case imports a workbook through the page. New
instruction text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:40:19 +03:00
Lauri Ojansivu 063365e8b9 Import and export boards as Wrike Excel workbooks.
Wrike documents the columns of its Excel import, not of its export: the
help article's key, parent task, title, status, priority, assigned to,
start date, duration, end date, depends on, start date constraint and
description, custom fields to the right of description, and the official
sample excel_import_sample.xls, whose folders and projects are rows with
a path as their Title (/Folder 2/Subfolder 1/) above their tasks. WeKan
reads and writes that template, headers matched case-insensitively.
Folder rows become swimlanes, Status the lists (a custom workflow's
Custom Status wins over its group), Key the reference, Parent Task the
parent card (a folder's Key puts the task in that folder), Assigned To
"Name <email>" the owner and assignees, Start and End Date the start and
due dates, Depends On "13FS" an is-blocked-by dependency, and Priority,
Duration and every other column custom fields. A start date constraint,
a folder or project's own status and dates, the workflow columns, the
SS/FF/SF kind of a dependency, bad keys and dates, and the repeated rows
of a task in several folders are reported. Export writes the template on
a Tasks sheet with a folder row per swimlane, sequential Keys, date cells,
the Wrike status group as Status and the list as the custom field WeKan
list, which the import reads back.

tests/wrikeFormat.test.cjs builds the sample's structure with ExcelJS
and covers the negatives and the round trip; a Playwright case imports a
template through the page. New instruction text is in English, pending
Transifex.

Thanks to xet7 !
2026-10-08 21:38:34 +03:00
Lauri Ojansivu 979edf4c3b Import and export boards as Quire CSV.
Quire's Import CSV reads Name, Assignee, Tag, Start, Due, Priority,
Status, Description, Parent and ID, matched by header name in any order;
its Export CSV, as the sample file its guide links and its API's
export-csv example show, also writes Started, Completed, Duration,
Estimate, Time log, Variation, Successors, Created and Created by. A
header with several values is repeated, or with merge joined by ", ".
The hierarchy is read in all three ways Quire writes it: a Parent column,
repeated ID columns by depth, and an ID path such as "#6, #8". Statuses
become lists and tasks cards with the ID as reference and the parent
task as parent card, Assignee as owner and assignees, Tag as labels,
Start (or Started), Due, Completed and Created as dates, Created by as
Requested by, and Priority (Low, High, Urgent, or the API's -1 to 2) as
a custom field; Medium is Quire's default and is left out. Dates are
read as Quire writes them, "Jun 2, 2026", or ISO 8601, and a leading '
before formula-like text is removed. Duration, Estimate, Time log,
Variation, Successors, unknown priorities and unreadable dates are
reported. Export writes the import columns with Completed, Created and
Created by, cards numbered #1... with Parent, and repeated Assignee and
Tag columns.

tests/quireCsv.test.cjs covers the sample file, the API's example, the
import shape, the negatives and the round trip; a Playwright case
imports through the page and the export audit fetches the format. New
instruction text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:35:31 +03:00
Lauri Ojansivu a8e73adf48 Import and export boards as Vikunja data exports.
Vikunja's Settings > Data Export writes, and its Vikunja Export migrator
reads, a zip with data.json (an array of projects with their tasks, views,
buckets, task_buckets and positions), filters.json, VERSION and
files/<id>. Both layouts are read: project views with buckets per view
(0.24 and newer) and bucket_id / is_done_bucket (0.21-0.23); a VERSION
older than 0.20.1 is refused, as Vikunja refuses it. The first kanban
view's buckets become lists and tasks cards in that view's order, several
projects swimlanes under their parent's name, with labels, assignees as
owner and assignees, created_by as Requested by, the dates (Go's zero time
is no date), the HTML description and comments as text, TipTap task lists
as checklists, hex color as card color, priority, percent done and done as
custom fields, subtask/parenttask as parent cards and blocking, related
and duplicate links as dependencies. Attachments, reminders, repeats,
other relation kinds, label and project colors, WIP limits, backgrounds,
reactions and saved filters are reported. The zip is uploaded, or its
data.json chosen or pasted, and opened on the server under size, entry
and inflate limits. Export writes the same zip, with a list called Done
as the done bucket and several swimlanes as child projects.

tests/vikunjaFormat.test.cjs covers both layouts, the round trip through
the zip and the negatives; Playwright cases import a zip and a pasted
data.json through the page and download the export. New instruction text
is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:20:06 +03:00
Lauri Ojansivu bd6a8ce019 Import and export boards as Taiga project dumps.
Taiga's Admin > Project > Export writes, and its load_dump importer reads,
one JSON object: the whole project, with people as emails and statuses,
swimlanes, sprints and roles by name. User story statuses become lists,
Taiga swimlanes swimlanes, and user stories cards in kanban order with
their tags, assignees, owner as Requested by, watchers, dates and comments
from the history entries. Tasks become subtask cards of their story with
their own status, people, dates and comments; epics and issues get
swimlanes of their own, an epic is the parent of its first story and an
issue's type, priority and severity become labels. Custom attributes,
story points (the Scrum estimate), blocked notes and requirements become
custom fields, tag colors the nearest label colors, open milestones Scrum
sprints with the backlog order as rank. Attachments (the page leaves the
embedded files out before sending), the wiki, the timeline, votes, WIP
limits, memberships and closed sprints are reported. A .json.gz dump is
unpacked first. Export writes every key Taiga's exporter writes, with
subtasks as tasks, a story's checklist items as tasks and sprints with
both dates as milestones.

Imported labels take a board-level label_colors map as well as a tag's
own color.

tests/taigaFormat.test.cjs covers the mapping, the negatives, that every
name the dump refers to exists, and round trips both ways, on a fixture
written from taiga-back's export serializers. Playwright cases import a
dump through the page, reject a malformed one, and the export audit
fetches the new format. New instruction text is in English, pending
Transifex.

Thanks to xet7 !
2026-10-08 21:17:07 +03:00
Lauri Ojansivu b7e515dba6 Import and export boards as Super Productivity backups.
Super Productivity's Export Data writes sp-backup_*.json: {timestamp,
lastUpdate, crossModelVersion, data}, with project, task, tag, note, boards
and archiveYoung/archiveOld as {ids, entities} entity states. Projects become
swimlanes, so none is dropped; the board takes the title of the only one.
Its boards are saved filters, not containers, so lists follow its default
Kanban board: done tasks in Done, the KANBAN_IN_PROGRESS tag in In Progress,
a project's backlog in Backlog, the rest in To Do. Tasks become cards and
sub-tasks sub-task cards, tags labels, notes and web link attachments the
description, the scheduled day or time the due date (the start date when a
deadline is the due date), doneOn the end date, timeSpent spent hours,
timeEstimate and priority custom fields, and archived tasks archived cards.
Repeat configurations, reminders, issue links, project notes, local
attachments, the per-day time breakdown and the saved boards are reported;
pre-v14 backups are refused.

Export writes a backup Import from File accepts at crossModelVersion 4.5:
project, task, tag, note, boards and both archives, leaving the slices the
app fills with defaults out. Swimlanes become projects, lists one board of
panels with other lists as tags, checklists markdown task lists in the
notes, and spent hours are booked on the card's end or creation day.

tests/superProductivityFormat.test.cjs checks the mapping, the negatives,
the round trip and the export against Super Productivity's own field and
cross-model validation; a Playwright case imports through the page and the
export audit fetches the format. New instruction text is in English,
pending Transifex.

Thanks to xet7 !
2026-10-08 21:14:58 +03:00
Lauri Ojansivu 1ceaad80f4 Import and export boards as monday.com Excel workbooks.
monday's "Export board to Excel" is documented only through its help
article's screenshots and cannot be changed: the board's name in row 1,
then per group its name, a header row starting Name with the board's
own column titles, the items and a summary row; with "+ updates" a
<board>-updates sheet of Item ID, Item Name, User, Created At and Update
Content. Column titles are the board owner's, so they are matched by
meaning: Name is the title, Status the list (groups become swimlanes;
without a Status column the groups are the lists), Person / People /
Owner / Assignee the owner and assignees, Date / Due date / Deadline the
due date, Timeline the start and due dates, Tags labels, Item ID the
reference, Long text / Description / Notes the description, and every
other column a custom field. Updates become comments on the item they
name. Subitems are undocumented; as community reports show them - a
Subitems header row after the parent, its rows indented one column -
they become subtasks. Bad dates, nameless items and updates for unknown
items are reported. Export writes the flat table monday's own Excel
import reads: the first sheet, a header row and ISO dates.

tests/mondayFormat.test.cjs builds the documented layout with ExcelJS,
including updates and subitems, and covers the negatives and the round
trip; a Playwright case imports a workbook through the page. New
instruction text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:13:39 +03:00
Lauri Ojansivu 68b2cceb19 Import and export boards as Tasks.org backups.
Tasks.org's backup (Settings > Backups > Export tasks) is JSON:
{version, timestamp, data:{tasks, tags, caldavAccounts, caldavCalendars,
...}}, written with every default left out. A task's list is its
caldavTasks[].calendar, named by caldavCalendars[].uuid; lists become
lists and tasks cards, with notes as description, tags as labels,
priority 0-2 as custom field Priority (High, Medium, Low), due and start
dates in epoch ms (a time only when ms % 60000 > 0, otherwise all-day,
kept as that day at 12:00 UTC), completion as the end date, elapsed time
as time spent, the estimate as custom field Estimate (hours), comments,
and caldavTasks[].remoteParent as subtask cards linked to their parent -
Tasks.org subtasks are full tasks with their own dates and completion,
which a checklist item could not keep. Deleted tasks are skipped and
reported; repeat rules, reminders, location reminders, a running timer,
attachments (the backup has no file contents), comment pictures and
undefined lists are reported. Export writes a backup Tasks.org's Import
backup accepts: one local account named after the board, a list per
WeKan list, tag definitions and per task its caldavTasks row, with
stable ids so a second restore skips tasks it already has; checklist
items become subtasks.

tests/tasksorgFormat.test.cjs runs a backup shaped like Tasks.org's
exporter output, the negatives, the fields its importer requires and the
round trip; a Playwright case imports through the page and the export
audit fetches the format. New instruction text is in English, pending
Transifex.

Thanks to xet7 !
2026-10-08 21:10:58 +03:00
Lauri Ojansivu 2e5fd9530e Import and export boards as Pivotal Tracker stories CSV.
Pivotal Tracker shut down on 2025-04-30; its stories CSV exports remain.
Columns are matched by name and repeated ones (Owned By, Blocker/Blocker
Status, Comment, Task/Task Status, Pull Request, Git Branch) collected in
order, so exports from before about 2018, which have no Priority, read
too. Current State becomes lists in Tracker's workflow order (unscheduled
to rejected), Type and Labels labels, Id the source reference, Owned By
the owner and assignees, Requested By Requested by, Created at / Accepted
at / Deadline the created, end and due dates ("Nov 22, 2014" or
11/22/2014), Estimate the Story points field and Scrum estimate, Priority
a custom field, each Iteration with its dates a Scrum sprint (one holding
only accepted stories is finished and reported), comments keep the author
and date of their "(Author - Mon D, YYYY)" tail, Task pairs a Tasks
checklist with done items, and an unresolved "#id" blocker an
is-blocked-by dependency. Pull requests, git branches, other blockers and
unknown states, types, priorities and dates are reported. Export writes
the columns Tracker's import reads, without Id, Iteration and URL.

Todoist's RFC 4180 reader is shared. tests/pivotalCsv.test.cjs runs a
2023 and a pre-2018 export, the Scrum planning, the negatives and the
round trip; a Playwright case imports through the page and the export
audit fetches the format. New instruction text is in English, pending
Transifex.

Thanks to xet7 !
2026-10-08 21:09:53 +03:00
Lauri Ojansivu eec53eb322 Import and export boards as Kanri JSON.
Kanri's Import & Export page writes, and its Import from Kanri reads, one
board (Partial Export: id, title, columns of cards, background, globalTags)
or all data (Full Export: the app settings and every board). Columns
become lists, cards become cards with their description, due date and
due-date-done flag and the card id as source reference, a card's tasks a
Tasks checklist, tags labels with their colors, and Kanri's card colors
WeKan's (teal and custom colors as hex). One import makes one board, so
from all data the first board is imported and the others are reported, as
are the background image, the countdown due date display, tags no card
uses and colors that are not colors. Imported labels now keep a source's
label color, and the collected export carries the card color and due-date
done. Export writes a single-board file Kanri's Partial import accepts.

tests/kanriFormat.test.cjs covers the mapping, all-data files, the round
trip and the negatives; Playwright cases import a board and an all-data
file through the page, and the export audit fetches the new format. New
instruction text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:08:40 +03:00
Lauri Ojansivu 2725f7a2aa Import and export boards as Nullboard .nbx files.
Nullboard's "Export this board..." writes plain JSON despite the .nbx
extension: one board {format, id, revision, title, lists: [{title,
notes: [{text, raw, min}]}]}, or an array of them for "Export all
boards". Every board is checked as Nullboard's own checkImport checks
it - the five keys, a non-empty id and revision, a lists array and
format 20190412 - and anything else is refused. Lists become lists and
notes cards; a note is free text, so its first non-blank line is the
card title and the rest the description. A raw note, drawn as a
heading in the list, gets the label raw; collapsed notes, empty notes,
repeated list titles and every board after the first in an array are
reported. Export writes one board Nullboard imports, with the title and
description as the note text, checklists after them as [ ] / [x] lines
and a card labelled raw as a raw note; Nullboard notes are text only,
so other labels, dates, people and comments are not written.

tests/nullboardFormat.test.cjs runs a welcome-board shaped sample, the
negatives and a round trip through Nullboard's checkImport; a
Playwright case imports through the page and the export audit fetches
the format. New instruction text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:07:01 +03:00
Lauri Ojansivu 1e7911a2d0 Import and export boards as ClickUp task CSV.
ClickUp documents two CSV shapes, both read by header name: the
workspace export (Task ID, Task Link, Task Type, Task Custom ID, Task
Name, Task Content, Status, each date as Unix milliseconds and as text,
Parent ID, Subtask IDs, Attachments, Assignees, Tags, Priority, List
Name, Folder Name/Path, Space Name, the time columns, Checklists and
Comments) and the Spreadsheets importer's columns (Priority 1-4,
Description content, List, Task assignee, Checklist, Time Estimate).
Statuses become lists, ClickUp lists swimlanes, the Space the board
title. Tasks become cards with Parent ID or the parent's Subtask IDs as
subtasks, Task Content as description with its attachments as links,
the [A,B] assignees and tags, the created, due and start dates (the
millisecond column, or ISO 8601), Time Spent as spent hours, and
Priority, Task Type, Custom ID, Folder and Time Estimate as custom
fields; the importer's Checklist becomes a checklist. The export's
Checklists and Comments cells have no documented format and are
reported, as are other dates. Export writes the workspace export
columns, plus the importer's Checklist column, which ClickUp maps by
name.

tests/clickupCsv.test.cjs covers both shapes, ClickUp's own importer
example, the negatives and the round trip; a Playwright case imports
through the page and the export audit fetches the format. New
instruction text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:04:38 +03:00
Lauri Ojansivu 46f026ddb6 Import and export boards as TickTick backup CSV.
TickTick's Generate backup writes, and Import backup reads, a CSV that
starts with a quoted Date / Version / Status preamble, then Folder Name,
List Name, Title, Kind, Tags, Content, Is Check list, the start and due
dates, Reminder, Repeat, Priority, Status, the created and completed
times, Order, Timezone, Is All Day, Is Floating, Column Name, Column
Order, View Mode, taskId and parentId, and since version 7.2 projectKind.
TickTick publishes no specification; this follows real 7.1 and 7.2
backups, as Vikunja's TickTick migrator reads them. The header is found
by its first cell and columns are read by name.

Each TickTick list becomes a swimlane and its kanban columns lists.
Tasks become cards with Content as description and its ▫ / ▪ lines as
the checklist, tags as labels, and the start, due, created and completed
dates; an all-day start or due date is the calendar day in the task's
Timezone, so it does not move. Status 1 is completed, 2 archived and -1
the label won't do; Priority 1/3/5 and Folder Name are custom fields;
taskId and parentId make subtasks. Reminders, repeat rules and unknown
codes are reported. Export writes a 7.2 backup for one TickTick list.

tests/ticktickCsv.test.cjs covers 7.1 and 7.2 backups, time zones, the
negatives and the round trip; a Playwright case imports through the page
and the export audit fetches the format. New instruction text is in
English, pending Transifex.

Thanks to xet7 !
2026-10-08 21:02:01 +03:00
Lauri Ojansivu fb7cbc66e6 Import and export boards as Linear CSV.
Linear exports issues as CSV - the workspace export or a view's - with
ID, Team, Title, Description, Status, Estimate, Priority, Project,
Creator, Assignee, Labels, Cycle, the created, started, completed,
canceled and archived dates, Due Date and Parent issue, plus columns it
has added over time; they are matched by header name. Values are read as
Linear's own open-source CSV importer reads them: priority names, labels
joined by ", ", and a leading ' before text a spreadsheet could take for
a formula, which is removed. Statuses become lists and teams swimlanes;
issues become cards with the ID as reference and Parent issue as the
parent card, Assignee as owner, Creator as Requested by, the labels and
dates, Archived as an archived card, and Priority, Estimate, Project,
Cycle and Canceled as custom fields. Updated, Triaged, cycle dates,
Initiatives, milestones, SLA Status, non-ISO dates and unknown priorities
are reported. Export writes Linear's columns in its order, with the same
formula guard.

tests/linearCsv.test.cjs covers the mapping, the parent link, the
negatives and the round trip; a Playwright case imports through the page
and the export audit fetches the format. New instruction text is in
English, pending Transifex.

Thanks to xet7 !
2026-10-08 20:59:26 +03:00
Lauri Ojansivu 435461f939 Import and export boards as Obsidian Kanban plugin files.
The plugin keeps a board in one Markdown file, and the generic Markdown
import read it only partly: the frontmatter and settings footer were
reported as unknown lines, #tags and @{dates} stayed in titles, and the
Complete lanes and the Archive were lost. This follows the plugin's own
parser and writer: kanban-plugin: board frontmatter (basic accepted),
## Lane (limit) headings, **Complete** lanes, - [ ] cards with 4-space or
tab continuation lines, *** and ## Archive, and the %% kanban:settings %%
JSON footer, whose date-format, date-trigger and time-trigger are used.
Lanes become lists with the card limit as WIP limit; #tags labels;
@{date} @@{time} the due date; the Tasks plugin's dates (due, start,
created, done, scheduled) and priority emoji the dates and a Priority
custom field; its id and depends-on the reference and blocked-by links;
Dataview key:: value fields custom fields; task lines in a card's body
its checklist; [x] and Complete lanes the done label, as the Markdown
import does; the Archive archived cards. Recurrence, cancelled dates and
other frontmatter keys are reported. Export writes the plugin's layout.

Imported columns now carry a WIP limit: KanboardCreator turns a column's
wip_limit, or Kanboard's own task_limit, which it dropped until now, into
the list's limit.

tests/obsidianKanban.test.cjs covers the plugin's sample layout, custom
date formats, the negatives and the round trip; a Playwright case imports
through the page and the export audit fetches the format. New instruction
text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 20:57:08 +03:00
Lauri Ojansivu 804c7183a2 Import and export boards as MeisterTask project CSV.
MeisterTask reads one CSV shape and writes another; both are matched by
header name. Its import shape, from MeisterTask's own sample file, is
project,section,name,notes,due_date,status,tags; its export header is
id,token,name,notes,created_at,updated_at,status,due_date,
status_updated_at,assignee,section,tags. Sections become lists and tasks
cards, with notes as description, "; "-separated tags as labels, the
assignee as owner, due and created dates in ISO 8601, status 2 as
completed with status_updated_at (or completed_at) as the end date, and
status 8 or 16 (binned, archived) as archived cards. Columns MeisterTask
documents no shape for - checklists, comments, custom fields, tracked
time - unknown status codes and non-ISO dates are reported. Export writes
the import shape, which MeisterTask reads back.

Todoist's RFC 4180 reader is shared and names the format in its errors.
tests/meistertaskCsv.test.cjs runs MeisterTask's published sample, the
export header, the negatives and the round trip; a Playwright case
imports through the page and the export audit fetches the format. New
instruction text is in English, pending Transifex.

Thanks to xet7 !
2026-10-08 20:52:04 +03:00
Lauri Ojansivu 7ef5b875fa Import and export boards as Microsoft Planner Excel workbooks.
Planner's "Export plan to Excel" writes one sheet, Tasks: plan name, plan
ID and export date on rows 1-3, then Task ID, Task Name, Bucket Name,
Progress, Priority, Assigned To, Created By, the created, start, due and
completed dates, Late, Completed By, Description, Completed Checklist
Items, Checklist Items and Labels. Columns are matched by name, as newer
exports add Is Recurring. Buckets become lists and tasks cards, with the
Task ID as source reference, the ;-separated assignees as owner and
assignees, Created By as Requested by, the checklist and labels, and
Progress, Priority and Completed By as custom fields. Dates are text in
the exporting user's locale: day/month order is decided for the whole
file, and reported when every date could be read either way; date cells
keep their day. Which checklist items were done (Planner exports only a
count), a recurring task's repeat and unknown values are reported.
Export writes the same workbook as .xlsx.

The layout follows a real Planner export, the MIT-licensed test data of
the plannr package, added under tests/fixtures/planner/ with its
licence. tests/plannerFormat.test.cjs imports it, round-trips an export
through ExcelJS and covers the negatives; Playwright cases import the
file through the page and download the export. New instruction text is
in English, pending Transifex.

Thanks to xet7 !
2026-10-08 20:48:39 +03:00
Lauri Ojansivu e8fac5e85c Record every board import before its first write, and let an admin keep or discard an interrupted one.
An import that stopped halfway - a restart, a hung writer, a failure - left a
partial board nothing recorded. Each board import, copy, Trello zip and
Trello API import now writes an importRuns record first, with the id its new
board will have; every creator inserts the board with that id and the run's
id stamped on it. A heartbeat keeps the run alive; the method deadline now
stops the writer at its next step. A scan at startup and every 5 minutes
flags a stopped or failed run once and records it in Admin Panel ->
Problems -> Recovery, where an administrator keeps the partial board or
discards it: only the board carrying the run's stamp is removed, through the
board's own removal, then whatever else has its id. Discard is refused while
the import's Scrum stage is still written or recovered, and the Scrum resume
is refused while the import is discarded. Resume is deliberately not
offered: the source file is not kept, for its size, its personal data and
the anonymization it would undo; discard and import again instead.

Thanks to xet7 !
2026-10-08 12:44:46 +03:00
Lauri Ojansivu ef54907836 Import Scrum planning into an existing board.
Every Scrum import used to create a new board. A board administrator can
now import a native wekan-scrum-2 transfer, or a WeKan board export, into
a board that already exists, from the Sprints view: Preview shows what
would change and writes nothing, Import writes it.

Sprints and releases are matched by ID on this board, then by
provenance, then by a name exactly one record has on each side; the rest
are created once with the source's provenance, so importing the same
file again changes nothing. Cards are matched by ID, or by card number
and title, and never created; unmatched, ambiguous and other boards'
cards are reported and left alone. Matched cards get the file's sprint,
releases, backlog rank, issue type and acceptance criteria; a move into a
finished sprint is refused. The writes go through the journaled Scrum
import stage, so an interrupted import is finished or discarded the same
way, and are recorded as one Scrum History change.

Thanks to xet7 !
2026-10-08 12:36:57 +03:00
Lauri Ojansivu c06bf8d0e9 Sync sprints and releases into Scrum planning.
List Sync from Jira or GitLab now carries an issue's sprint and fix
versions / milestones into the board's Scrum planning while Scrum is
enabled on the board. A missing sprint or release is created on this
board with the dates the source gives; an existing one is matched by its
source ID first, then by name. A local planning change stays until the
source changes that issue's planning, and a first Sync never removes
planning. The writes go through the durable Sync journal and steps, so
an interrupted Sync is finished or discarded like any other.

Thanks to xet7 !
2026-10-08 12:35:58 +03:00
Lauri Ojansivu 958e9e13f3 Import Scrum sprints and releases from GitLab, OpenProject and Asana.
Only the Jira importer created sprints and releases. GitLab iterations and
milestones became nothing but milestone: and iteration: labels, OpenProject
versions only a version: label, and Asana milestones and Trello produced
nothing Scrum-related, so a board moved from those tools lost its planning.

Imports now map what each export really carries, through the same journaled
Scrum import stage as Jira and WeKan JSON, so an interrupted import is
recovered the same way. GitLab iterations become sprints and milestones
releases, with their dates and state. OpenProject versions become releases
and its Sprint resources sprints; position sets the backlog rank and story
points become the board's estimate field. Asana milestone tasks become
releases for themselves and the tasks they wait for. Trello has no sprints or
releases; its Power-Up data is counted in the import loss report.

As for Jira, a started sprint is imported as planned and a finished one not
at all, because the exports have no commitment or close snapshot; both are
reported. Malformed dates, unknown states, duplicate names and cards in an
iteration that is not imported are reported, never invented. The milestone
and iteration labels stay for List Sync and existing boards. The import
page's Scrum settings part now also decides whether external imports bring
their planning in. GitLab and OpenProject exports write each card's sprint
and first release back so a board round-trips.

Thanks to xet7 !
2026-10-08 12:08:29 +03:00
Lauri Ojansivu cb69750b17 Let administrators discard List Sync operations that cannot be replayed.
A saved List Sync operation whose list was removed, recreated or
reconfigured, or whose actor lost full-list write access, could never be
replayed. The replay job refused it every minute with only a console line,
and because a new Sync of the list resumes the pending operation first,
that list could not Sync at all.

Such an operation is now marked once, with one Recovery event, and a
blocked manual Sync says why. Admin Panel / Problems / Recovery lists these
operations with what they applied and their live replayability. An
instance administrator can discard one only while the same checks a replay
makes still fail. The discard holds the list's Sync lease, records one
immutable decision, then removes the saved steps and the operation marker,
reading each removal back. It writes no card: changes already applied stay
and the rest are never written. A retry or a second administrator only
finishes the removal, and a replay that finds a decided discard completes it
instead of resuming. The intent stays as evidence and the discard is
audited in Recovery.

Unit, source-wiring and negative tests cover recording once, refusing
non-administrators and replayable operations, and discarding twice; an app
test and a Playwright case cover the Recovery page. New interface text is
in English, pending Transifex.

Thanks to xet7 !
2026-10-08 11:53:06 +03:00
Lauri Ojansivu 727ceedd01 Let a card be in more than one release.
A card had exactly one release, scrum.releaseId. Jira import kept only the
first fix version of an issue and reported the rest as lost, Jira export
wrote no fix versions at all, and the card UI could not show or pick more
than one release.

A card's releases are now a list, scrum.releaseIds, with releaseId kept as
its first entry so older servers, importers and REST readers still see one.
Existing cards are not migrated: every reader goes through cardReleaseIds(),
which reads the list and the old single field the same way, so cards saved
either way work side by side, and a card moves to the new form on its next
Scrum save. A save with releaseIds replaces the list; a save with only
releaseId, from an older client, replaces the first release and keeps the
others, and null clears them. Every release must belong to the board,
checked in one query; duplicates collapse and a releaseId that contradicts
the list is refused.

Copies and moves to another board link each release by name. The native
transfer writes one release exactly as before and adds releaseIds only for
cards with several, and remaps each of them on import. Jira import maps every
fix version and Jira export writes them all as fixVersions. Board View /
Sprints shows each release's cards and how many are done, counting a card in
each of its releases. Scrum History checks and guards every release, and
rule e-mails name them all. The Product Backlog and card details use a
multiple select.

tests/scrumMultipleReleases.test.cjs covers the rules and fails if any code
reads the single field directly; a Playwright spec drives the UI. New text is
in English, pending Transifex.

Thanks to xet7 !
2026-10-08 11:51:44 +03:00
Lauri Ojansivu 711303af32 Import and export boards as Org mode outlines.
Org mode files from Emacs, Orgzly, Beorg or organice import as boards:
level-1 headings become lists and level-2 headings cards. TODO keywords,
including those a #+TODO line declares, decide the done tag; [#A]
priorities become priority:A labels and :tags: labels. SCHEDULED, DEADLINE
and CLOSED become the start, due and end dates, and a :CREATED: property the
creation date. Body text becomes the description, and its - [ ] checkboxes
and childless level-3 headings the card's checklist; a level-3 heading with
children becomes a checklist of its own. #+TITLE names the board.
Timestamps carry no zone in Org and are read and written as UTC.
Repeaters, warning delays and text outside cards are reported in the loss
report. Export writes the same outline.

tests/orgMode.test.cjs covers custom keywords, localized day names, the
round trip and the negatives. A Playwright case imports a file through the
page, and the export audit fetches the new format. New instruction text is
in English, pending Transifex.

Thanks to xet7 !
2026-10-08 11:21:05 +03:00
Lauri Ojansivu e6c8f85518 Import and export boards as OPML outlines.
OPML is what Workflowy, Dynalist, OmniOutliner, Logseq and most other
outliners export and import. Top-level outlines become lists and their
children cards, with the outliners' _note as the description and a completed
item (Workflowy's _complete, Dynalist's complete) as the done tag. Deeper
outlines become checklists with their descendants as items, and the head
title becomes the board title. A list's note and url/htmlUrl/xmlUrl links are
reported in the loss report. Export writes the same with Workflowy's
attribute names; line breaks and tabs in notes are written as character
references so that they survive the XML parser.

Like the Leo outline, the XML is parsed on the server only, with htmlparser2
in XML mode: DTDs and external entities are never resolved, and size and node
counts are bounded. tests/opmlOutline.test.cjs covers a Workflowy/Dynalist
file, the round trip and the negatives (an external entity, a node bomb). A
Playwright case imports an outline through the page, and the export audit
fetches the new format. New instruction text is in English, pending
Transifex.

Thanks to xet7 !
2026-10-08 11:18:14 +03:00
Lauri Ojansivu 1eabb367e7 Import and export boards as Todoist project templates (CSV).
Todoist's Export as a template writes, and Import from template reads, a
CSV with TYPE, CONTENT, DESCRIPTION, PRIORITY, INDENT, AUTHOR, RESPONSIBLE,
DATE ... DEADLINE_LANG columns. Sections become lists, tasks become cards,
indented sub-tasks a Sub-tasks checklist, and notes comments on the task
above. @label words become labels and leave the title, PRIORITY 1-3 become
labels p1-p3 (1 is Todoist's highest; 4 is its "no priority"), RESPONSIBLE
becomes the owner, and DATE becomes the due date, or the start date when a
DEADLINE is the due date. Dates in words such as "every monday", DURATION,
orphan notes and sub-tasks and unknown row types are reported in the loss
report. Export writes the same columns in Todoist's order, with its
view_style=board meta row. Todoist exports no completed tasks, so finished
checklist items are left out.

tests/todoistCsv.test.cjs covers quoted fields, the round trip and the
negatives. A Playwright case imports a template through the page, and the
export audit fetches the new format. New instruction text is in English,
pending Transifex.

Thanks to xet7 !
2026-10-08 11:15:34 +03:00
Lauri Ojansivu 71cd2aed05 Read MONGO_URL_FILE, MAIL_URL_FILE and S3_SECRET_KEY_FILE instead of three dead secret files.
MAIL_SERVICE_PASSWORD_FILE, MONGO_PASSWORD_FILE and S3_SECRET_FILE were
listed on every platform, and nothing read them. Per the maintainer decision
of 2026-10-08:

- MONGO_URL_FILE holds the whole MongoDB URL. Meteor connects before any
  WeKan code runs, so the Docker entrypoint, the snap's wekan-control,
  start-wekan.sh and start-wekan.bat read it and start WeKan with MONGO_URL
  set. An unreadable or empty file stops the start instead of falling back
  to a default database. The snap log now masks a password in MONGO_URL.
- MAIL_URL_FILE and S3_SECRET_KEY_FILE fill MAIL_URL and S3_SECRET_KEY first
  thing in server/main.js (models/lib/envSecretFiles.js). As for the login
  secrets, the variable wins over its file.
- The three dead names are gone from the Dockerfile, every docker-compose
  file, the snap settings and help, the start scripts and the docs. The
  example secret files are renamed to match, and WeKan logs a warning naming
  the replacement when a retired name is still set.

The issue itself was closed earlier, with only part of this done.

Thanks to xet7 !
2026-10-08 11:07:58 +03:00
Lauri Ojansivu 5d26e9fff8 Import and export boards as Focalboard (Mattermost Boards) archive text.
A Focalboard board.jsonl, from a .boardarchive zip, imports with or
without its version line: Focalboard's own importer reads the same
text. The board view's group-by select property becomes the lists.
Other select and multi-select properties become labels, and a property
called Labels gives labels by their own name. The first date property
becomes the due date, or start and due for a range. Text, number, email,
url, phone, checkbox and later dates become custom fields. Text and
heading blocks become the description, checkbox blocks a checklist, and
comment blocks comments. Members, person properties, images,
attachments and card templates are reported in the loss report. Export
writes the same text: a Status property for the lists, Labels, Due and
the custom fields. The field names follow Focalboard's model.Board and
model.Block.

tests/focalboard.test.cjs covers both board forms, the round trip and
the negatives. A Playwright case imports a board.jsonl through the page,
and the export audit fetches the new format. New instruction text is in
English, pending Transifex.

Thanks to xet7 !
2026-10-03 00:17:10 +03:00
Lauri Ojansivu 47a603a63f Discover the Jira estimate field from the export's schema.
The Jira import page now offers the numeric custom fields that the
pasted export declares in its schema, story points first, as
suggestions for the estimate field. When no field is entered and
exactly one field has Jira Software's story points type, that field is
used, in points. It is identified by its type, never by a name. With
two such fields, or none, nothing is chosen.

Thanks to xet7 !
2026-10-02 19:23:20 +03:00
Lauri Ojansivu b0803ffeaa Import Jira sprints, fix versions, rank and epic links as Scrum planning data.
The Sprint, Rank and Epic Link fields are found by their schema type, or
by name when the export has no schema, never by customfield number.
Future and active sprints become planned WeKan sprints with their goals
and dates. An active sprint is reported, because the export has no
commitment snapshot. Closed sprints are reported, not invented. Fix
versions become releases. Jira's rank orders the backlog, and a legacy
Epic Link becomes the card's parent. The data is written as a native
Scrum import, and these fields are no longer also imported as text
custom fields.

Thanks to xet7 !
2026-10-02 19:21:24 +03:00
Lauri Ojansivu f0323140f6 Import and export boards as Taskwarrior JSON.
Taskwarrior's task export / task import JSON is the task format of the
Taskwarrior command line tool, and WeKan read and wrote neither. It now
imports from the import picker, as a JSON array or one task per line as
versions before 2.4 write it, and exports from the board's export menu.
A completed task goes to Done, a waiting one to Waiting and a started one
to In Progress; project and priority become labels, tags become labels,
entry, due, scheduled and end become dates, annotations become comments
and depends becomes blocked-by dependencies resolved by uuid. WeKan's
wekanlist and wekandescription attributes, which Taskwarrior keeps as
orphaned UDAs, carry list names and descriptions across a round trip.
Deleted tasks, recurring templates, bad dates and unmapped attributes are
reported in the loss report instead of guessed.

tests/taskwarrior.test.cjs covers the mapping, both input shapes, the
round trip and the negatives; the format guards learn the new format and
a Playwright case imports a Taskwarrior export through the page. The new
instruction text is in English, pending translation.

Thanks to xet7 !
2026-10-02 15:53:14 +03:00