Composer Installation 

composer require web-vision/kanban-workspaces

After installation, activate the extension in the Extension Manager or verify it's enabled in your configuration.

Extension Manager Settings 

You can configure the extension under Admin Tools > Settings > Extension Configuration > kanban_workspaces:

• Disable reset to editing stage (disableResetToEditingStage) - By default disabled. When enabled, it prevents TYPO3's DataHandler from resetting a workspace record's stage back to the editing stage (stage 0) after a field update, so the record keeps its current workflow stage.
• Custom titles for default stages (customStageEditTitle, customStageReadyToPublishTitle, customStagePublishTitle) - Optional custom titles for the default "Editing" (stage 0), "Ready to publish" (stage -10) and "Publish" (stage -20) stages. Each accepts a plain string or a LLL:EXT:... translation reference; an empty value keeps the original TYPO3 title.

To access these settings:

1. Go to Admin Tools > Settings in the backend
2. Open Extension Configuration and select "kanban_workspaces"
3. Adjust the settings as needed and save

Stage Checklist (Workspace Stages) 

You can add optional checklist items to each custom workspace stage. When editors move a card to that stage on the kanban board, the "Send to Stage" modal shows the checklist at the top (informational only; no checkboxes or submission).

Where to configure: Admin Tools > Workspaces. Edit a workspace that has custom stages (Internal Stages / Custom Stages).

Steps:

1. Expand a custom stage (e.g. "Review", "Publish").
2. In the stage form, find the Checklist items (or "Stage checklist") inline section.
3. Add, reorder, or remove entries (each has a Title). Save the workspace/stage.

Only custom workspace stages (with a database record) can have checklist items. Internal/system stages (e.g. default "Editing") have no checklist configuration.

Site Configuration 

The extension automatically uses your site's configuration. No manual site configuration is required.

Static TypoScript 

A static TypoScript template is registered automatically:

• Name - "Kanban Workspaces Backend Module"
• Location - EXT:kanban_workspaces/Configuration/TypoScript
• Purpose - Backend module configuration

The template is optional but recommended for consistency.

Service Configuration 

Services are automatically configured through the extension's Services.yaml file:

services:
  _defaults:
    autowire: true
    autoconfigure: true

  WebVision\KanbanWorkspaces\:
    resource: '../Classes/'

Access Control 

The extension respects TYPO3's built-in access control:

• Users without workspace access cannot see the module
• Users can only interact with workspaces they're assigned to
• Stage edit/delete permissions are enforced per workspace

Backend User Permissions 

Ensure backend users have appropriate permissions:

• Web Module Access - Required to access the module
• Workspace Access - Required to see workspace-specific items
• Page Access - Respects page access control lists (ACLs)

From Earlier Versions 

If upgrading from an earlier version:

1. Update via Composer:

   composer update web-vision/kanban-workspaces

   Copied!

2. Run database migrations (if any):

   vendor/bin/typo3 extension:setup

   Copied!

3. Clear caches:

   vendor/bin/typo3 cache:flush

   Copied!
4. Verify the module still works after upgrade

Moving Items Between Stages 

To move a content item to a different stage:

1. Click and Hold the card you want to move
2. Drag the card to another column (stage)
3. Release the mouse button to drop the item in the new stage

The item will automatically transition to the new stage, and the change will be reflected in TYPO3's workspace system.

When you drag a card to another column (or use Approve or Revert on a card), the Send to Stage modal opens. If the target stage has checklist items configured by an administrator, a Checklist section appears at the top of the modal (below the blue info banner). Each item is shown as a list row with a checklist icon and the item title. The list is informational only (no checkboxes, no submission of state). Complete recipients/comments as needed and confirm to perform the stage transition.

Viewing Item Details 

To see more information about an item:

1. Click on a card to select it
2. The item's details will be displayed
3. You can view the item's title, current stage, and other metadata
4. Some implementations may allow inline editing of item properties

Editing Items 

To edit a content item's actual content:

1. Click on a card to view item details
2. Look for an Edit button or link
3. Click to open the item in the record editor
4. Make your changes in the editor interface
5. Save your changes

The changes will be applied in your current workspace, not the live website.

Depth Filter 

Controls how many page tree levels are shown:

• This Page - Only items directly on the selected page (depth 0)
• 1 Level - Selected page plus first level of child pages (depth 1)
• 2 Levels - Selected page plus two levels of children (depth 2)
• 3 Levels - Selected page plus three levels of children (depth 3)
• 4 Levels - Selected page plus four levels of children (depth 4)
• Infinite - All pages below the selected page, regardless of depth

Use the depth filter to focus on a specific section or show more items at once.

Language Filter 

For multi-language websites, filter by language:

• All - Show items from all languages
• English - Show only English language items
• Deutsch (German) - Show only German language items
• [Other languages] - Show items from specific languages configured on your site

This is helpful when managing content in multiple languages separately.

Stage Filter 

Show items from specific workflow stages only:

• All Stages - Show items in all stages
• Draft - Show only items in draft stage
• In Review - Show only items awaiting review
• [Custom Stages] - Show items in other custom stages defined for your workflow

Use the stage filter to focus on items that need your attention in specific stages.

Content Organization 

Use Clear Page Titles

Page titles appear on kanban cards, so clear, descriptive titles help everyone understand what content each card represents.

Organize Your Page Tree Logically

The depth filter shows multiple page tree levels, so a well-organized hierarchy makes the kanban board easier to use.

Set Appropriate Initial Stage

When creating new content, verify it starts in the correct initial stage for your workflow.

Workflow Management 

Move Items in Sequence

Follow your workflow stages in order. For example: Draft → Review → Approved → Published.

Use Consistent Staging

Ensure all editors follow the same workflow stages to maintain consistency.

Complete Stages Promptly

Don't leave items stuck in intermediate stages. Move them along the workflow as soon as they're ready.

Communication 

Check Before Publishing

Review item details before moving to final stages to ensure content quality.

Document Your Process

If your workflow includes stages like "In Review", ensure reviewers know to check the kanban board.

Use Comments and Stages

Some workflow implementations may include comment or note stages—use these for team communication.

Publishing Content 

Typical publishing workflow:

1. Select the page from the page tree
2. Verify the item is in the "Ready to Publish" or "Approved" stage
3. Drag the item to the "Published" stage
4. Confirm the transition in any prompts that appear
5. The content is now marked for publication

Reviewing Content 

For content review workflow:

1. Select a page with items in "In Review" stage
2. Check the review stage column
3. Click on items that need review
4. Edit if needed, or move to "Approved" if content is ready
5. Reject items back to "Draft" if changes are needed

Managing Translations 

For multi-language sites:

1. Select the page to manage translations for
2. Use the language filter to show items from one language
3. Manage that language's items through the workflow
4. Switch to another language in the filter
5. Repeat the process for each language

Overview 

The Assign feature lets you assign a backend user to a workspace content element (a card on the kanban board). You can add an optional title and description for the assignment. The assignment is stored in the extension’s own table and is shown on the card (including assignee avatar when available). When you assign a different user (not yourself), that user receives an email notification. When the record is published, assignment data for that record is cleaned up automatically.

Flow 

