Add new feature to change taxon tree type in tree viewer

specifyweb/barvis/views.py

@@ -1,29 +1,40 @@
 from django.http import HttpResponse
-
-from sqlalchemy.sql.expression import func, distinct
+from django.db.models import Count, Q
 
 from specifyweb.middleware.general import require_GET
 from specifyweb.specify.views import login_maybe_required
+from specifyweb.specify.filter_by_col import filter_by_collection
 from specifyweb.specify.api import toJson
-
-from specifyweb.stored_queries.models import Determination, Taxon
+from specifyweb.specify.models import Taxon
 
 from django.db import connection
 
+
 @require_GET
 @login_maybe_required
 def taxon_bar(request):
-    "Returns the data for creating a taxon tiles visualization."
-    cursor = connection.cursor()
-    cursor.execute("""
-    SELECT t.TaxonID,
-    t.RankID,
-    t.ParentID,
-    t.Name,
-    (SELECT COUNT(*) FROM determination d WHERE t.TaxonID = d.TaxonID AND d.IsCurrent = 1)
-    FROM taxon t
-    WHERE t.TaxonTreeDefID = %s
-    """, [request.specify_collection.discipline.taxontreedef_id])
+    # "Returns the data for creating a taxon tiles visualization."
+    # cursor = connection.cursor()
+    # cursor.execute("""
+    # SELECT t.TaxonID,
+    # t.RankID,
+    # t.ParentID,
+    # t.Name,
+    # (SELECT COUNT(*) FROM determination d WHERE t.TaxonID = d.TaxonID AND d.IsCurrent = 1)
+    # FROM taxon t
+    # WHERE t.TaxonTreeDefID = %s
+    # """, [request.specify_collection.discipline.taxontreedef_id])
+
+    # Implementing the previous SQL query in Django ORM:
+    taxons = (
+        Taxon.objects.annotate(
+            current_determination_count=Count(
+                'determinations', filter=Q(determinations__iscurrent=True))
+        )
+        .values_list("id", "rankid", "parent_id", "name", "current_determination_count")
+    )
+    filtered_taxons = filter_by_collection(taxons, request.specify_collection)
+    result = toJson(list(filtered_taxons))
 
     # SELECT d.TaxonID, COUNT(DISTINCT d.CollectionObjectID), t.ParentID
     # FROM determination d
@@ -33,7 +44,7 @@ def taxon_bar(request):
     # GROUP BY d.TaxonId
     # ORDER BY d.TaxonId
     # """, [request.specify_collection.id])
-    result = toJson(cursor.fetchall())
+    # result = toJson(cursor.fetchall())
     # session = Session()
     # query = session.query(
     #     Determination.TaxonID,

specifyweb/frontend/js_src/lib/components/DataModel/resourceApi.ts

