Add an Add and Delete tree ranks option

specifyweb/frontend/js_src/lib/components/TreeView/Tree.tsx

@@ -22,6 +22,12 @@ import { userPreferences } from '../Preferences/userPreferences';
 import type { Conformations, Row, Stats } from './helpers';
 import { fetchStats } from './helpers';
 import { TreeRow } from './Row';
+import { commonText } from '../../localization/common';
+import { Dialog } from '../Molecules/Dialog';
+import { Form, Input, Label } from '../Atoms/Form';
+import { Submit } from '../Atoms/Submit';
+import { ping } from '../../utils/ajax/ping';
+import { LoadingContext } from '../Core/Contexts';
 
 const treeToPref = {
   Geography: 'geography',
@@ -100,6 +106,25 @@ export function Tree<SCHEMA extends AnyTree>({
     [baseUrl, statsThreshold]
   );
 
+  const loading = React.useContext(LoadingContext);
+  const rankId = useId('add-tree-rank')('');
+  const [isAddingRank, setIsAddingRank] = React.useState(false);
+  const [newRankName, setNewRankName] = React.useState('');
+  function addRank(parentRankName: string): void {
+    const url = `/api/specify_tree/${tableName.toLowerCase()}/add_tree_rank/`;
+    loading(
+      ping(url, {
+        method: 'POST',
+        body: {
+          newRankName: newRankName,
+          parentRankName: parentRankName,
+          treeName: tableName.toLowerCase(),
+        },
+      }).then(() => globalThis.location.reload())
+    );
+    setIsAddingRank(false);
+  }
+
   return (
     <div
       className={`
@@ -172,10 +197,50 @@ export function Tree<SCHEMA extends AnyTree>({
                       : rankName) as LocalizedString
                   }
                 </Button.LikeLink>
-                {isEditingRanks &&
-                collapsedRanks?.includes(rank.rankId) !== true ? (
-                  <EditTreeRank rank={rank} />
-                ) : undefined}
+                {isEditingRanks && (
+                  <>
+                    {collapsedRanks?.includes(rank.rankId) !== true ? (
+                      <EditTreeRank rank={rank} />
+                    ) : undefined}
+                    <Button.Icon
+                      icon="plus"
+                      title={treeText.addNewRank()}
+                      onClick={() => setIsAddingRank(true)}
+                    />
+                  </>
+                )}
+                {isAddingRank && (
+                  <Dialog
+                    buttons={
+                      <>
+                        <Button.DialogClose>
+                          {commonText.cancel()}
+                        </Button.DialogClose>
+                        <Submit.Info form={rankId}>
+                          {commonText.create()}
+                        </Submit.Info>
+                      </>
+                    }
+                    onClose={() => setIsAddingRank(false)}
+                    header={treeText.addNewRank()}
+                  >
+                    <Form
+                      id={rankId}
+                      onSubmit={(): void => {
+                        addRank(rankName);
+                      }}
+                    >
+                      <Label.Block>
+                        {treeText.newRankName()}
+                        <Input.Text
+                          required
+                          value={newRankName}
+                          onValueChange={setNewRankName}
+                        />
+                      </Label.Block>
+                    </Form>
+                  </Dialog>
+                )}
               </div>
             );
           })}

specifyweb/frontend/js_src/lib/localization/tree.ts

@@ -459,4 +459,10 @@ export const treeText = createDictionary({
     'uk-ua': 'Синхронізувати',
     'ru-ru': 'Это приведет к безвозвратному удалению следующего ресурса',
   },
+  addNewRank: {
+    'en-us': 'Add New Rank',
+  },
+  newRankName: {
+    'en-us': 'New Rank Name',
+  },
 } as const);

specifyweb/specify/test_trees.py

@@ -1,7 +1,10 @@
+import json
+from django.test import Client
 from specifyweb.specify import models
 from specifyweb.specify.api_tests import ApiTests, get_table
 from specifyweb.specify.tree_stats import get_tree_stats
 from specifyweb.stored_queries.tests import SQLAlchemySetup
+from .tree_extras import set_fullnames
 
 class TestTreeSetup(ApiTests):
     def setUp(self) -> None:
@@ -208,4 +211,238 @@ def test_counts_correctness(self):
             for parent_id, correct in correct_results.items()
         ]
 
+class AddDeleteRanksTest(ApiTests):
+    def setUp(self) -> None:
+        super().setUp()
+
+    def test_add_ranks_without_defaults(self):
+        c = Client()
+        c.force_login(self.specifyuser)
+
+        treedef_geo = models.Geographytreedef.objects.create(name='GeographyTest')
+
+        # Test adding non-default rank on empty heirarchy
+        response = c.post(
+            '/api/specify_tree/geography/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Universe',
+                'parentRankName': 'root',
+                'treeID': treedef_geo.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(100, models.Geographytreedefitem.objects.get(name='Universe').rankid)
 
+        # Test adding non-default rank to the end of the heirarchy
+        response = c.post(
+            '/api/specify_tree/geography/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Galaxy',
+                'parentRankName': 'Universe',
+                'treeID': treedef_geo.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(200, models.Geographytreedefitem.objects.get(name='Galaxy').rankid)
+
+        # Test adding non-default rank to the front of the heirarchy
+        response = c.post(
+            '/api/specify_tree/geography/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Multiverse',
+                'parentRankName': 'root',
+                'treeID': treedef_geo.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(50, models.Geographytreedefitem.objects.get(name='Multiverse').rankid)
+
+        # Test adding non-default rank in the middle of the heirarchy
+        response = c.post(
+            '/api/specify_tree/geography/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Dimension',
+                'parentRankName': 'Universe',
+                'treeID': treedef_geo.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(150, models.Geographytreedefitem.objects.get(name='Dimension').rankid)
+
+        # Test foreign keys
+        self.assertEqual(4, models.Geographytreedefitem.objects.filter(treedef=treedef_geo).count())
+
+        # Create test nodes
+        cfc = models.Geography.objects.create(name='Central Finite Curve', rankid=50, definition=treedef_geo,
+                                              definitionitem=models.Geographytreedefitem.objects.get(name='Multiverse'))
+        c137 = models.Geography.objects.create(name='C137', rankid=100, parent=cfc, definition=treedef_geo,
+                                               definitionitem=models.Geographytreedefitem.objects.get(name='Universe'))
+        d3 = models.Geography.objects.create(name='3D', rankid=150, parent=c137, definition=treedef_geo,
+                                             definitionitem=models.Geographytreedefitem.objects.get(name='Dimension'))
+        milky_way = models.Geography.objects.create(name='Milky Way', parent=d3, rankid=200, definition=treedef_geo,
+                                                    definitionitem=models.Geographytreedefitem.objects.get(
+                                                        name='Galaxy'))
+
+        # Test full name reconstruction
+        set_fullnames(treedef_geo, null_only=False, node_number_range=None)
+        if cfc.fullname is not None:
+            self.assertEqual('Central Finite Curve', cfc.fullname)
+        if c137.fullname is not None:
+            self.assertEqual('C137', c137.fullname)
+        if d3.fullname is not None:
+            self.assertEqual('3D', d3.fullname)
+        if milky_way.fullname is not None:
+            self.assertEqual('Milky Way', milky_way.fullname)
+
+        # Test parents of child nodes
+        self.assertEqual(cfc.id, c137.parent.id)
+        self.assertEqual(c137.id, d3.parent.id)
+        self.assertEqual(d3.id, milky_way.parent.id)
+
+
+    def test_add_ranks_with_defaults(self):
+        c = Client()
+        c.force_login(self.specifyuser)
+
+        treedef_taxon = models.Taxontreedef.objects.create(name='TaxonTest')
+
+        # Test adding default rank on empty heirarchy
+        response = c.post(
+            '/api/specify_tree/taxon/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Taxonomy Root',
+                'parentRankName': 'root',
+                'treeID': treedef_taxon.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(0, models.Taxontreedefitem.objects.get(name='Taxonomy Root').rankid)
+
+        # Test adding non-default rank in front of rank 0
+        response = c.post(
+            '/api/specify_tree/taxon/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Invalid',
+                'parentRankName': 'root',
+                'treeID': treedef_taxon.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(0, models.Taxontreedefitem.objects.filter(name='Invalid').count())
+
+        # Test adding default rank to the end of the heirarchy
+        response = c.post(
+            '/api/specify_tree/taxon/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Division',
+                'parentRankName': 'Taxonomy Root',
+                'treeID': treedef_taxon.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(30, models.Taxontreedefitem.objects.get(name='Division').rankid)
+
+        # Test adding default rank to the middle of the heirarchy
+        response = c.post(
+            '/api/specify_tree/taxon/add_tree_rank/',
+            data=json.dumps({
+                'newRankName': 'Kingdom',
+                'parentRankName': 'Taxonomy Root',
+                'treeID': treedef_taxon.id
+            }),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(10, models.Taxontreedefitem.objects.get(name='Kingdom').rankid)
+        self.assertEqual(models.Taxontreedefitem.objects.get(name='Division').parent.id,
+                         models.Taxontreedefitem.objects.get(name='Kingdom').id)
+        self.assertEqual(models.Taxontreedefitem.objects.get(name='Kingdom').parent.id,
+                         models.Taxontreedefitem.objects.get(name='Taxonomy Root').id)
+
+        # Test foreign keys
+        for rank in models.Taxontreedefitem.objects.all():
+            self.assertEqual(treedef_taxon.id, rank.treedef.id)
+
+        # Create test nodes
+        pokemon = models.Taxon.objects.create(name='Pokemon', rankid=50, definition=treedef_taxon,
+                                              definitionitem=models.Taxontreedefitem.objects.get(name='Taxonomy Root'))
+        water = models.Taxon.objects.create(name='Water', rankid=100, parent=pokemon, definition=treedef_taxon,
+                                            definitionitem=models.Taxontreedefitem.objects.get(name='Kingdom'))
+        squirtle = models.Taxon.objects.create(name='Squirtle', rankid=150, parent=water, definition=treedef_taxon,
+                                               definitionitem=models.Taxontreedefitem.objects.get(name='Division'))
+        blastoise = models.Taxon.objects.create(name='Blastoise', parent=water, rankid=200, definition=treedef_taxon,
+                                                definitionitem=models.Taxontreedefitem.objects.get(name='Division'))
+
+        # Test full name reconstruction
+        set_fullnames(treedef_taxon, null_only=False, node_number_range=None)
+        if pokemon.fullname is not None:
+            self.assertEqual('Pokemon', pokemon.fullname)
+        if water.fullname is not None:
+            self.assertEqual('Water', water.fullname)
+        if squirtle.fullname is not None:
+            self.assertEqual('Squirtle', squirtle.fullname)
+        if blastoise.fullname is not None:
+            self.assertEqual('Blastoise', blastoise.fullname)
+
+    def test_delete_ranks(self):
+        c = Client()
+        c.force_login(self.specifyuser)
+
+        treedef_geotimeperiod = models.Geologictimeperiodtreedef.objects.create(name='GeographyTimePeriodTest')
+        era_ranks = models.Geologictimeperiodtreedefitem.objects.create(
+            name='Era',
+            rankid=100,
+            treedef=treedef_geotimeperiod
+        )
+        period_rank = models.Geologictimeperiodtreedefitem.objects.create(
+            name='Period',
+            rankid=200,
+            treedef=treedef_geotimeperiod,
+            parent=era_ranks
+        )
+        epoch_rank = models.Geologictimeperiodtreedefitem.objects.create(
+            name='Epoch',
+            rankid=300,
+            treedef=treedef_geotimeperiod,
+            parent=period_rank
+        )
+        age_rank = models.Geologictimeperiodtreedefitem.objects.create(
+            name='Age',
+            rankid=400,
+            treedef=treedef_geotimeperiod,
+            parent=epoch_rank
+        )
+
+        # Test deleting a rank in the middle of the heirarchy
+        response = c.post(
+            '/api/specify_tree/geologictimeperiod/delete_tree_rank/',
+            data= json.dumps({'rankName': 'Epoch', 'treeID': treedef_geotimeperiod.id}),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(None, models.Geologictimeperiodtreedefitem.objects.filter(name='Epoch').first())
+        self.assertEqual(period_rank.id, models.Geologictimeperiodtreedefitem.objects.get(name='Age').parent.id)
+
+        # Test deleting a rank at the end of the heirarchy
+        response = c.post(
+            '/api/specify_tree/geologictimeperiod/delete_tree_rank/',
+            data= json.dumps({'rankName': 'Age', 'treeID': treedef_geotimeperiod.id}),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(None, models.Geologictimeperiodtreedefitem.objects.filter(name='Age').first())
+
+        # Test deleting a rank at the head of the heirarchy
+        response = c.post(
+            '/api/specify_tree/geologictimeperiod/delete_tree_rank/',
+            data= json.dumps({'rankName': 'Era', 'treeID': treedef_geotimeperiod.id}),
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 500)