1. Assign You open the card context menu (⋯) and choose **Assign**. A modal opens with: **Title** (optional) Description (optional) **Assignee** (required) – select a backend user from the dropdown (populated from ``be_users``). You click OK. The extension sends the data to its own Ajax endpoint and saves one row in the table `sys_workspaces_assignee` (per record/workspace/assignee). If the assignee is not the current user and has a valid email, an assignment notification email is sent (subject and body from Fluid templates). The modal closes, a success message is shown, and the board refreshes. After refresh, the card shows the assignee (avatar image or initial) in the card footer, using data enriched from sys_workspaces_assignee and be_users.
2. Display When the board loads (or refreshes), workspace data is enriched with assignee info from `sys_workspaces_assignee` and `be_users` (including avatar URL from FAL when the backend user has an avatar). Each card that has an assignee shows it in the footer (avatar image if available, otherwise user initial).
3. Email notification When you assign another backend user (with a valid email), the extension sends one email per assignment using TYPO3’s mailer and Fluid email templates. The email uses the SystemEmail layout and the extension’s templates under EXT:kanban_workspaces/Resources/Private/Templates/Email/ (e.g. AssignmentNotification). * Sender and format can be overridden via Page TSconfig tx_workspaces.emails.*; otherwise global MAIL defaults (e.g. defaultMailFromAddress) apply.
4. Publish When a record is **published** (via TYPO3 workspace publish), the extension listens to the core event `AfterRecordPublishedEvent`. It then deletes all rows in sys_workspaces_assignee for that table, record UID, and workspace. * So assignments are only kept for draft/workspace content; they are not kept after publish.

Technical Summary 

• Storage: Table sys_workspaces_assignee (extension-owned). Optional TCA column t3ver_assignee on versioned tables points to the assignee mapping row; no core schema is changed beyond that.
• UI: Assign is in the card context menu (⋯ → Assign). Assign modal uses TYPO3 backend Modal with assignee dropdown; assignee is shown on the card with .card-assignees / .user-avatar (avatar image or initial).
• Backend: Ajax route kanban_workspace_assign (path /kanban-workspace/assign) → AssignAjaxController::assignAction; service AssigneeMappingService for persist and cleanup; AssignmentNotificationService for sending the assignee email; AssigneeCleanupAfterPublishListener for cleanup on publish; AssigneeEnrichmentListener to add assignee (and assignee avatar URL) to workspace data for display.
• Email: AssignmentNotificationService uses MailerInterface, FluidEmail, and templates AssignmentNotification.html / AssignmentNotification.txt; fallback MAIL template/layout paths ensure the SystemEmail layout is found even when global MAIL config overwrites defaults.

Prerequisites 

1. TYPO3 with EXT:workspaces and EXT:kanban_workspaces installed and the database schema applied (so sys_workspaces_assignee exists).
2. Backend user logged in, with access to the Kanban Workspaces module.
3. Non-Live workspace – e.g. create or switch to a workspace (not “Live”).
4. Content in workspace – at least one page or content element that has a version in that workspace (so it appears as a card on the board).

Apply Database Schema (if needed) 

If the table does not exist yet:

• Option A: Install Tool → Compare database → apply changes so that sys_workspaces_assignee is created from ext_tables.sql.
• Option B: If you use CLI: run your project’s database compare/sync command so that the extension’s schema is applied.

Get a Backend User UID 

You need a valid backend user UID for the “Assignee” field:

• In the TYPO3 backend, go to Admin Tools → Backend Users (or your user list), open a user and note the UID (e.g. 1, 2, 3).
• Or query the database: SELECT uid, username FROM be_users WHERE uid > 0;

Test 1: Assign a user to a card 

1. Switch to a non-Live workspace.
2. In the backend, go to Web → Kanban Workspaces.
3. Select a page in the page tree that has workspace content (so at least one card is visible).
4. Find a card on the board.
5. Open the card context menu (click the ⋯ “more” button on the card).
6. Click Assign.
7. In the modal: **Title:** e.g. “Review requested” Description: e.g. “Please check by Friday” * Assignee (Backend user UID): enter a valid backend user UID (e.g. 1).
8. Click OK.
9. Expected: Modal closes. A success notification (e.g. “Assignment saved”) appears. * The board refreshes; the card shows the assignee in the footer (e.g. avatar with initial or “U1”).
10. Optional: Open the same module again (or refresh the page). The same card should still show the assignee (data comes from sys_workspaces_assignee + enrichment).

Test 2: Change assignee / title / description 

1. On the same card, open the context menu again and choose Assign.
2. Change: **Assignee** to another backend user UID, or Title or Description.
3. Click OK.
4. Expected: Success message, board refresh, and the card shows the new assignee (and the stored title/description are updated in sys_workspaces_assignee).

Test 3: Validation (invalid assignee) 

1. Open Assign on any card.
2. Leave Assignee empty or enter 0 or a non-existent UID.
3. Click OK.
4. Expected: Either validation prevents submit, or you see an error message and the modal may close without saving. No new/updated row in sys_workspaces_assignee for invalid data.

Test 4: Cleanup on publish 

1. Note a card that has an assignee (e.g. table, UID, workspace).
2. Publish that record using TYPO3’s normal workspace publish (e.g. from the Workspaces list module or the action that publishes that version).
3. Expected: The record is published as usual. Rows in sys_workspaces_assignee for that table, record_uid, and workspace_id are removed by the extension’s listener.

4. Verify: In the database, run:

   SELECT * FROM sys_workspaces_assignee
   WHERE table_name = '<table>' AND record_uid = <uid> AND workspace_id = <workspace_id>;
   

   Copied!

   There should be no rows for that combination after publish.

Test 5: Assignee visible after full reload 

1. Assign a user to a card (Test 1).
2. Reload the Kanban Workspaces page (F5) or close and reopen Web → Kanban Workspaces.
3. Select the same page in the page tree.
4. Expected: The card still shows the assignee in the footer (enrichment from sys_workspaces_assignee + be_users).

Disable reset to editing stage 

Setting name: disableResetToEditingStage

Type: Boolean (checkbox)

Default: Disabled (0)

Description: When enabled, this option prevents TYPO3's DataHandler from resetting a workspace record's stage back to the editing stage (stage 0) after one of the record's fields is updated. With the option disabled (default), TYPO3's standard behavior applies and an edited record may fall back to the "Editing" stage.

The option is read via the EmConfiguration accessor and evaluated by the PreventResetToEditingStageDataHandlerHook DataHandler hook, which adjusts the stage before the record is persisted.

Custom titles for default stages 

Setting names: customStageEditTitle, customStageReadyToPublishTitle, customStagePublishTitle

Type: String

Default: Empty (TYPO3 default titles are used)

Description: These options override the titles of the three default TYPO3 workspace stages on the kanban board and in the workspace module:

Each value accepts either a hard-coded string (e.g. In review) or a translation reference using the LLL:EXT:... syntax (e.g. LLL:EXT:my_ext/Resources/Private/Language/locallang.xlf:stage.review). When a value is empty (default), the original TYPO3 stage title is kept.

The titles are applied by extending TYPO3's \TYPO3\CMS\Workspaces\Service\StagesService and overriding getStageTitle(); the extended service is registered in place of the core one via Symfony dependency injection.

Module Registration 

The backend module is configured in Configuration/Backend/Modules.php:

