OrganonTweaks: per-column persistent sort -- number-aware title sort + sticky toggle (v1.9.0)

Asset/js/relocate.js

@@ -70,9 +70,29 @@
         }
     }
 
+    function hideNativeSort() {
+        // Only when our persistent-sort control is present (the tweak is on); otherwise leave the
+        // native fa-sort menu alone.
+        if (!document.querySelector(".organontweaks-sort")) {
+            return;
+        }
+
+        var sorts = document.querySelectorAll("#board .fa-sort");
+
+        for (var i = 0; i < sorts.length; i++) {
+            var dd = sorts[i].closest(".dropdown");
+
+            // Skip our own control (its OFF-state icon is also fa-sort).
+            if (dd && !dd.classList.contains("organontweaks-sort")) {
+                dd.style.display = "none";
+            }
+        }
+    }
+
     function apply() {
         relocateColumnMenuItems();
         repositionCommentIcons();
+        hideNativeSort();
     }
 
     function init() {

Controller/ConfigController.php

@@ -24,6 +24,7 @@ class ConfigController extends BaseController
                 'organon_tweaks_recurring_filters' => (int) $this->configModel->get('organon_tweaks_recurring_filters', 1),
                 'organon_tweaks_shortcut_labels' => (int) $this->configModel->get('organon_tweaks_shortcut_labels', 1),
                 'organon_tweaks_title_click_edit' => (int) $this->configModel->get('organon_tweaks_title_click_edit', 1),
+                'organon_tweaks_persistent_sort' => (int) $this->configModel->get('organon_tweaks_persistent_sort', 1),
             ),
             'errors' => array(),
         )));
@@ -43,6 +44,7 @@ class ConfigController extends BaseController
         $recurringFilters = isset($values['organon_tweaks_recurring_filters']) ? 1 : 0;
         $shortcutLabels = isset($values['organon_tweaks_shortcut_labels']) ? 1 : 0;
         $titleClickEdit = isset($values['organon_tweaks_title_click_edit']) ? 1 : 0;
