feat(trees): sort Chronostrat tree by period instead of name, add ranges

config/common/schema_localization_en.json

@@ -3479,7 +3479,7 @@
       "guid": {"name": "GUID", "desc": "GUID", "format": null, "ishidden": true, "isuiformatter": false, "picklistname": null, "type": "java.lang.String", "isrequired": false, "weblinkname": null},
       "highestchildnodenumber": {"name": "Highest Child Node Number", "desc": "Highest Child Node Number", "format": null, "ishidden": true, "isuiformatter": false, "picklistname": null, "type": "java.lang.Integer", "isrequired": false, "weblinkname": null},
       "isaccepted": {"name": "Is Preferred", "desc": "Is Preferred", "format": null, "ishidden": true, "isuiformatter": false, "picklistname": null, "type": "java.lang.Boolean", "isrequired": false, "weblinkname": null},
-      "isbiostrat": {"name": "Is BioStratigraphy", "desc": "Is BioStratigraphy", "format": null, "ishidden": false, "isuiformatter": false, "picklistname": null, "type": null, "isrequired": false, "weblinkname": null},
+      "isbiostrat": {"name": "Is Biostratigraphy", "desc": "Is Biostratigraphy", "format": null, "ishidden": false, "isuiformatter": false, "picklistname": null, "type": null, "isrequired": false, "weblinkname": null},
       "modifiedbyagent": {"name": "Modified By Agent", "desc": "Modified By Agent", "format": null, "ishidden": true, "isuiformatter": false, "picklistname": null, "type": null, "isrequired": false, "weblinkname": null},
       "name": {"name": "Name", "desc": "Name", "format": null, "ishidden": false, "isuiformatter": false, "picklistname": null, "type": "java.lang.String", "isrequired": false, "weblinkname": null},
       "nodenumber": {"name": "Node Number", "desc": "Node Number", "format": null, "ishidden": true, "isuiformatter": false, "picklistname": null, "type": "java.lang.Integer", "isrequired": false, "weblinkname": null},

specifyweb/backend/trees/tests/test_trees.py

@@ -344,6 +344,8 @@ def _run_for_row():
                 self.earth.id,
                 "geographyid",
                 False,