'web_kanbanworkspaces' => [
    'parent' => 'web',
    'position' => ['after' => 'web_info'],
    'inheritNavigationComponentFromMainModule' => true,
    'access' => 'user',
    'workspaces' => '*',
    'icon' => 'EXT:kanban_workspaces/Resources/Public/Icons/Extension.png',
    'path' => '/module/web/kanbanworkspaces',
    'labels' => 'LLL:EXT:kanban_workspaces/Resources/Private/Language/locallang_mod.xlf',
    'extensionName' => 'KanbanWorkspaces',
    'controllerActions' => [
        KanbanWorkspacesController::class => [
            'index',
        ],
    ],
]

Customizing Module Position 

To change where the module appears in the Web menu, modify the position configuration:

// Position before Web > Info
'position' => ['before' => 'web_info'],

// Position at the end of Web menu
'position' => ['bottom'],

// Position at the top of Web menu
'position' => ['top'],

Dependency Injection 

The extension uses TYPO3's service container for dependency injection. Services are configured in Configuration/Services.yaml:

services:
  _defaults:
    autowire: true
    autoconfigure: true
    public: false

  WebVision\KanbanWorkspaces\:
    resource: '../Classes/*'
    exclude: '../Classes/Domain/Model/*'

  WebVision\KanbanWorkspaces\Controller\KanbanWorkspacesController:
    public: true
    tags:
      - name: 'backend.controller'
        identifier: 'KanbanWorkspaces'

  WebVision\KanbanWorkspaces\Configuration\EmConfiguration:
    public: true

  WebVision\KanbanWorkspaces\Service\AssigneeMappingService:
    public: true
  WebVision\KanbanWorkspaces\Notification\AssignmentNotificationService:
    public: true

This configuration automatically registers classes in Classes/ and enables autowiring. The listed services are explicitly public so they can be resolved when the Assign Ajax controller is instantiated by the backend dispatcher.

Ajax Route for Assign 

The Assign feature uses a backend Ajax route so the kanban board can save assignments without leaving the module.

File: Configuration/Backend/AjaxRoutes.php

return [
    'kanban_workspace_assign' => [
        'path' => '/kanban-workspace/assign',
        'target' => \WebVision\KanbanWorkspaces\Controller\AssignAjaxController::class . '::assignAction',
        'inheritAccessFromModule' => 'web_kanbanworkspaces',
    ],
];

• path – URL path for the Ajax endpoint.
• target – Controller class and action handling the request.
• inheritAccessFromModule – Access is inherited from the Kanban Workspaces module (web_kanbanworkspaces).

No additional configuration is required; the route is registered when the extension is active. Clear backend cache if the route does not appear.

MAIL Configuration for Assignment Emails 

When you assign a different backend user (not yourself) to a card, the extension can send an assignment notification email. TYPO3’s global MAIL configuration is used.

Recommended in your project config (e.g. ``config/system/settings.php``):

'MAIL' => [
    'defaultMailFromAddress' => 'noreply@your-domain.com',
    'defaultMailFromName' => 'TYPO3 Kanban Workspaces',
    'transport' => 'sendmail',
    'transport_sendmail_command' => '/usr/local/bin/mailpit sendmail -t --smtp-addr 127.0.0.1:1025',
    // ... other transport options
],

• defaultMailFromAddress – Sender address when no page-specific sender is set. Required for emails to be accepted by many mail servers.
• defaultMailFromName – Sender name shown in the email client.
• transport / transport_sendmail_command – How mail is sent (e.g. sendmail, SMTP, or a local tool like Mailpit for development).

Optional – Page TSconfig (per-page sender/format):

You can override sender and format per page using the workspaces email config:

tx_workspaces.emails {
    senderEmail = no-reply@example.com
    senderName = My Site
    format = both
}

The extension uses the same pattern as EXT:workspaces for email (FluidEmail, SystemEmail layout). Template/layout paths fall back to TYPO3 core/backend defaults when the global MAIL config does not define templateRootPaths / layoutRootPaths.

Troubleshooting: If assignment emails are not sent, ensure the assignee has a valid email in the backend user record, check MAIL.transport and defaultMailFromAddress, and review TYPO3 logs (e.g. var/log/typo3_*.log) for transport or template errors.

Backend JavaScript Modules 

The extension loads backend JavaScript modules for the kanban board interface:

// Main kanban board application
$this->pageRenderer->loadJavaScriptModule('@web-vision/kanban-workspaces/App.js');

// TYPO3 workspaces send-to-stage form component
$this->pageRenderer->loadJavaScriptModule('@typo3/workspaces/renderable/send-to-stage-form.js');

Configuration Location: Configuration/JavaScriptModules.php

These modules are loaded exclusively in the backend module interface. No frontend JavaScript is loaded by this extension.

Development Environment 

For development, you may want to enable additional backend debugging:

// In your project's configuration
$GLOBALS['TYPO3_CONF_VARS']['BE']['debug'] = true;

Production Environment 

For production, ensure optimal performance by using TYPO3's standard caching configuration. The extension respects the default caching settings configured in your TYPO3 instance.

Working with Multiple Sites 

If your TYPO3 instance has multiple sites, the Kanban Workspaces module will work independently for each site:

1. Each site can have its own workspace configuration
2. Stages are workspace-specific, not site-specific
3. Users see workspaces based on their access permissions
4. The module respects site-specific language configurations

No site-specific configuration is needed—the extension automatically uses the active site's settings.

Workspace Stages 

Workspace stages are configured in the TYPO3 workspace settings, not in this extension. To configure stages:

1. Go to Admin Tools > Workspaces
2. Select a workspace to edit
3. Configure available stages for that workspace
4. Save the workspace configuration

The Kanban Workspaces extension will automatically display the configured stages on its board.

Accessing Content at Different Stages 

The kanban board shows all content items at different stages in the workspace:

• Stage 0 (Editing) - Default editing stage
• Custom Stages - Any custom stages created for your workflow
• Published - Items ready for publication

Each stage can have different permissions for editing, deletion, and stage transitions.

AfterDataGeneratedForWorkspaceEvent 

The extension includes an event listener for workspace data generation. It is registered via a PHP attribute (no manual Services.yaml entry required):

#[AsEventListener(
    identifier: 'kanban-workspaces/assignee-enrichment',
)]
final class AssigneeEnrichmentListener

Purpose: Processes workspace data when it is generated (for example, enriching records with assignment information).

Configuration: No manual configuration needed—automatically registered by TYPO3's service container.

Caching 

The extension respects TYPO3's caching strategy. Workspace data is typically not cached (to always show current status), but you can configure caching if needed:

$GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['kanban_workspaces'] = [
    'frontend' => \TYPO3\CMS\Core\Cache\Frontend\VariableFrontend::class,
    'backend' => \TYPO3\CMS\Core\Cache\Backend\Apcu::class,
];

Database Queries 

The extension uses efficient database queries through TYPO3's repository pattern. For large workspaces:

1. Use depth filters to limit query results
2. Filter by language to reduce items
3. Regularly publish items to keep workspace size manageable

Backend Module Assets 

Assets are loaded automatically in the backend module controller:

// Load CSS
$this->pageRenderer->addCssFile('EXT:kanban_workspaces/Resources/Public/Css/Styles.css');
$this->pageRenderer->addCssFile('EXT:kanban_workspaces/Resources/Public/Css/Fontawesome.min.css');

