Redmine

The sort order is the result of the underlying SQL statement's ORDER BY.

To order in the way you describe:
- you need to hack redmine (ActiveRecord), but I doubt that this would be possible.
- exclude all empty due dates in your query and only order on those non-empty ones.

One note: please do /not/ suggest assigning due dates to every item. We've considered and attempted that approach, and we've determined that we need to retain the ability to save issues without due dates, for a variety of reporting and workflow reasons.

A classic fallacy on your part (IMHO). Not all problems caused by peoples' inadequate working attitudes can be solved by technical means.

Jan Niggemann (redmine.org team member) wrote:

The sort order is the result of the underlying SQL statement's ORDER BY.

This certainly explains why it happens, but says very little about if it makes sense in this situation or not.

To order in the way you describe:
- you need to hack redmine (ActiveRecord), but I doubt that this would be possible.
- exclude all empty due dates in your query and only order on those non-empty ones.

One note: please do /not/ suggest assigning due dates to every item. We've considered and attempted that approach, and we've determined that we need to retain the ability to save issues without due dates, for a variety of reporting and workflow reasons.

A classic fallacy on your part (IMHO). Not all problems caused by peoples' inadequate working attitudes can be solved by technical means.

Then, there's that other fallacy of the developer thinking to know better than the user. Sometimes that's true, sometimes it isn't. Anyway, the good developer (IMHO) knows that his software is better if it allows to properly work in unanticipated (while sensible after described) ways.

I know that a kind of project manager on duty will most probably add starting/due dates for issues when planning a new project, but I also know that a sysadmin working more or less kanban-style will not, since his work-mode is that of queuing plus best effort (unless there is an externally set due date for whatever reasons). I fail to see how one of these use cases is any more valid than the other.

• If I'm requesting issues to be sorted by due date, it means due date is of importance to me, so issues with an assigned due date should be somehow highlighted over those without (i.e.: by sorting before).
• Not having an assigned due date on an issue means I don't know/it doesn't matter and, again, known info should prevail over "don't knows/doesn't matters".
• Excluding in the query issues without due date may make sense sometimes but I can think of a lot of scenarios when it doesn't (i.e.: multifilter: I still want to see issues at critical priority sorted before any issues at normal priority, even if no due date is assigned to them).
• An issue can have an implicit due date as long it has a target version assigned (that of the target version).
• I can't think of an user case where things with no due date should be meaningfully presented before those with a due date when sorting ascending order, but I'm open to consider it if you can present it to me.

1. 1/MAR/2016
2. 2/MAR/2016
3. no due date [or have it set to its target version's one and sort accordingly]

TIA

Rob D: One note: please do /not/ suggest assigning due dates to every item. We've considered and attempted that approach, and we've determined that we need to retain the ability to save issues without due dates, for a variety of reporting and workflow reasons.

Jan Niggemann: A classic fallacy on your part (IMHO). Not all problems caused by peoples' inadequate working attitudes can be solved by technical means.

Jesús M. Navarro: Then, there's that other fallacy of the developer thinking to know better than the user.

I'm inclined to agree with Jesús here. This kind of ordering (due date ascending, but anything with no due date bumped to the end of the list) is fairly typical of task lists. Back in the day my Palm Desktop application used to sort tasks this way (and I relied on it). I thought outlook did too, but I've just looked and it takes the unintuitive approach of listing dateless tasks first (like redmine currently does). I'm pretty sure others are out there which work the way Palm Desktop did though.

Anyhow, it shouldn't be too big a hassle to tweak the SQL query for date sorting should it? I'm not an expert in MySQL's queries and performance specifically, but wouldn't something like this work (for the ascending date sort order anyway, descending date order could be left as-is so that dateless issues continue to appear at the bottom of the results)?

SELECT COALESCE(issue_date, '2038-01-19'xx) AS sort_date, {other fields} 
FROM Issues
ORDER BY sort_date ASC

xx (or whatever the largest date MySQL can handle is)

Anyhow, consider this a +1 from me for ordering issues like this :) - it's how I work, and I was surprised to find today that redmine sorts on due-date in the way it does.

As a follow up to my last reply, it's interesting to note that OpenProject (which I only learned about recently, and began as a fork of Redmine) has clearly addressed this issue in their time.

Sorting on due date ascending in OpenProject does what you'd reasonably expect (as a user, rather than a developer) and lists the dateless issues last:

An example:
https://community.openproject.com/projects/openproject/work_packages?query_props={%22c%22:[%22id%22,%22type%22,%22status%22,%22subject%22,%22assigned_to%22,%22due_date%22],%22t%22:%22due_date,parent:desc%22,%22f%22:[{%22n%22:%22status_id%22,%22o%22:%22o%22,%22t%22:%22list_status%22}],%22pa%22:1,%22pp%22:100}

NOTE: You'll need to copy and paste that URL - something in the big long list of query args isn't translating properly as a clickable link.

As a last follow-up, it seems someone has addressed this issue for Redmine in a plugin (perhaps it'll help the original poster).

https://www.redmine.org/plugins/redmine_smart_issues_sort

Unfortunately this plugin is not compatible with Redmine 3.x (which is the version I run)

Quick suggestion of update (not sure where it should goes in Redmine's code, and I don't know ruby):

ORDER BY ISNULL(due_date), due_date ASC

And it should actually work with any other column to sort ; we probably could apply Jesus' principles to all columns, not only dates.

So, in the end, what should we do next? Opening an issue requesting this as a new feature, maybe?

Jesús M. Navarro wrote:

So, in the end, what should we do next? Opening an issue requesting this as a new feature, maybe?

Done: See #24529.