+                False,
+                'all',
                 session,
             )
             expected = [
@@ -397,6 +399,8 @@ def _run_for_row():
                 self.na.id,
                 "name",
                 False,
+                False,
+                'all',
                 session,
             )
             expected = [

specifyweb/backend/trees/views.py

@@ -13,7 +13,7 @@
 from specifyweb.specify import models as spmodels
 from specifyweb.specify.api.crud import get_object_or_404
 from specifyweb.specify.api.serializers import obj_to_data, toJson
-from sqlalchemy import select, func, distinct, literal
+from sqlalchemy import and_, select, func, distinct, literal
 from sqlalchemy.orm import aliased
 from jsonschema import validate  # type: ignore
 from jsonschema.exceptions import ValidationError  # type: ignore
@@ -165,13 +165,15 @@ def tree_view(request, treedef, tree: TREE_TABLE, parentid, sortfield):
     implementation/design decisions
     """
     include_author = request.GET.get('includeauthor', False) and tree == 'taxon'
+    include_start_end_periods = request.GET.get('includestartendperiods', False) and tree == 'geologictimeperiod'
+    biostrat = request.GET.get('biostrat', 'all')
     with sqlmodels.session_context() as session:
         set_group_concat_max_len(session.connection())
-        results = get_tree_rows(treedef, tree, parentid, sortfield, include_author, session)
+        results = get_tree_rows(treedef, tree, parentid, sortfield, include_author, include_start_end_periods, biostrat, session)
     return HttpResponse(toJson(results), content_type='application/json')
 
 
-def get_tree_rows(treedef, tree, parentid, sortfield, include_author, session):
+def get_tree_rows(treedef, tree, parentid, sortfield, include_author, include_start_end_periods, biostrat, session):
     tree_table = spmodels.datamodel.get_table(tree)
     parentid = None if parentid == 'null' else int(parentid)
 
@@ -208,21 +210,67 @@ def get_tree_rows(treedef, tree, parentid, sortfield, include_author, session):
             else func.min(literal("NULL"))
         ).label("author"),
 
+        (
+            func.min(node.startPeriod)
+            if include_start_end_periods
+            else func.min(literal("NULL"))
+        ).label("start_period"),
+        (
+            func.min(node.startUncertainty)
+            if include_start_end_periods
+            else func.min(literal("NULL"))
+        ).label("start_uncertainty"),
+        (
+            func.min(node.endPeriod)
+            if include_start_end_periods
+            else func.min(literal("NULL"))
+        ).label("end_period"),
+        (
+            func.min(node.endUncertainty)
+            if include_start_end_periods
+            else func.min(literal("NULL"))
+        ).label("end_uncertainty"),
+
         func.count(distinct(child._id)).label("child_count"),
         group_concat(distinct(synonym.fullName), separator=", ").label("synonyms"),
+        (
+            func.min(node.isBioStrat)
+            if tree == 'geologictimeperiod'
+            else func.min(literal("NULL"))
+        ).label("is_biostrat"),
     ]
 
+    if biostrat != 'all' and tree == 'geologictimeperiod':
+        # Count all matching descendants (any depth) using nested-set ranges
+        if biostrat == 'bio':
+            descendant_match = child.isBioStrat == True
+        else:
+            descendant_match = (child.isBioStrat == False) | (child.isBioStrat == None)
+        matching_descendant_count = (
+            select(func.count(distinct(child._id)))
+            .where(
+                child.nodeNumber > node.nodeNumber,
+                child.nodeNumber <= node.highestChildNodeNumber,
+                descendant_match,
+                getattr(child, tree_table.name + "TreeDefID") == int(treedef),
+            )
+            .correlate(node)
+            .scalar_subquery()
+            .label("matching_descendant_count")
+        )
+        cols.append(matching_descendant_count)
+
     query = (
         select(*cols)
-        .outerjoin(child, child.ParentID  == node._id)
+        .outerjoin(child, child.ParentID == node._id)
         .outerjoin(accepted, node.AcceptedID == accepted._id)
         .outerjoin(synonym, synonym.AcceptedID == node._id)
         .where(treedef_col == int(treedef))
         .where(node.ParentID == parentid)
-        .group_by(node._id)
-        .order_by(orderby)
     )
 
+    query = query.group_by(node._id).order_by(orderby)
+
     return session.execute(query).all()
 
 @login_maybe_required

specifyweb/frontend/js_src/lib/components/Preferences/UserDefinitions.tsx

@@ -1677,6 +1677,13 @@ export const userPreferenceDefinitions = {
             renderer: ColorPickerPreferenceItem,
             container: 'label',
           }),
+          displayChronoPeriods: definePref<boolean>({
+            title: preferencesText.displayChronoPeriods(),
+            requiresReload: false,
+            visible: true,
+            defaultValue: true,
+            type: 'java.lang.Boolean',
+          }),
           rankThreshold: definePref<number>({
             title: preferencesText.rankThreshold(),
             description: preferencesText.rankThresholdDescription(),

specifyweb/frontend/js_src/lib/components/QueryComboBox/__tests__/biostratConditions.test.ts

@@ -0,0 +1,71 @@
+import { requireContext } from '../../../tests/helpers';
+import { serializeResource } from '../../DataModel/serializers';
+import { tables } from '../../DataModel/tables';
+import { queryFieldFilterSpecs } from '../../QueryBuilder/FieldFilterSpec';
+import { getQueryComboBoxConditions } from '../helpers';
+
+requireContext();
+
+describe('getQueryComboBoxConditions with BioStrat typeSearchName', () => {
+  const getBaseParams = () => ({
+    // Use a non-tree resource to avoid toTreeTable() requiring tree data
+    resource: new tables.CollectionObject.Resource(
+      {},
+      { noBusinessRules: true }
+    ),
+    fieldName: 'name' as const,
+    treeData: undefined,
+    collectionRelationships: undefined,
+    relatedTable: tables.GeologicTimePeriod,
+    subViewRelationship: undefined,
+    treeDefinition: undefined,
+  });
+
+  test('adds isBioStrat=true filter when typeSearchName is BioStrat', () => {
+    const conditions = getQueryComboBoxConditions({
+      ...getBaseParams(),
+      typeSearchName: 'BioStrat',
+    });
+    const serialized = conditions.map(serializeResource);
+    expect(serialized).toContainEqual(
+      expect.objectContaining({
+        fieldName: 'isBioStrat',
+        startValue: 'true',
+        operStart: queryFieldFilterSpecs.true.id,
+      })
+    );
+  });
+
+  test('does NOT add isBioStrat filter when typeSearchName is something else', () => {
+    const conditions = getQueryComboBoxConditions({
+      ...getBaseParams(),
+      typeSearchName: 'ChronosStrat',
+    });
+    const serialized = conditions.map(serializeResource);
+    expect(
+      serialized.filter(({ fieldName }) => fieldName === 'isBioStrat')
+    ).toHaveLength(0);
+  });
+
+  test('does NOT add isBioStrat filter when typeSearchName is undefined', () => {
+    const conditions = getQueryComboBoxConditions({
+      ...getBaseParams(),
+    });
+    const serialized = conditions.map(serializeResource);
+    expect(
+      serialized.filter(({ fieldName }) => fieldName === 'isBioStrat')
+    ).toHaveLength(0);
+  });
+
+  test('does NOT add isBioStrat filter for non-GeologicTimePeriod tables', () => {
+    const conditions = getQueryComboBoxConditions({
+      ...getBaseParams(),
+      relatedTable: tables.Taxon,
+      typeSearchName: 'BioStrat',
+    });
+    const serialized = conditions.map(serializeResource);
+    expect(
+      serialized.filter(({ fieldName }) => fieldName === 'isBioStrat')
+    ).toHaveLength(0);
+  });
+});

specifyweb/frontend/js_src/lib/components/QueryComboBox/helpers.ts

@@ -81,6 +81,7 @@ export function getQueryComboBoxConditions({
   subViewRelationship,
   relatedTable,
   treeDefinition,
+  typeSearchName,
 }: {
   readonly resource: SpecifyResource<AnySchema>;
   readonly fieldName: string;
@@ -89,6 +90,7 @@ export function getQueryComboBoxConditions({
   readonly relatedTable: SpecifyTable;
   readonly subViewRelationship: Relationship | undefined;
   readonly treeDefinition: string | undefined;
+  readonly typeSearchName?: string | undefined;
 }): RA<SpecifyResource<SpQueryField>> {
   const fields: WritableArray<SpecifyResource<SpQueryField>> = [];
   const treeResource = toTreeTable(resource);
@@ -164,6 +166,22 @@ export function getQueryComboBoxConditions({
     );
   }
 
+  /**
+   * When looking up BioStrat values for PaleoContext, only show
+   * GeologicTimePeriod nodes where isBioStrat is TRUE.
+   */
+  if (
+    typeSearchName === 'BioStrat' &&
+    relatedTable === tables.GeologicTimePeriod
+  )
+    fields.push(
+      QueryFieldSpec.fromPath(tables.GeologicTimePeriod.name, ['isBioStrat'])
+        .toSpQueryField()
+        .set('isDisplay', false)
+        .set('operStart', queryFieldFilterSpecs.true.id)
+        .set('startValue', 'true')
+    );
+
   if (
     typeof collectionRelationships === 'object' &&
     fieldName === 'collectionRelType'

specifyweb/frontend/js_src/lib/components/QueryComboBox/index.tsx

@@ -341,6 +341,7 @@ export function QueryComboBox({
                     relatedTable,
                     subViewRelationship,
                     treeDefinition,
+                    typeSearchName: typeSearch.name,
                   }),
                 })
               )
@@ -547,6 +548,10 @@ export function QueryComboBox({
                                 relatedTable,
                                 subViewRelationship,
                                 treeDefinition,
+                                typeSearchName:
+                                  typeof typeSearch === 'object'
+                                    ? typeSearch.name
+                                    : undefined,
                               })
                                 .map(serializeResource)
                                 .map(({ fieldName, startValue }) =>
@@ -587,13 +592,21 @@ export function QueryComboBox({
                                               isNot: false,
                                               value: startValue,
                                             }
-                                          : f.error(
-                                              `extended filter not created`,
-                                              {
-                                                fieldName,
-                                                startValue,
+                                          : fieldName === 'isBioStrat'
+                                            ? {
+                                                field: 'isBioStrat',
+                                                isRelationship: false,
+                                                operation: 'in',
+                                                isNot: false,
+                                                value: '1',
                                               }
-                                            )
+                                            : f.error(
+                                                `extended filter not created`,
+                                                {
+                                                  fieldName,
+                                                  startValue,
+                                                }
+                                              )
                                 )
                             ),
                           })