// Load JavaScript modules
$this->pageRenderer->loadJavaScriptModule('@web-vision/kanban-workspaces/App.js');

Location: Resources/Public/Css/ and Resources/Public/JavaScript/

These are backend-only assets used exclusively in the kanban board backend module. No frontend assets are loaded or used by this extension.

Localization Files 

Language labels are stored in:

Resources/Private/Language/locallang_mod.xlf

These contain labels for:

• Module title
• Button labels
• Filter labels
• Error messages
• Stage names

Settings Not Taking Effect 

If configuration changes don't appear:

1. Clear TYPO3 caches: Admin Tools > Maintenance > Clear Cache
2. Clear browser cache: Ctrl+Shift+Del
3. Verify settings were actually saved in Extension Manager
4. Restart your web server if running locally

Module Position Wrong 

If the module appears in the wrong location:

1. Check the position configuration in Configuration/Backend/Modules.php
2. Verify the referenced module (e.g., 'web_info') exists
3. Clear all caches and reload the backend
4. Check for module position conflicts with other extensions

Controller 

KanbanWorkspacesController

Namespace: WebVision\KanbanWorkspaces\Controller\KanbanWorkspacesController

Responsibility: Main backend module controller handling HTTP requests and view rendering.

Key Methods:

indexAction ( ) : ResponseInterface

Main action rendering the kanban board interface.

Responsibilities:

• Retrieves active workspace and page context
• Fetches configured workspace stages
• Prepares filter options (depth, language, stage)
• Loads CSS and JavaScript assets
• Renders ModuleTemplate with configured data

Returns: ResponseInterface containing rendered module HTML

Access: Requires workspace and page access

addAssets ( ) : void

Loads CSS and JavaScript modules required for the kanban board.

Loaded Assets:

• Resources/Public/Css/Styles.css - Kanban board styles
• Resources/Public/Css/Fontawesome.min.css - Icon fonts
• @web-vision/kanban-workspaces/App.js - Main JavaScript application
• @typo3/workspaces/renderable/send-to-stage-form.js - Workspace form component

configureKanban ( array $stageConfig) : void

Configures the JavaScript frontend with stage and filter data.

Parameters:

• $stageConfig - Array of stage configuration with page ID, workspace, stages, and filters

Example:

$this->configureKanban([
    'pageUid' => 123,
    'workspaceId' => 1,
    'stages' => $stageConfig,
    'selectedLanguage' => 'en',
    'selectedDepth' => 2,
    'selectedStage' => -99,
    'filters' => [
        'depth' => [...],
        'language' => [...],
        'stage' => [...],
    ],
]);

Copied!

getSystemLanguages ( int $pageId, string $selectedLanguage = '') : array

Retrieves available system languages for the given page.

Parameters:

• $pageId - Page UID to get languages for
• $selectedLanguage - Currently selected language (for marking as active)

Returns: Array of language configuration objects with id, label, and flag

Example Return:

[
    ['id' => 'all', 'label' => 'All', 'flag' => ''],
    ['id' => '0', 'label' => 'English', 'flag' => 'en'],
    ['id' => '1', 'label' => 'Deutsch', 'flag' => 'de'],
]

Copied!

Entry point and orchestrator 

• App.js – entry point loaded as the module trigger. It enables horizontal drag-to-scroll (core/HorizontalScroll.js), instantiates WorkspaceBoard with the runtime options (API URLs, feature flags such as enableDragDrop / enableFilters / enableSearch, mockData), and registers the application-level event handlers — most importantly card:moved, which POSTs the move to the workspace dispatch endpoint.
• WorkspaceBoard.js – the WorkspaceBoard class. It owns the shared state (cards, stages, filters, selection, undo/redo history, current workspace, search query) and the lifecycle wiring, and delegates the real work to its collaborators. Collaborators are constructed with a back-reference to the board and reach shared state and each other through it (e.g. this.board.data, this.board.renderer.renderBoard()).

Collaborators 

Events 

WorkspaceBoard exposes on(event, handler) / off(event, handler) / emit(event, …) through its EventEmitter. Subscribe to observe and extend behaviour. Notable events:

• board:initialized, board:rendered, board:destroyed – board lifecycle.
• data:loaded – workspace records fetched and transformed.
• card:moved, card:drop, card:dragstart, card:dragend, card:click – card interactions.
• filter:change, filter:clear, search:change, search:clear – filter / search changes.
• comment:added – a comment was added in the preview modal.

Database and TCA 

• Table: tx_kanbanworkspaces_stage_checklist (see ext_tables.sql). Columns: uid, pid, tstamp, crdate, deleted, sorting, stage (FK to sys_workspace_stage.uid), title.
• TCA: Configuration/TCA/tx_kanbanworkspaces_stage_checklist.php defines the checklist table (label, sorting, delete, columns stage, title; record icon kanban-workspaces-stage-checklist).
• TCA override: Configuration/TCA/Overrides/sys_workspace_stage.php adds checklist_items inline field to sys_workspace_stage (after responsible_persons). Inline: sortable, expandSingle, no sync/localization links.

AssignAjaxController 

Namespace: WebVision\KanbanWorkspaces\Controller\AssignAjaxController

Responsibility: Handles the Ajax request for saving an assignment (assignee, title, description) and triggers persistence and email notification.

Route: kanban_workspace_assign, path /kanban-workspace/assign (see Configuration/Backend/AjaxRoutes.php). Access is inherited from module web_kanbanworkspaces.

Key method: assignAction(ServerRequestInterface $request): ResponseInterface – parses request body (table, record_uid, workspace_id, stage_id, be_user, title, description), calls AssigneeMappingService::persistAssignmentWithMeta() and AssignmentNotificationService::notifyAssignee(), returns JSON success/error.

Note: The controller is instantiated by the backend dispatcher via GeneralUtility::makeInstance() (no constructor args). It resolves AssigneeMappingService and AssignmentNotificationService from the container inside the action; both services are registered as public in Configuration/Services.yaml.

AssigneeMappingService 

Namespace: WebVision\KanbanWorkspaces\Service\AssigneeMappingService

Responsibility: Persists assignment data to sys_workspaces_assignee (insert or update per record/workspace), sets t3ver_assignee on the versioned record, and cleans up assignee rows when a record is published.

Key methods:

• persistAssignmentWithMeta(beUserId, tableName, recordUid, workspaceId, stageId, title, description) – upserts one row in sys_workspaces_assignee and updates the record’s t3ver_assignee column.
• cleanupForPublished(table, recordId, workspaceId) – deletes rows in sys_workspaces_assignee for the given table/record/workspace (called by AssigneeCleanupAfterPublishListener).

AssignmentNotificationService 

Namespace: WebVision\KanbanWorkspaces\Notification\AssignmentNotificationService

Responsibility: Sends an email to the assignee when they are assigned to a record (unless the assignee is the current user or has no valid email). Uses TYPO3’s MailerInterface and FluidEmail with the extension’s templates and the core SystemEmail layout.

Dependencies: MailerInterface, LoggerInterface, StagesService, PreviewUriBuilder.

Templates: Resources/Private/Templates/Email/AssignmentNotification.html and AssignmentNotification.txt. Fallback MAIL template/layout/partial paths (EXT:core, EXT:backend) are used when global MAIL config does not define them.