+        $persistentSort = isset($values['organon_tweaks_persistent_sort']) ? 1 : 0;
 
         if ($this->configModel->save(array(
             'organon_tweaks_always_comment_icon' => $alwaysCommentIcon,
@@ -55,6 +57,7 @@ class ConfigController extends BaseController
             'organon_tweaks_recurring_filters' => $recurringFilters,
             'organon_tweaks_shortcut_labels' => $shortcutLabels,
             'organon_tweaks_title_click_edit' => $titleClickEdit,
+            'organon_tweaks_persistent_sort' => $persistentSort,
         ))) {
             $this->flash->success(t('Settings saved successfully.'));
         } else {

Controller/OrganonSortController.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Kanboard\Plugin\OrganonTweaks\Controller;
+
+use Kanboard\Controller\BaseController;
+use Kanboard\Core\Controller\AccessForbiddenException;
+use Kanboard\Plugin\OrganonTweaks\Helper\OrganonSortHelper;
+
+/**
+ * Per-column persistent sort, driven from the column's sort control on the board. Project-member
+ * (task-update) gated + CSRF, mirroring core TaskReorderController; returns to the board.
+ */
+class OrganonSortController extends BaseController
+{
+    private function authorize()
+    {
+        $project = $this->getProject();
+
+        if (! $this->helper->user->hasProjectAccess('TaskModificationController', 'update', $project['id'])) {
+            throw new AccessForbiddenException();
+        }
+
+        return $project;
+    }
+
+    private function sorter()
+    {
+        return new OrganonSortHelper($this->container);
+    }
+
+    private function backToBoard(array $project)
+    {
+        $this->response->redirect($this->helper->url->to('BoardViewController', 'show', array('project_id' => $project['id'])));
+    }
+
+    public function sort()
+    {
+        $this->checkCSRFParam();
+        $project = $this->authorize();
+
+        $this->sorter()->applySort(
+            $project['id'],
+            $this->request->getIntegerParam('swimlane_id'),
+            $this->request->getIntegerParam('column_id'),
+            $this->request->getStringParam('sort'),
+            $this->request->getStringParam('direction')
+        );
+
+        $this->backToBoard($project);
+    }
+
+    public function toggle()
+    {
+        $this->checkCSRFParam();
+        $project = $this->authorize();
+
+        $this->sorter()->toggle($project['id'], $this->request->getIntegerParam('column_id'));
+
+        $this->backToBoard($project);
+    }
+}

Helper/OrganonSortHelper.php

@@ -0,0 +1,140 @@
+<?php
+
+namespace Kanboard\Plugin\OrganonTweaks\Helper;
+
+use Kanboard\Core\Base;
+use Kanboard\Model\TaskModel;
+
+/**
+ * Per-column persistent sort. Kanboard's native column sort is a one-shot physical reorder (writes
+ * task positions); this stores the chosen sort per column and, when "persistent" is on, re-applies it
+ * whenever a card is dropped in or created -- so the column stays sorted. Adds a number-aware title
+ * sort on top of the native criteria.
+ *
+ * Everything lives in project metadata, per column, as literal strings:
+ *   organon_sort_by_<col>    = id | priority | assignee-priority | assignee | due-date | title
+ *   organon_sort_dir_<col>   = asc | desc
+ *   organon_sort_stick_<col> = on | off   (default off = native one-shot behavior)
+ */
+class OrganonSortHelper extends Base
+{
+    const BY_PREFIX = 'organon_sort_by_';
+    const DIR_PREFIX = 'organon_sort_dir_';
+    const STICK_PREFIX = 'organon_sort_stick_';
+
+    // The sort criteria this control offers. Native ones dispatch to core TaskReorderModel; 'title'
+    // is our own number-aware sort. Any value not here is ignored (no reorder, nothing stored).
+    const CRITERIA = array('id', 'priority', 'assignee-priority', 'assignee', 'due-date', 'title');
+
+    public function isSticky($project_id, $column_id)
+    {
+        return $this->projectMetadataModel->get((int) $project_id, self::STICK_PREFIX.(int) $column_id, 'off') === 'on';
+    }
+
+    public function sortBy($project_id, $column_id)
+    {
+        return (string) $this->projectMetadataModel->get((int) $project_id, self::BY_PREFIX.(int) $column_id, '');
+    }
+
+    public function sortDir($project_id, $column_id)
+    {
+        return $this->projectMetadataModel->get((int) $project_id, self::DIR_PREFIX.(int) $column_id, 'asc') === 'desc' ? 'desc' : 'asc';
+    }
+
+    /**
+     * Sort the column now and record the choice (for the icon + the sticky re-apply).
+     */
+    public function applySort($project_id, $swimlane_id, $column_id, $sort, $direction)
+    {
+        if (! in_array($sort, self::CRITERIA, true)) {
+            return;
+        }
+
+        $direction = $direction === 'desc' ? 'desc' : 'asc';
+        $this->reorder((int) $project_id, (int) $swimlane_id, (int) $column_id, $sort, $direction);
+        $this->projectMetadataModel->save((int) $project_id, array(
+            self::BY_PREFIX.(int) $column_id => $sort,
+            self::DIR_PREFIX.(int) $column_id => $direction,
+        ));
+    }
+
+    /**
+     * Re-apply the stored sort (called on card drop / creation when persistent is on). No-op if the
+     * column has no stored sort yet.
+     */
+    public function reapply($project_id, $swimlane_id, $column_id)
+    {
+        $sort = $this->sortBy($project_id, $column_id);
+
+        if ($sort !== '' && in_array($sort, self::CRITERIA, true)) {
+            $this->reorder((int) $project_id, (int) $swimlane_id, (int) $column_id, $sort, $this->sortDir($project_id, $column_id));
+        }
+    }
+
+    /**
+     * Flip the persistent flag for a column; returns the new state.
+     *
+     * @return string 'on' | 'off'
+     */
+    public function toggle($project_id, $column_id)
+    {
+        $new = $this->isSticky($project_id, $column_id) ? 'off' : 'on';
+        $this->projectMetadataModel->save((int) $project_id, array(self::STICK_PREFIX.(int) $column_id => $new));
+
+        return $new;
+    }
+
+    /**
+     * Dispatch the physical reorder: native criteria reuse core TaskReorderModel; 'title' is ours.
+     */
+    private function reorder($project_id, $swimlane_id, $column_id, $sort, $direction)
+    {
+        switch ($sort) {
+            case 'id':
+                $this->taskReorderModel->reorderByTaskId($project_id, $swimlane_id, $column_id, $direction);
+                break;
+            case 'priority':
+                $this->taskReorderModel->reorderByPriority($project_id, $swimlane_id, $column_id, $direction);
+                break;
+            case 'assignee-priority':
+                $this->taskReorderModel->reorderByAssigneeAndPriority($project_id, $swimlane_id, $column_id, $direction);
+                break;
+            case 'assignee':
+                $this->taskReorderModel->reorderByAssignee($project_id, $swimlane_id, $column_id, $direction);
+                break;
+            case 'due-date':
+                $this->taskReorderModel->reorderByDueDate($project_id, $swimlane_id, $column_id, $direction);
+                break;
+            case 'title':
+                $this->reorderByTitle($project_id, $swimlane_id, $column_id, $direction);
+                break;
+        }
+    }
+
+    /**
+     * Number-aware title sort (strnatcasecmp, so "Task 2" precedes "Task 10"), then write positions.
+     * Mirrors the native reorder scope (all tasks in the column+swimlane, no status filter). Core's
+     * TaskReorderModel::reorderTasks is protected, so the 3-line position write is replicated here.
+     */
+    private function reorderByTitle($project_id, $swimlane_id, $column_id, $direction)
+    {
+        $rows = $this->db->table(TaskModel::TABLE)
+            ->columns('id', 'title')
+            ->eq('project_id', $project_id)
+            ->eq('swimlane_id', $swimlane_id)
+            ->eq('column_id', $column_id)
+            ->findAll();
+
+        usort($rows, function ($a, $b) use ($direction) {
+            $cmp = strnatcasecmp((string) $a['title'], (string) $b['title']);
+
+            return $direction === 'desc' ? -$cmp : $cmp;
+        });
+
+        $position = 1;
+        foreach ($rows as $row) {
+            $this->db->table(TaskModel::TABLE)->eq('id', $row['id'])->update(array('position' => $position));
+            $position++;
+        }
+    }
+}

Plugin.php

@@ -3,6 +3,7 @@
 namespace Kanboard\Plugin\OrganonTweaks;
 
 use Kanboard\Core\Plugin\Base;
+use Kanboard\Model\TaskModel;
 
 class Plugin extends Base
 {
@@ -77,6 +78,39 @@ class Plugin extends Base
             $this->template->hook->attach('template:board:private:task:before-title', 'organonTweaks:board/title_edit');
         }
 
+        // Tweak: per-column persistent sort. A sort control (number-aware title sort + a
+        // "Persistent sort: ON/OFF" toggle) replaces the native column sort. Sorting always reorders
+        // physically (writes positions, like native); when persistent is ON, the column is re-sorted
+        // whenever a card is dropped in or created, so it stays sorted. Persistent OFF = native
+        // one-shot. Control injected via the column dropdown hook + relocate.js (which also hides the
+        // native fa-sort menu).
+        if ((int) $this->configModel->get('organon_tweaks_persistent_sort', 1) === 1) {
+            $this->template->hook->attach('template:board:column:dropdown', 'organonTweaks:board/sort_control');
+
+            $container = $this->container;
+            $reapply = function ($project_id, $swimlane_id, $column_id) use ($container) {
+                $helper = new \Kanboard\Plugin\OrganonTweaks\Helper\OrganonSortHelper($container);
+                if ($helper->isSticky($project_id, $column_id)) {
+                    $helper->reapply($project_id, $swimlane_id, $column_id);
+                }
+            };
+
+            // Card dropped into a column -> re-apply that column's sort (the plugin on() wrapper drops
+            // the event, so subscribe on the dispatcher to receive the TaskEvent).
+            $this->dispatcher->addListener(TaskModel::EVENT_MOVE_COLUMN, function ($event) use ($reapply) {
+                $task = $event['task'];
+                $reapply((int) $task['project_id'], (int) $task['swimlane_id'], (int) $event['dst_column_id']);
+            });
+
+            // New card created in a column -> re-apply that column's sort.
+            $this->hook->on('model:task:creation:aftersave', function ($task_id) use ($container, $reapply) {
+                $task = $container['taskFinderModel']->getById($task_id);
+                if (! empty($task)) {
+                    $reapply((int) $task['project_id'], (int) $task['swimlane_id'], (int) $task['column_id']);
+                }
+            });
+        }
+
         // Auto-managed shared custom filters (v1.5 "Show all tasks", v1.6 month filters, v1.7
         // recurring filters). Ensured lazily whenever a project header renders (covers old + new
         // boards); each group is gated by its own config toggle inside
@@ -107,7 +141,7 @@ class Plugin extends Base
     public function getHelpers()
     {
         return array(
-            'Plugin\OrganonTweaks\Helper' => array('OrganonColumnHelper', 'OrganonProjectHelper'),
+            'Plugin\OrganonTweaks\Helper' => array('OrganonColumnHelper', 'OrganonProjectHelper', 'OrganonSortHelper'),
         );
     }
 
@@ -128,7 +162,7 @@ class Plugin extends Base
 
     public function getPluginVersion()
     {
-        return '1.8.5';
+        return '1.9.0';
     }
 
     public function getPluginHomepage()

README.md

@@ -96,6 +96,27 @@ edits when it opens (there is no template hook, so it is done in JS,
 
 - **On by default.** Toggle it under "Settings -> Organon Tweaks".
 
+### Persistent column sort
+
+Kanboard's native column sort is a one-shot physical reorder: it rewrites task positions once, so
+the order already survives refreshes, but a newly created or dropped-in card lands out of order
+until you sort again -- and there is no sort-by-title. This tweak replaces the per-column sort
+control with one that:
+
+- adds a **number-aware Title sort** (A to Z / Z to A), so "Task 2" sorts before "Task 10";
+- adds a **Persistent sort: ON / OFF** toggle. When ON, the column is re-sorted (server-side,
+  physically) whenever a card is dropped into it or created in it, so it **stays** sorted; when
+  OFF it behaves exactly like the native one-shot sort.
+
+The header icon shows the state: the native double-arrow when persistent is OFF, and a **red
+single arrow** (up for ascending, down for descending) when it is ON.
+
+- Reorders reuse core's `TaskReorderModel` for the native criteria (id / priority / assignee /
+  due date) and add the title sort; the sticky re-apply runs on the move / creation events.
+- The control is injected via the `template:board:column:dropdown` hook + `Asset/js/relocate.js`
+  (which also hides the native sort menu). Per-column state lives in project metadata.
+- **On by default.** Toggle it under "Settings -> Organon Tweaks".
+
 ## Settings
 
 Global (per Kanboard instance) and admin-only, under "Settings -> Organon Tweaks", grouped as on
@@ -118,6 +139,10 @@ the page:
 - **Show keyboard shortcuts on the task menu** -- default on.
 - **Clicking a task title opens the edit form** -- default on.
 
+**Board columns**
+
+- **Per-column persistent sort** -- default on.
+
 Standalone:
 
 - **Keep the board scroll position across refreshes** -- default on.
@@ -137,7 +162,7 @@ name). No build step and no database migration.
 
 AGPL-3.0. See LICENSE.
 