@@ -448,6 +448,12 @@ export const ResourceBase = Backbone.Model.extend({
         this.trigger('change', this);
         return undefined;
       }
+      /*
+       * Needed for taxonTreeDef on discipline because field.isVirtual equals false
+       */
+      case 'one-to-one': {
+        return value;
+      }
     }
     if (!field.isVirtual)
       softFail('Unhandled setting of relationship field', {

specifyweb/frontend/js_src/lib/components/DataModel/treeBusinessRules.ts

@@ -5,16 +5,14 @@ import { getPref } from '../InitialContext/remotePrefs';
 import { fetchPossibleRanks } from '../PickLists/TreeLevelPickList';
 import { formatUrl } from '../Router/queryString';
 import type { BusinessRuleResult } from './businessRules';
-import type {
-  AnyTree,
-  FilterTablesByEndsWith,
-  TableFields,
-} from './helperTypes';
+import type { AnyTree, TableFields } from './helperTypes';
 import type { SpecifyResource } from './legacyTypes';
+import { idFromUrl } from './resource';
+import type { Tables } from './types';
 
 // eslint-disable-next-line unicorn/prevent-abbreviations
 export type TreeDefItem<TREE extends AnyTree> =
-  FilterTablesByEndsWith<`${TREE['tableName']}TreeDefItem`>;
+  Tables[`${TREE['tableName']}TreeDefItem`];
 
 export const initializeTreeRecord = (
   resource: SpecifyResource<AnyTree>
@@ -36,7 +34,11 @@ export const treeBusinessRules = async (
     const possibleRanks =
       parentDefItem === undefined
         ? undefined
-        : await fetchPossibleRanks(resource, parentDefItem.get('rankId'));
+        : await fetchPossibleRanks(
+            resource,
+            parentDefItem.get('rankId'),
+            idFromUrl(parentDefItem.get('treeDef'))!
+          );
 
     const doExpandSynonymActionsPref = getPref(
       `sp7.allow_adding_child_to_synonymized_parent.${resource.specifyTable.name}`

specifyweb/frontend/js_src/lib/components/Forms/Save.tsx

@@ -204,6 +204,7 @@ export function SaveButton<SCHEMA extends AnySchema = AnySchema>({
 
   const ButtonComponent = saveBlocked ? Button.Danger : Button.Save;
   const SubmitComponent = saveBlocked ? Submit.Danger : Submit.Save;
+
   // Don't allow cloning the resource if it changed
   const isChanged = saveRequired || externalSaveRequired;
 

specifyweb/frontend/js_src/lib/components/HomePage/TaxonTiles.tsx

@@ -7,7 +7,7 @@ import { ajax } from '../../utils/ajax';
 import type { RA } from '../../utils/types';
 import { tables } from '../DataModel/tables';
 import {
-  getTreeDefinitionItems,
+  strictGetTreeDefinitionItems,
   treeRanksPromise,
 } from '../InitialContext/treeRanks';
 import {
@@ -98,7 +98,8 @@ function useGenusRankId(): number | false | undefined {
       async () =>
         treeRanksPromise.then(
           () =>
-            getTreeDefinitionItems('Taxon', false)!.find(
+            // REFACTOR: Narrow the TreeDefinition used to find the rankId of the Genus Rank
+            strictGetTreeDefinitionItems('Taxon', false, 'all').find(
               (item) => (item.name || item.title)?.toLowerCase() === 'genus'
             )?.rankId ?? false
         ),

specifyweb/frontend/js_src/lib/components/InitialContext/treeRanks.ts

@@ -3,32 +3,35 @@
  * given discipline.
  */
 
+import { ajax } from '../../utils/ajax';
+import { getCache } from '../../utils/cache';
 import { f } from '../../utils/functools';
 import type { RA } from '../../utils/types';
 import { defined } from '../../utils/types';
-import {
-  caseInsensitiveHash,
-  sortFunction,
-  unCapitalize,
-} from '../../utils/utils';
+import { caseInsensitiveHash } from '../../utils/utils';
 import type {
   AnySchema,
   AnyTree,
+  FilterTablesByEndsWith,
+  SerializedRecord,
   SerializedResource,
 } from '../DataModel/helperTypes';
 import type { SpecifyResource } from '../DataModel/legacyTypes';
 import { fetchContext as fetchDomain, schema } from '../DataModel/schema';
-import { getDomainResource } from '../DataModel/scoping';
 import { serializeResource } from '../DataModel/serializers';
 import { genericTables } from '../DataModel/tables';
 import type { Tables } from '../DataModel/types';
 
-let treeDefinitions: {
-  readonly [TREE_NAME in AnyTree['tableName']]: {
-    readonly definition: SpecifyResource<Tables[`${TREE_NAME}TreeDef`]>;
-    readonly ranks: RA<SerializedResource<Tables[`${TREE_NAME}TreeDefItem`]>>;
-  };
-} = undefined!;
+export type TreeInformation = {
+  readonly [TREE_NAME in AnyTree['tableName']]: RA<{
+    readonly definition: SerializedResource<FilterTablesByEndsWith<'TreeDef'>>;
+    readonly ranks: RA<
+      SerializedResource<FilterTablesByEndsWith<'TreeDefItem'>>
+    >;
+  }>;
+};
+
+let treeDefinitions: TreeInformation = undefined!;
 
 /*
  * FEATURE: allow reordering trees
@@ -37,7 +40,6 @@ let treeDefinitions: {
 const commonTrees = ['Geography', 'Storage', 'Taxon'] as const;
 const treesForPaleo = ['GeologicTimePeriod', 'LithoStrat'] as const;
 export const allTrees = [...commonTrees, ...treesForPaleo] as const;
-const paleoDiscs = new Set(['paleobotany', 'invertpaleo', 'vertpaleo']);
 /*
  * Until discipline information is loaded, assume all trees are appropriate in
  * this discipline
@@ -60,46 +62,36 @@ export const treeRanksPromise = Promise.all([
   import('../Permissions').then(async ({ fetchContext }) => fetchContext),
   import('../DataModel/tables').then(async ({ fetchContext }) => fetchContext),
   fetchDomain,
-])
-  .then(async ([{ hasTreeAccess, hasTablePermission }]) =>
-    hasTablePermission('Discipline', 'read')
-      ? getDomainResource('discipline')
-          ?.fetch()
-          .then((discipline) => {
-            if (!f.has(paleoDiscs, discipline?.get('type')))
-              disciplineTrees = commonTrees;
-          })
-          .then(async () =>
-            Promise.all(
-              disciplineTrees
-                .filter((treeName) => hasTreeAccess(treeName, 'read'))
-                .map(async (treeName) =>
-                  getDomainResource(getTreeScope(treeName) as 'discipline')
-                    ?.rgetPromise(
-                      `${unCapitalize(treeName) as 'geography'}TreeDef`
-                    )
-                    .then((treeDefinition) => {
-                      const ranks = {
-                        definition: treeDefinition,
-                        ranks: Array.from(
-                          treeDefinition.getDependentResource('treeDefItems')
-                            ?.models ?? [],
-                          (definitionItem) => serializeResource(definitionItem)
-                        ).sort(sortFunction(({ rankId }) => rankId)),
-                      };
+]).then(async () =>
+  ajax<{
+    readonly [TREE_NAME in AnyTree['tableName']]: RA<{
+      readonly definition: SerializedRecord<Tables[`${TREE_NAME}TreeDef`]>;
+      readonly ranks: RA<SerializedRecord<Tables[`${TREE_NAME}TreeDefItem`]>>;
+    }>;
+  }>('/api/specify_trees/', {
+    headers: { Accept: 'application/json' },
+  }).then(({ data }) => {
+    const treeNames = new Set(
+      Object.keys(data).map((key) => key.toLowerCase())
+    );
+    disciplineTrees = allTrees.filter((treeName) =>
+      treeNames.has(treeName.toLowerCase())
+    );
 
-                      return [treeName, ranks] as const;
-                    })
-                )
-            )
-          )
-      : []
-  )
-  .then((ranks) => {
-    // @ts-expect-error
-    treeDefinitions = Object.fromEntries(ranks.filter(Boolean));
+    treeDefinitions = Object.fromEntries(
+      Object.entries(data).map(([treeName, information]) => [
+        treeName,
+        information.map(({ definition, ranks }) => ({
+          definition: serializeResource(
+            definition as SerializedRecord<FilterTablesByEndsWith<'TreeDef'>>
+          ),
+          ranks: ranks.map((rank) => serializeResource(rank)),
+        })),
+      ])
+    );
     return treeDefinitions;
-  });
+  })
+);
 
 function getTreeScope(
   treeName: AnyTree['tableName']
@@ -114,22 +106,61 @@ function getTreeScope(
   );
 }
 
+export function getTreeDefinitions<TREE_NAME extends AnyTree['tableName']>(
+  tableName: TREE_NAME,
+  treeDefinitionId: number | 'all' | undefined = getCache(
+    'tree',
+    `definition${tableName}`
+  )
+): TreeInformation[TREE_NAME] {
+  const specificTreeDefinitions = caseInsensitiveHash(
+    defined(treeDefinitions),
+    tableName
+  );
+
+  return typeof treeDefinitionId === 'number'
+    ? specificTreeDefinitions.filter(
+        ({ definition }) => definition.id === treeDefinitionId
+      )
+    : specificTreeDefinitions;
+}
+
 export function getTreeDefinitionItems<TREE_NAME extends AnyTree['tableName']>(
   tableName: TREE_NAME,
-  includeRoot: boolean
-): typeof treeDefinitions[TREE_NAME]['ranks'] | undefined {
-  const definition = caseInsensitiveHash(treeDefinitions, tableName);
-  return definition?.ranks.slice(includeRoot ? 0 : 1);
+  includeRoot: boolean,
+  treeDefinitionId: number | 'all' | undefined = getCache(
+    'tree',
+    `definition${tableName}`
+  )
+): TreeInformation[TREE_NAME][number]['ranks'] | undefined {
+  const specificTreeDefinitions =
+    treeDefinitions === undefined
+      ? undefined
+      : caseInsensitiveHash(treeDefinitions, tableName);
+
+  return specificTreeDefinitions === undefined
+    ? undefined
+    : typeof treeDefinitionId === 'number'
+    ? specificTreeDefinitions
+        .find(({ definition }) => definition.id === treeDefinitionId)
+        ?.ranks.slice(includeRoot ? 0 : 1)
+    : specificTreeDefinitions.flatMap(({ ranks }) =>
+        ranks.slice(includeRoot ? 0 : 1)
+      );
 }
 
 export const strictGetTreeDefinitionItems = <
   TREE_NAME extends AnyTree['tableName']
 >(
   tableName: TREE_NAME,
-  includeRoot: boolean
-): typeof treeDefinitions[TREE_NAME]['ranks'] =>
+  includeRoot: boolean,
+  treeDefinitionId: number | 'all' | undefined = getCache(
+    'tree',
+    `definition${tableName}`
+  )
+): TreeInformation[TREE_NAME][number]['ranks'] =>
   defined(
-    getTreeDefinitionItems(tableName, includeRoot),
+    getTreeDefinitionItems(tableName, includeRoot, treeDefinitionId),
     `Unable to get tree ranks for a ${tableName} table`
   );
 

specifyweb/frontend/js_src/lib/components/Leaflet/localityRecordDataExtractor.ts

@@ -136,7 +136,8 @@ async function recursiveResourceResolve(
       return [];
     const tableRanks = strictGetTreeDefinitionItems(
       treeTableName as 'Geography',
-      false
+      false,
+      'all'
     );
     const currentRank = defined(
       tableRanks.find(({ rankId }) => rankId === resource.get('rankId')),