Configuration: Sender/format can be overridden via Page TSconfig tx_workspaces.emails.*; otherwise MAIL.defaultMailFromAddress / defaultMailFromName and transport apply.

AssigneeEnrichmentListener 

Namespace: WebVision\KanbanWorkspaces\EventListener\AssigneeEnrichmentListener

Event: TYPO3\CMS\Workspaces\Event\AfterDataGeneratedForWorkspaceEvent

Identifier: kanban-workspaces/assignee-enrichment (runs after kanban-workspaces/after-data-generated-for-workspace).

Responsibility: Enriches each workspace item in the event data with assignee info from sys_workspaces_assignee and be_users: assignee_uid, assignee_username, assignee_avatar_url (from FAL avatar when available). The frontend uses these to display the assignee on the card.

AssigneeCleanupAfterPublishListener 

Namespace: WebVision\KanbanWorkspaces\EventListener\AssigneeCleanupAfterPublishListener

Event: TYPO3\CMS\Workspaces\Event\AfterRecordPublishedEvent

Identifier: kanban-workspaces/assignee-cleanup-after-publish

Responsibility: After a record is published, calls AssigneeMappingService::cleanupForPublished() to remove assignee rows for that table/record/workspace.

Database and TCA 

Table: sys_workspaces_assignee (defined in ext_tables.sql). Columns include uid, pid, tstamp, crdate, title, description, be_user, table_name, record_uid, workspace_id, stage_id. One row per record/workspace (last assignee wins on update).

TCA: Configuration/TCA/Overrides/t3ver_assignee.php adds a read-only t3ver_assignee column (select on sys_workspaces_assignee) to all tables with versioningWS, so the versioned record can reference the assignee mapping row.

Services and Ajax Route 

Services.yaml: AssigneeMappingService and AssignmentNotificationService are explicitly public so they can be resolved from the container when AssignAjaxController is created by makeInstance. KanbanWorkspacesController and EmConfiguration remain public for module and config access.

Ajax route: Configuration/Backend/AjaxRoutes.php registers route kanban_workspace_assign with path /kanban-workspace/assign and target AssignAjaxController::assignAction.

Controller Interface 

The KanbanWorkspacesController extends ActionController and provides the backend module interface:

Injected Dependencies:

public function __construct(
    protected readonly ModuleTemplateFactory $moduleTemplateFactory,
    protected readonly IconFactory $iconFactory,
    protected readonly PageRenderer $pageRenderer,
    protected readonly WorkspaceStageRepository $workspaceStageRepository,
    protected readonly WorkspaceRepository $workspaceRepository,
    protected readonly EmConfiguration $emSettings,
    protected readonly TranslationConfigurationProvider $translationConfigurationProvider,
) {}

Available TYPO3 Services:

• ModuleTemplateFactory - Creates module template for rendering
• IconFactory - Generates icons for UI elements
• PageRenderer - Adds CSS/JS and inline configuration
• WorkspaceStageRepository - Retrieves workspace stages
• WorkspaceRepository - Retrieves workspace records
• TranslationConfigurationProvider - Gets site language configuration
• EmConfiguration - Extension Manager settings

Backend Module Configuration 

File: Configuration/Backend/Modules.php

Defines the backend module registration:

return [
    'web_kanbanworkspaces' => [
        'parent' => 'web',
        'position' => ['after' => 'web_info'],
        'inheritNavigationComponentFromMainModule' => true,
        'access' => 'user',
        'workspaces' => '*',
        'icon' => 'EXT:kanban_workspaces/Resources/Public/Icons/Extension.png',
        'path' => '/module/web/kanbanworkspaces',
        'labels' => 'LLL:EXT:kanban_workspaces/Resources/Private/Language/locallang_mod.xlf',
        'extensionName' => 'KanbanWorkspaces',
        'controllerActions' => [
            KanbanWorkspacesController::class => [
                'index',
            ],
        ],
    ]
];

Configuration Properties:

• parent - Parent module in the backend menu tree
• position - Position relative to other modules
• inheritNavigationComponentFromMainModule - Inherit parent module's navigation
• access - Access level required (user, admin, systemMaintainer)
• workspaces - Which workspaces the module is available in
• icon - Icon file path
• path - URL path for the module
• labels - Language file for localization
• extensionName - Extension identifier
• controllerActions - Maps controller classes to available actions

Service Configuration 

File: Configuration/Services.yaml

services:
  _defaults:
    autowire: true
    autoconfigure: true

  WebVision\KanbanWorkspaces\:
    resource: '../Classes/'

Enables automatic service registration and dependency injection for all classes in the Classes/ directory.

JavaScript Modules 

File: Configuration/JavaScriptModules.php

Defines and configures JavaScript modules needed for the module:

return [
    'dependencies' => [
        'core',
        'workspaces',
    ],
    'triggers' => [
        '@web-vision/kanban-workspaces/App.js',
    ],
];

Available Modules:

• @web-vision/kanban-workspaces/App.js - Main kanban board application
• @typo3/workspaces/renderable/send-to-stage-form.js - Stage transition form

Creating Custom Event Listeners 

To hook into workspace events:

<?php

namespace MyVendor\MyExtension\EventListener;

use TYPO3\CMS\Core\Attribute\AsEventListener;
use TYPO3\CMS\Workspaces\Event\AfterDataGeneratedForWorkspaceEvent;

#[AsEventListener(
    identifier: 'my-extension/custom-workspace-listener',
)]
final class CustomWorkspaceEventListener
{
    public function __invoke(AfterDataGeneratedForWorkspaceEvent $event): void
    {
        // Your custom logic here
    }
}

Registration: Automatically registered through Services.yaml with autoconfigure: true

Extending the Controller 

To add custom actions to the module:

<?php

namespace MyVendor\MyExtension\Controller;

use WebVision\KanbanWorkspaces\Controller\KanbanWorkspacesController as BaseController;
use Psr\Http\Message\ResponseInterface;

class ExtendedKanbanWorkspacesController extends BaseController
{
    public function customAction(): ResponseInterface
    {
        // Your custom action logic
    }
}

Register in your extension's Configuration/Backend/Modules.php:

'controllerActions' => [
    ExtendedKanbanWorkspacesController::class => [
        'index',
        'custom',
    ],
],

Customizing Views 

Override the default template in your extension:

1. Create Resources/Private/Templates/KanbanWorkspaces/Index.html
2. Copy content from the original extension
3. Modify as needed
4. Register in your extension's module configuration

Customizing Assets 

To customize styles or JavaScript:

1. Create custom CSS in Resources/Public/Css/Custom.css
2. Create custom JavaScript in Resources/Public/JavaScript/Custom.js
3. Load in your extension's controller or module configuration

Unit Testing 

To test your custom extensions:

<?php

namespace MyVendor\MyExtension\Tests\Unit\EventListener;

use PHPUnit\Framework\TestCase;
use MyVendor\MyExtension\EventListener\CustomWorkspaceEventListener;

class CustomWorkspaceEventListenerTest extends TestCase
{
    public function testEventListenerProcessesData(): void
    {
        $listener = new CustomWorkspaceEventListener();
        $event = new AfterDataGeneratedForWorkspaceEvent([]);
        
        $listener($event);
        
        $this->assertTrue(true); // Your assertions here
    }
}

