Ability to sort groups by some user-defined property calculated from all the tasks in the group, such as most recent due date

[rhhub]

⚠️ Please check that this feature request hasn't been suggested before.

• I searched previous Ideas in Discussions didn't find any similar feature requests.
• I searched previous Issues didn't find any similar feature requests.

🔖 Feature description

This feature request encompasses using "group by" then sorting the groups by the content of each group.

Possible Usecases

1. sort groups by the highest priority task in each group
2. sort groups by the soonest due/scheduled/created task in each group
3. sort groups by some special aggregate calculation of each group (less useful and more complicated)

For Comparison Image

#t/group2 should come first because item 1 has the soonest date ⏳ 2023-05-10

Desired Image

notice group2 is above group1

✔️ Solution

I'm not sure what the solution would be. I think it would be called on the group by line.

Tasks' Steps

1. Query tasks
2. Display groups using group by
3. Sort the groups by content in each group.

Users Steps

1. Provide query language to modify group by order

Where user implements sort logic:

```tasks
not done
group by tags SOME CALL HERE
sort by priority
```

❓ Alternatives

I noticed #1421 had some functions added to the group by call. I'm not sure the extent of that addition.

📝 Additional Context

markdown of first screenshot:

- [ ] item 1 #t/group2  ⏳ 2023-05-10
- [ ] item 2 #t/group2  ⏳ 2023-05-14 
- [ ] item 3 #t/group1  ⏳ 2023-05-13
- [ ] item 4 #t/group1  ⏳ 2023-05-14 

```tasks
not done
group by tags
sort by priority
```

[claremacrae]

Hi @rhhub, Thank you for the write-up.

I regret to say that I have read it multiple times and am not at all confident that I understand what exact change in Tasks functionality it is requesting.

This feature request is made to satisfy the following statement: Grab the next task then get all tasks that share context with it. If I have tasks labeled #grocerystore, it would be helpful to get all tags that share grocerystore.

For example, I am struggling to understand what "If I have tasks labeled #grocerystore, it would be helpful to get all tags that share grocerystore. " means...

Especially as the example tasks you give do not mention #grocerystore - so I cannot see how the tags relate to the request.

I think that what you are saying is:

• That you use the tag #grocerystore to indicate the tasks that you need to do, or would like to do, when you are at the grocery store.
• That you know how to search for all tasks containing the tag #grocerystore
• But there is some limitation in how Tasks presents those matching tasks... the tasks with tag #grocerystore. What limitation?

If you could please provide a more concrete description of the real-world problem you are trying to solve, maybe I can make suggestions. Thanks.

In case you don't know, it's possible to give multiple sort by instructions in tasks blocks. The first sort line takes precedence, but where 2 or more tasks have the same value for the first sort line, they are compared/sorted by the second sort line, and so on...

So you have a lot of control over the sort of tasks within groups.

What is currently not yet possible is to control the order of the groups themselves.

[rhhub]

Hi,

I updated the original post. It does require sorting groups. I think it's less ambiguous now.

One example:
I want to sort the groups. When I "group by", each of those groups contain tasks. Steps to sort groups:

1. In a single group find the task with the highest priority.
2. Sort the groups by each respective priority found in step 1

[claremacrae]

OK, I get it. Thank you very much indeed.

I've updated the description/summary to try to make it fully reflect the request.

Just to set expectations, the current code design is a long way off being able to sort this.

[rhhub]

That's fair. Your help in #1940 will get me by with use tag contexts more. Thank you.

[rhhub]

Reinspired by #3332 I made a custom grouping function described below.

Goal

1. Groups tasks by tags. Sorts the groups by urgency associated with most urgent task contained within the group.

Limitations

1. If a group is displayed, less urgent tasks may not show up. This depends on sort and limit size.
2. Uses 'const allTasks = query.allTasks.filter((t) => !t.isDone); '. The additional fitler improves performance. It would be preferred to query just the tasks returned by the query but that doesn't seem possible. May cause unwanted results because of considering tasks outside those returned by the query.

Code Block