-## More Kanboard plugins by Dr. Bèco
+## More Kanboard plugins by Dr. Beco
 
 All free and AGPL-3.0, at [code.beco.cc](https://code.beco.cc/beco):
 

Template/board/sort_control.php

@@ -0,0 +1,69 @@
+<?php
+// Per-column persistent-sort control. Rendered by template:board:column:dropdown (so it sits in the
+// column header, as its own dropdown); relocate.js hides the native fa-sort menu in its favour.
+// Icon: native double-arrow when persistent is off, a red single arrow (up=asc / down=desc) when on.
+if ($column['nb_tasks'] <= 0 || ! $this->user->hasProjectAccess('TaskModificationController', 'update', $column['project_id'])) {
+    return;
+}
+
+$pid = $column['project_id'];
+$cid = $column['id'];
+$sid = $swimlane['id'];
+
+$sticky = $this->OrganonSortHelper->isSticky($pid, $cid);
+$curBy = $this->OrganonSortHelper->sortBy($pid, $cid);
+$curDir = $this->OrganonSortHelper->sortDir($pid, $cid);
+$applied = $curBy !== '';
+$desc = $curDir === 'desc';
+
+$criteria = array(
+    array('title', 'asc', t('Title (A to Z)')),
+    array('title', 'desc', t('Title (Z to A)')),
+    array('id', 'asc', t('Id (ASC)')),
+    array('id', 'desc', t('Id (DESC)')),
+    array('priority', 'asc', t('Priority (ASC)')),
+    array('priority', 'desc', t('Priority (DESC)')),
+    array('due-date', 'asc', t('Due date (ASC)')),
+    array('due-date', 'desc', t('Due date (DESC)')),
+    array('assignee', 'asc', t('Assignee (A-Z)')),
+    array('assignee', 'desc', t('Assignee (Z-A)')),
+    array('assignee-priority', 'asc', t('Assignee + priority (ASC)')),
+    array('assignee-priority', 'desc', t('Assignee + priority (DESC)')),
+);
+?>
+<span class="dropdown organontweaks-sort">
+    <a href="#" class="dropdown-menu" title="<?= t('Sort this column') ?>">
+        <?php if ($sticky && $applied): ?>
+            <?php /* Persistent ON: a single red arrow for the direction (8593 up / 8595 down),
+                     written as HTML entities so the source stays ASCII. OFF = the native
+                     double-arrow (fa-sort) below -- the natural, non-sticky state. */ ?>
+            <span class="organontweaks-sort-arrow" style="color: #c0392b;"><?= $desc ? '&#8595;' : '&#8593;' ?></span>
+        <?php else: ?>
+            <i class="fa fa-sort fa-fw" aria-hidden="true"></i>
+        <?php endif ?>
+    </a>
+    <ul>
+        <li>
+            <?= $this->url->link(
+                '<i class="fa fa-thumb-tack fa-fw"></i> '.($sticky ? t('Persistent sort: ON') : t('Persistent sort: OFF')),
+                'OrganonSortController',
+                'toggle',
+                array('plugin' => 'OrganonTweaks', 'project_id' => $pid, 'column_id' => $cid),
+                true
+            ) ?>
+        </li>
+        <li class="no-hover"><strong><?= t('Sort by') ?></strong></li>
+        <?php foreach ($criteria as $c): ?>
+            <?php $active = ($curBy === $c[0] && $curDir === $c[1]); ?>
+            <li>
+                <?= $this->url->link(
+                    '<i class="fa '.($active ? 'fa-check' : '').' fa-fw"></i> '.$this->text->e($c[2]),
+                    'OrganonSortController',
+                    'sort',
+                    array('plugin' => 'OrganonTweaks', 'project_id' => $pid, 'column_id' => $cid, 'swimlane_id' => $sid, 'sort' => $c[0], 'direction' => $c[1]),
+                    true
+                ) ?>
+            </li>
+        <?php endforeach ?>
+    </ul>
+</span>

Template/config/show.php

@@ -55,6 +55,13 @@
         <p class="form-help"><?= t('On the board and the card view, click the title to open the edit modal (only where you may edit).') ?></p>
     </fieldset>
 
+    <fieldset>
+        <legend><?= t('Board columns') ?></legend>
+
+        <?= $this->form->checkbox('organon_tweaks_persistent_sort', t('Per-column persistent sort'), 1, isset($values['organon_tweaks_persistent_sort']) && $values['organon_tweaks_persistent_sort'] == 1) ?>
+        <p class="form-help"><?= t('Replaces the native column sort with a control that adds a number-aware Title sort and a "Persistent sort: ON/OFF" toggle. When ON, the column is re-sorted whenever a card is dropped in or created, so it stays sorted (a red up/down arrow marks it). OFF is the native one-shot sort.') ?></p>
+    </fieldset>
+
     <div class="form-actions">
         <button type="submit" class="btn btn-blue"><?= t('Save') ?></button>
     </div>

VERSION

@@ -1 +1 @@
-OrganonTweaks v1.8.5
+OrganonTweaks v1.9.0