Functional Testing 

Test the kanban board integration:

1. Create a test workspace with stages
2. Add test pages and content items
3. Navigate to the kanban module
4. Verify stage display and item appearance
5. Test drag-and-drop functionality

Enable Debug Output 

In LocalConfiguration.php:

'BE' => [
    'debug' => true,
],

Browser Console 

Open browser developer tools (F12) to see JavaScript console for:

• Module initialization errors
• Drag-and-drop logging
• Filter update notifications
• API communication logs

Backend Logging 

TYPO3 logs extension errors to var/log/typo3_*.log

Check logs for:

• Service initialization errors
• Database query failures
• Event listener exceptions
• Permission check failures

Database Query Optimization 

The extension uses efficient queries through TYPO3's repository pattern:

• Respects workspace context automatically
• Filters by language configuration
• Uses depth parameters for limited results
• Implements lazy loading where possible

For large workspaces:

1. Filter by depth in the UI
2. Filter by language for multi-language sites
3. Regularly publish items to keep workspace size manageable
4. Use workspace archiving features

Caching Strategy 

Workspace data is typically not cached to ensure current status. For custom implementations, consider:

// Cache workspace configuration (stable)
$cacheIdentifier = 'workspace_' . $workspaceId;

// Don't cache item/stage data (changes frequently)
// Always query fresh from database

Asset Optimization 

The extension loads assets efficiently:

• CSS files are concatenated by TYPO3
• JavaScript modules are loaded asynchronously
• Icons use icon factory for optimization
• Images should be optimized before deployment

PHP Standards 

The extension follows:

• PSR-12 - Extended coding style guide
• TYPO3 Coding Guidelines - TYPO3-specific standards
• Strict Types - All files use declare(strict_types=1)
• Type Hints - Full type declarations for methods and properties

JavaScript Standards 

• ES6+ Syntax - Modern JavaScript features
• TYPO3 JS Module Pattern - Uses TYPO3's module system
• Linting - TYPO3 ESLint configuration

Documentation Standards 

• PHPDoc Comments - All classes and methods documented
• RST Documentation - User and developer documentation
• Inline Comments - Complex logic is documented

TYPO3 Versions 

• Minimum: TYPO3 13.4.0 LTS
• Maximum: TYPO3 13.4.99 (latest v13 patch)

Breaking Changes: None planned for v13 support period

PHP Versions 

• Minimum: PHP 8.2.0
• Maximum: PHP 8.3.99

Features Used: Constructor property promotion (PHP 8.0+) Named arguments (PHP 8.0+) Match expressions (PHP 8.0+) Attributes (PHP 8.0+)

Backward Compatibility 

The extension maintains backward compatibility within v1.x versions. Changes between minor versions should not break existing code.

Breaking Changes 

Any breaking changes in major versions (2.0+) will be documented in:

• CHANGELOG.md - Version history
• Documentation/ChangeLog/Index.rst - Detailed migration guide

Migration Guide 

For upgrades from v0.x to v1.x:

1. Update via Composer
2. Run database migrations (if any)
3. Clear caches
4. Test functionality in development
5. Deploy to production

Common Issues and Solutions 

Module not showing up

1. Verify extension is activated
2. Check user has Web module access
3. Clear backend caches
4. Check browser console for errors

Stages not displaying

1. Verify workspace is active (not Live)
2. Check workspace configuration has stages
3. Verify page access permissions
4. Check EmConfiguration settings

Drag-and-drop not working

1. Check JavaScript console for errors
2. Verify user has stage edit permissions
3. Clear browser cache
4. Try different browser to isolate issue

Performance issues with large workspaces

1. Use depth filter to limit displayed items
2. Filter by language for multi-language sites
3. Consider splitting large workspaces
4. Monitor database query performance

Module Availability 

Issue: The Kanban Workspaces module only appears when in an active workspace.