```tasks
status.type is NOT DONE
(happens before tomorrow)
show urgency

group by function { \
  const cacheKey = "tag-heading-maximum-urgency-in-group"; \
  /* Many tags can be returned. #c is a context tag used to group tasks.   \
  	    Handles multiple #c tags. */ \
  const getTaskGroups = (t) => { \
    const taskGroups = t.tags.filter((tag) => tag.includes("#c/")); \
    return taskGroups.length > 0 ? taskGroups : ["No Context"]; \
  }; \
  if (!query.searchCache[cacheKey]) { \
    console.log("Create Cache"); \
    /* Doing another query on allTasks is less than ideal. */ \
    const allTasks = query.allTasks.filter((t) => !t.isDone); \
    const groupUrgencyMap = new Map(); \
    allTasks.forEach((t) => { \
      const taskGroups = getTaskGroups(t); \
      const thisUrgency = t.urgency || 2; \
      taskGroups.forEach((t) => { \
        const storedUrgency = groupUrgencyMap.get(t) || 1; \
        /* Search for highest priority task. */ \
        if (thisUrgency >= storedUrgency) { \
          groupUrgencyMap.set(t, thisUrgency); \
        } \
      }); \
    }); \
    const getUrgencyOfGroup = (group) => groupUrgencyMap.get(group); \
    /* Create an array sorted by urgency */ \
    const sortedGroups = [...groupUrgencyMap.keys()].sort( \
      (a, b) => groupUrgencyMap.get(b) - groupUrgencyMap.get(a) \
    ); \
    const groupIndexMap = new Map( \
      sortedGroups.map((group, index) => [group, index]) \
    ); \
    const getSortIndexOfGroup = (group) => groupIndexMap.get(group); \
    query.searchCache[cacheKey] = { getSortIndexOfGroup, getUrgencyOfGroup }; \
  } \
  const { getUrgencyOfGroup, getSortIndexOfGroup } = query.searchCache[cacheKey]; \
  const taskGroups = getTaskGroups(task); \
  const groups = taskGroups.map((group) => { \
    const urgency = getUrgencyOfGroup(group); \
    const index = getSortIndexOfGroup(group); \
    return group ? `%%${index}%%${group} Max Urgency: ${urgency}` : ""; \
  }); \
  return groups; \
}

limit 30
```

[claremacrae]

@rhhub Many thanks for sharing this. I'm glad it's useful for you.

Whilst I was initially happy at adding the query.searchCache mechanism, as soon as I started documenting it, I could see it is way too complicated for almost all users...

For this reason, I have not yet documented it, in the hope that I can come up with something that is easier to use.

And this is the most complicated example I have seen!

[rhhub]

An update to my code. I cached the tasks from the query using a group by function that returns null. No need to query all tasks.

group by function { \
	  /* Creates an array of tasks to be used in following group by function. */ \
	const tasksInQueryKey = "tasksInQuery"; \
	if (!query.searchCache[tasksInQueryKey]) { \
		query.searchCache[tasksInQueryKey] = []; \
	} \
	query.searchCache[tasksInQueryKey].push(task); \
	return null; \
}
group by function { \
	const tasksInQueryKey = "tasksInQuery"; \
	const cacheKey = "tag-heading-maximum-urgency-in-group"; \
	/* Many tags can be returned. #c is a context tag used to group tasks.   \
		    Handles multiple #c tags. */ \
	const getTaskGroups = (t) => { \
	  const taskGroups = t.tags.filter((tag) => tag.includes("#c/")); \
	  return taskGroups.length > 0 ? taskGroups : ["No Context"]; \
	}; \
	if (!query.searchCache[cacheKey]) { \
	  const tasksInQuery = query.searchCache[tasksInQueryKey]; \
	  const groupUrgencyMap = new Map(); \
	  tasksInQuery.forEach((t) => { \
	    const taskGroups = getTaskGroups(t); \
	    const thisUrgency = t.urgency || 2; \
	    taskGroups.forEach((t) => { \
	      const storedUrgency = groupUrgencyMap.get(t) || 1; \
	      /* Search for highest priority task. */ \
	      if (thisUrgency >= storedUrgency) { \
	        groupUrgencyMap.set(t, thisUrgency); \
	      } \
	    }); \
	  }); \
	  const getUrgencyOfGroup = (group) => groupUrgencyMap.get(group); \
	  /* Create an array sorted by urgency */ \
	  const sortedGroups = [...groupUrgencyMap.keys()].sort( \
	    (a, b) => groupUrgencyMap.get(b) - groupUrgencyMap.get(a) \
	  ); \
	  const groupIndexMap = new Map( \
	    sortedGroups.map((group, index) => [group, index]) \
	  ); \
	  const getSortIndexOfGroup = (group) => groupIndexMap.get(group); \
	  query.searchCache[cacheKey] = { getSortIndexOfGroup, getUrgencyOfGroup }; \
	} \
	const { getUrgencyOfGroup, getSortIndexOfGroup } = query.searchCache[cacheKey]; \
	const taskGroups = getTaskGroups(task); \
	const groups = taskGroups.map((group) => { \
	  const urgency = getUrgencyOfGroup(group).toFixed(2); \
	  const index = getSortIndexOfGroup(group); \
	  return group ? `%%${index}%%${group} Max Urgency: ${urgency}` : ""; \
	}); \
	return groups; \
}