Behavior: The module is hidden when in the Live workspace (TYPO3's main published content).

Reason: Kanban boards are designed for workspace content management. Live workspace doesn't have staging, so the kanban board isn't applicable.

Workaround: Switch to an active workspace to see the module. Users can change their workspace in:

1. Click their username in top-right corner
2. Select "Switch workspace" or similar option
3. Choose an active workspace (not "Live")

Status: Expected behavior (not a bug)

---

Issue: Module doesn't appear in Web menu.

Possible Causes:

1. Extension not activated
2. User lacks Web module access
3. Backend cache not cleared

Solutions:

1. Verify extension is in Extension Manager's "Installed Extensions"
2. Check user backend permissions include Web module access
3. Clear backend caches: Admin Tools > Maintenance > Clear Cache
4. Hard-refresh browser (Ctrl+Shift+R)

---

Empty Kanban Board 

Issue: Kanban board appears but shows no stages or items.

Possible Causes:

1. No workspace stages configured
2. No content in selected page tree
3. Page access restrictions prevent item display
4. Wrong depth/language filter selected

Solutions:

1. Verify workspace has stages configured: Admin Tools > Workspaces > [Select Workspace] > Stages
2. Ensure selected page has child content items
3. Try depth "Infinite" to see items at all levels
4. Change language filter to "All" to see all language variants
5. Check user has access to pages containing items

---

JavaScript Errors 

Issue: Browser console shows JavaScript errors preventing kanban board interaction.

Common Errors:

• "Cannot read property of undefined"
• "Module failed to load"
• "Drag functionality not initialized"

Solutions:

1. Clear browser cache completely: - Press Ctrl+Shift+Del - Clear all browsing data - Hard-refresh page (Ctrl+Shift+R)
2. Check browser compatibility: - Use modern browsers: Chrome 90+, Firefox 88+, Safari 14+, Edge 90+ - Ensure JavaScript is enabled - Try different browser to isolate issue
3. Check TYPO3 cache: - Admin Tools > Maintenance > Flush all caches - Then reload kanban board module
4. Verify extension assets are loaded: - Open browser DevTools (F12) - Network tab - Check CSS and JS files load with 200 status - Check console for loading errors

---

Stage Transitions Not Working 

Issue: Dragging items between stages doesn't work or shows errors.

Possible Causes:

1. User lacks permission to edit items
2. User lacks permission in target stage
3. Workspace doesn't allow stage transitions
4. JavaScript initialization failed

Solutions:

1. Check workspace permissions: - Admin Tools > Workspaces > [Select Workspace] - Verify user has edit rights in all stages - Verify target stage allows transitions
2. Check page/item access: - Users can only move items they can edit - Verify page access control list allows editing - Check field restrictions don't prevent stage field updates
3. Test with admin user: - If admin can move items but regular user can't, it's a permissions issue - Adjust workspace/page/field permissions
4. Check browser console: - F12 > Console tab - Look for error messages - Check Network tab for failed API requests

---

Performance Issues 

Issue: Kanban board loads slowly or becomes unresponsive with many items.

Causes:

1. Large number of items in workspace (hundreds or thousands)
2. Deep page tree being displayed
3. All languages shown at once
4. Insufficient server resources

Solutions:

1. Use depth filter: - Select "This Page" or "1 Level" instead of "Infinite" - Reduces displayed items significantly
2. Filter by language: - Show one language at a time instead of "All" - Reduces items by language count factor
3. Filter by stage: - Show specific stages instead of all stages - Helps focus on relevant items
4. Consider workspace size: - Regularly publish items to keep workspace manageable - Split large workspaces if needed - Archive completed versions
5. Server resources: - Check server CPU and memory usage - Ensure database has proper indexes - Consider database optimization

---

Multi-Language Issues 

Issue: Language filter shows unexpected language combinations.

Behavior: Language filter shows all configured site languages, not just active translations.

Reason: TYPO3 can have language definitions that don't have actual content.

Solutions:

1. Use language filter to show only languages with actual content
2. Verify language configuration in Site Settings
3. Check translation status of pages

---

Issue: Items from default language shown even with non-default language selected.

Reason: Some TYPO3 pages fallback to default language content if translation doesn't exist.

Solutions:

1. Ensure page translations exist before filtering
2. Check fallback language configuration in site settings
3. Create translations for all needed languages

---

Workspace-Related Issues 

Issue: Changes made in kanban board don't save to workspace.

Possible Causes:

1. Workspace is in read-only mode
2. User lacks write permissions
3. Database transaction failed
4. Workspace is locked

Solutions:

1. Check workspace isn't locked: Admin Tools > Workspaces > [Select Workspace]
2. Verify user has write permissions in workspace
3. Check error logs: var/log/typo3_*.log
4. Try again, errors may be temporary

---

Issue: "This workspace is not editable" message appears.

Cause: Workspace may be archived or in a read-only state.

Solutions:

1. Create a new active workspace
2. Use Live workspace temporarily if needed
3. Contact administrator to unarchive workspace

---

Browser-Specific Issues 

Safari Issues

• Drag-and-drop may not work smoothly
• Solution: Ensure Safari is up to date (14.1+)
• Consider using Chrome for better compatibility

Firefox Issues

• Occasional JavaScript module loading delays
• Solution: Clear browser cache, hard-refresh page

Internet Explorer 11

• Status: Not supported (requires modern browsers)
• Solution: Use Chrome, Firefox, Safari, or Edge instead

---

Display Issues 

Issue: Kanban board layout looks broken or columns are misaligned.

Causes:

1. CSS not loaded properly
2. Browser zoom level interfering
3. Very narrow screen (mobile/tablet)
4. Custom CSS conflicting

Solutions:

1. Check CSS loading: - F12 > Network tab - Verify Styles.css and Fontawesome.min.css load with 200 status - Check console for CSS parsing errors
2. Reset browser zoom: - Ctrl+0 (zero) to reset zoom to 100% - Try different zoom level
3. Use wider screen: - Tablet width may not accommodate all columns - Desktop width recommended - Check responsive view in DevTools
4. Check custom CSS: - Disable browser extensions affecting page styling - Clear browser cache completely

---

Conflicts with Other Extensions 

Extensions Known to Have Issues:

Currently, no known critical conflicts are documented. If you encounter conflicts:

1. Note which extension causes the conflict
2. Report to extension author
3. Use workarounds until fixed
4. Check extension release notes

Potential Conflict Sources:

• Custom workspace extensions
• Custom page tree modifications
• Backend UI customization extensions
• JavaScript library conflicts

Solutions:

1. Check for JavaScript console errors when conflicting extension is enabled
2. Disable conflicting extension if not critical
3. Contact extension authors about compatibility

---

Stage Configuration Problems 

Issue: Custom stages don't appear in kanban board.

Solutions:

1. Verify stages are configured in workspace: Admin Tools > Workspaces > Stages
2. Clear TYPO3 caches
3. Refresh kanban board module
4. Check user has access to all stages

---

Issue: Only the default stage appears; custom stages missing.

Check:

1. Are custom stages actually configured in the workspace?
2. Do you have view permissions for custom stages?

---

Access Control Issues 

Issue: "Access Denied" when trying to edit items.

Causes:

1. Missing workspace edit permission
2. Missing page edit permission
3. Missing field edit restriction
4. Page is locked by another user

Solutions:

1. Ask administrator to grant workspace edit rights
2. Ask page owner to grant edit access
3. Check field-level permissions (Admin Tools > User TSconfig)
4. Wait for other user to release page lock, or have admin break lock

---

Database Synchronization Issues 

Issue: Database shows changes not reflected in kanban board.

Solution:

1. Clear all caches: Admin Tools > Maintenance > Flush Cache
2. Reload kanban board page
3. Database should synchronize automatically

---

API/Integration Issues 

Issue: Custom code integrating with kanban extension fails.

Debug Steps:

1. Check extension documentation for API changes
2. Verify code uses correct namespaces and class names
3. Test with vanilla installation to isolate issue
4. Check error logs: var/log/typo3_*.log

---

Current Design Limitations 

1. Single Page Context: Each kanban board view shows one page tree root. Multiple workspaces require separate module instances.
2. Synchronous Updates: Stage transitions are synchronous. Large database updates may cause temporary UI freeze.
3. Language Structure: Language filtering is based on TYPO3 site language configuration, not arbitrary tag-based filtering.
4. Stage Permissions: Respects workspace stage permissions exactly as configured. Fine-grained field-level permissions may limit stage transitions.
5. Depth Limitations: Maximum practical depth is  4-5 levels. Beyond that, performance degrades significantly.
6. Browser Compatibility: Requires modern browsers with ES6+ support. Legacy browsers not supported.

---

Feature Limitations 

Not Currently Supported:

• Bulk stage transitions (single-click to move multiple items)
• Custom item properties display on cards
• Item color coding based on custom rules
• Kanban board persistence (selected filters reset on page reload)
• Mobile-optimized interface (desktop-only currently)

---

Planned Features (Not Yet Implemented) 

• Persistent filter selections (saved per user)
• Bulk operations on multiple items
• Custom kanban card templates
• Item relationship visualization
• Performance improvements for very large workspaces
• Mobile interface optimization

---

How to Report Bugs 

If you encounter issues not listed here:

1. Gather Information: - TYPO3 version - PHP version - Browser and version - Exact steps to reproduce - Error messages and logs
2. Check Existing Issues: - GitHub repository for known issues - Extension documentation for workarounds
3. Report to Developer: - WebVision issue tracker - Include reproduction steps - Attach relevant error logs - Describe expected vs. actual behavior
4. Include Debug Information: - Browser console screenshots - TYPO3 error logs (var/log/) - Extension configuration screenshot - Workspace configuration details

---

Resources for Assistance 

1. Extension Documentation - This guide and configuration docs
2. TYPO3 Community Forum - TYPO3 general questions and workspace info
3. Developer Documentation - For custom implementations
4. Administrator Documentation - For setup and configuration
5. Extension Author - WebVision GmbH for extension-specific issues

Support Contacts 

• Extension Issues: WebVision GitHub/Issue Tracker
• TYPO3 General: https://typo3.org/community/
• Documentation: This documentation set

New Features 

• Disable reset to editing stage – New extension configuration option disableResetToEditingStage; when enabled it prevents TYPO3's DataHandler from resetting a workspace record's stage back to the editing stage (stage 0) after a field update.
• Custom titles for default stages – New extension configuration options customStageEditTitle, customStageReadyToPublishTitle and customStagePublishTitle to override the titles of the default TYPO3 workspace stages (Editing, Ready to publish, Publish). Each accepts a plain string or a LLL:EXT:... translation reference; empty keeps the TYPO3 default. Implemented by extending StagesService::getStageTitle().

Breaking / Removed 

• Disable default stage and Default StageId - Disabling default stage (editing) and configure a default custom stage id to use has been removed; Removing default stage editing is not reasonable and the Default Custom Stage Id needs to be done on workspace level because multiple workspaces does not have the same custom stage at all. Removed for now and postponed to be added in more workable stage at a later point.

Supported Versions 

• TYPO3: 13.4.0+ (v13 LTS) && 14.3.0+ (v14 LTS)
• PHP: 8.2.0 to 8.5.99
• Browsers: TYPO3 Backend policy, last two supported versions of (Chrome, Firefix, Safari)

New Features 

• Checklist items per stage – In Admin Tools > Workspaces, edit a workspace and expand a custom stage; add, reorder, or remove checklist entries in the "Checklist items" inline section.
• Checklist in Send to Stage modal – When moving a card to a stage, the modal shows that stage's checklist (list with icon per item) below the info banner; empty stages show no checklist section.
• Assign user to card – Card context menu (⋯) → Assign opens a modal to set Title (optional), Description (optional), and Assignee (required; select from backend user list).
• Assignee on card – Each card shows the assignee in the footer (avatar image from FAL when available, otherwise user initial).
• Assignment notification email – When you assign a different user (not yourself) with a valid email, that user receives an email (Fluid templates, SystemEmail layout).
• Cleanup on publish – When a record is published via TYPO3 workspace publish, assignment rows for that record/workspace are removed automatically.
• Kanban Board Interface - Visual drag-and-drop interface for workspace stage management
• Multi-stage Workflow Support - Support for custom workspace stages with drag-and-drop transitions
• Depth-based Content Filtering - Filter displayed content by page tree depth (0-4 levels or infinite)
• Multi-language Support - Filter content by system languages (all languages, specific languages)
• Stage-based Filtering - Show items from specific workflow stages
• Backend Module Integration - Integrated into TYPO3 Web module with proper navigation
• Dynamic Stage Configuration - Auto-configuration from workspace settings
• TYPO3 v13 Compatibility - Full support for TYPO3 v13.4.0+ LTS
• Persistent Filter State Per User - User filter preferences are automatically saved and restored on subsequent visits
• Bulk Stage Transitions - Drag-and-drop functionality for moving multiple items between workflow stages simultaneously

Technical Details 

• Framework: TYPO3 v13.4.0+ && TYPO3 v14.3.0+
• PHP: PHP 8.2.0+
• Architecture: Modern TYPO3 service container, dependency injection
• Code Quality: PSR-12 compliant, full type declarations, TYPO3 coding standards
• Documentation: Comprehensive documentation for administrators, editors, and developers
• Table: tx_kanbanworkspaces_stage_checklist – stores stage (FK to sys_workspace_stage), title, sorting (see ext_tables.sql).
• TCA: Configuration/TCA/tx_kanbanworkspaces_stage_checklist.php; Configuration/TCA/Overrides/sys_workspace_stage.php adds checklist_items inline to workspace stage form.
• Icons: Configuration/Icons.php registers kanban-workspaces-stage-checklist (Resources/Public/Icons/checklist.svg) for TCA and modal list items.
• Controller: KanbanWorkspacesController::getChecklistForStage() loads and deduplicates items; stage config passed to frontend includes checklist array per stage.
• Frontend: ui/ModalController.js renders checklist in openSendToStageModal; targetStage passed from approve/revert handlers so checklist and banner show for the correct stage.
• Table: sys_workspaces_assignee – stores assignee (be_user), table_name, record_uid, workspace_id, stage_id, title, description (see ext_tables.sql).
• TCA: t3ver_assignee column added to all versioned tables (references sys_workspaces_assignee); see Configuration/TCA/Overrides/t3ver_assignee.php.
• Ajax route: kanban_workspace_assign (path /kanban-workspace/assign) → AssignAjaxController::assignAction; see Configuration/Backend/AjaxRoutes.php.
• Services: AssigneeMappingService (persist/cleanup), AssignmentNotificationService (email); both public in Configuration/Services.yaml.
• Event listeners: AssigneeEnrichmentListener (AfterDataGeneratedForWorkspaceEvent – enriches workspace data with assignee/avatar); AssigneeCleanupAfterPublishListener (AfterRecordPublishedEvent – cleanup).
• Email templates: Resources/Private/Templates/Email/AssignmentNotification.html and AssignmentNotification.txt; MAIL config (e.g. defaultMailFromAddress, transport) required for sending.

Documentation 

• Administrator: Stage Checklist (Workspace Stages) – where and how to configure checklist items; see Administrator.
• Administrator Guide - Installation, configuration, access control, troubleshooting; see Administrator.
• Configuration: MAIL and Ajax route configuration for assignment emails; see Configuration.
• Configuration Guide - All configuration options, TypoScript, service configuration
• Editor: Stage checklist in the Send to Stage modal – when it appears and what you see; see Editor.
• Editor: Editor > AssignUser – flow, email notification, avatar display, testing, troubleshooting.
• Editor Guide - Using the kanban board, workflow management, best practices
• Developer: Stage Checklist feature (implementation) – TCA, controller, JS, CSS, data model; see Developer.
• Developer: Assign feature implementation (controllers, services, listeners, DB, TCA); see Developer.
• Developer Guide - Architecture, API reference, extending the extension
• Known Problems - Known issues, limitations, workarounds, reporting bugs

Installation & Setup 

• Composer-based installation via web-vision/kanban-workspaces
• Automatic backend module registration
• Zero-configuration default setup
• Optional Extension Manager settings for customization

Backend Module Features 

• Located at: Web > Kanban Workspaces
• Available to all workspace-enabled backend users
• Supports multiple workspaces simultaneously
• Respects TYPO3 access control and workspace permissions
• Responsive stage display with color coding
• Filter controls for depth, language, and stage
• Automatic asset loading (CSS, JavaScript modules)

JavaScript Module System 

• Uses TYPO3's modern ES6 module system
• Loads main app module: @web-vision/kanban-workspaces/App.js
• Modular architecture: App.js (entry point) instantiates the WorkspaceBoard orchestrator (WorkspaceBoard.js), which delegates to focused collaborators under core/ (event emitter, horizontal scroll, utilities), data/ (WorkspaceApi, DataTransformer) and ui/ (BoardRenderer, DragController, ModalController, FilterController, CardActions)
• Integrates with TYPO3 workspaces send-to-stage functionality
• Asynchronous module loading for optimal performance

Performance Optimizations 

• Efficient database queries through TYPO3 repositories
• Lazy loading of workspace data
• Client-side filtering for quick response
• Respects workspace context automatically
• Optimized asset loading strategy

Workspace Integration 

• Full integration with TYPO3 core workspaces
• Supports all workspace stages and transitions
• Respects workspace edit/delete permissions per stage
• Automatic stage configuration from workspace settings
• Event listener for stage assignment on record generation

Known Limitations 

• Module only visible in active workspaces (not in Live workspace)
• Requires modern browser with ES6+ support (IE11 not supported)
• Maximum practical depth of  4-5 levels for optimal performance
• Desktop-optimized interface (mobile support planned)
• Respects TYPO3 core workspace limitations