Lf 4380 api route for edit update route for edit animal and batch details

packages/api/src/controllers/animalBatchController.js

@@ -16,11 +16,10 @@
 import { Model, transaction } from 'objection';
 import AnimalBatchModel from '../models/animalBatchModel.js';
 import baseController from './baseController.js';
-import CustomAnimalBreedModel from '../models/customAnimalBreedModel.js';
-import CustomAnimalTypeModel from '../models/customAnimalTypeModel.js';
 import { handleObjectionError } from '../util/errorCodes.js';
-import { assignInternalIdentifiers } from '../util/animal.js';
+import { assignInternalIdentifiers, checkAndAddCustomTypeAndBreed } from '../util/animal.js';
 import { uploadPublicImage } from '../util/imageUpload.js';
+import _pick from 'lodash/pick.js';
 
 const animalBatchController = {
   getFarmAnimalBatches() {
@@ -60,50 +59,19 @@ const animalBatchController = {
         const { farm_id } = req.headers;
         const result = [];
 
-        // avoid attempts to add an already created type or breed to the DB
-        // where multiple batches have the same type_name or breed_name
+        // Create utility object used in type and breed
         const typeIdsMap = {};
         const typeBreedIdsMap = {};
 
         for (const animalBatch of req.body) {
-          if (animalBatch.type_name) {
-            let typeId = typeIdsMap[animalBatch.type_name];
-
-            if (!typeId) {
-              const newType = await baseController.postWithResponse(
-                CustomAnimalTypeModel,
-                { type: animalBatch.type_name, farm_id },
-                req,
-                { trx },
-              );
-              typeId = newType.id;
-              typeIdsMap[animalBatch.type_name] = typeId;
-            }
-            animalBatch.custom_type_id = typeId;
-            delete animalBatch.type_name;
-          }
-
-          if (animalBatch.breed_name) {
-            const typeColumn = animalBatch.default_type_id ? 'default_type_id' : 'custom_type_id';
-            const typeId = animalBatch.type_name
-              ? typeIdsMap[animalBatch.type_name]
-              : animalBatch.default_type_id || animalBatch.custom_type_id;
-            const typeBreedKey = `${typeColumn}_${typeId}_${animalBatch.breed_name}`;
-            let breedId = typeBreedIdsMap[typeBreedKey];
-
-            if (!breedId) {
-              const newBreed = await baseController.postWithResponse(
-                CustomAnimalBreedModel,
-                { farm_id, [typeColumn]: typeId, breed: animalBatch.breed_name },
-                req,
-                { trx },
-              );
-              breedId = newBreed.id;
-              typeBreedIdsMap[typeBreedKey] = breedId;
-            }
-            animalBatch.custom_breed_id = breedId;
-            delete animalBatch.breed_name;
-          }
+          await checkAndAddCustomTypeAndBreed(
+            req,
+            typeIdsMap,
+            typeBreedIdsMap,
+            animalBatch,
+            farm_id,
+            trx,
+          );
 
           // Remove farm_id if it happens to be set in animal object since it should be obtained from header
           delete animalBatch.farm_id;
@@ -128,6 +96,62 @@ const animalBatchController = {
     };
   },
 
+  editAnimalBatches() {
+    return async (req, res) => {
+      const trx = await transaction.start(Model.knex());
+
+      try {
+        const { farm_id } = req.headers;
+
+        // Create utility object used in type and breed
+        const typeIdsMap = {};
+        const typeBreedIdsMap = {};
+
+        const desiredKeys = [
+          'id',
+          'count',
+          'custom_breed_id',
+          'custom_type_id',
+          'default_breed_id',
+          'default_type_id',
+          'name',
+          'notes',
+          'photo_url',
+          'organic_status',
+          'supplier',
+          'price',
+          'sex_detail',
+          'origin_id',
+          'group_ids',
+          'animal_batch_use_relationships',
+        ];
+
+        // select only allowed properties to edit
+        for (const animalBatch of req.body) {
+          await checkAndAddCustomTypeAndBreed(
+            req,
+            typeIdsMap,
+            typeBreedIdsMap,
+            animalBatch,
+            farm_id,
+            trx,
+          );
+
+          const keysExisting = desiredKeys.filter((key) => key in animalBatch);
+          const data = _pick(animalBatch, keysExisting);
+
+          await baseController.upsertGraph(AnimalBatchModel, data, req, { trx });
+        }
+
+        await trx.commit();
+        // Do not send result revalidate using tags on frontend
+        return res.status(204).send();
+      } catch (error) {
+        handleObjectionError(error, res, trx);
+      }
+    };
+  },
+
   removeAnimalBatches() {
     return async (req, res) => {
       const trx = await transaction.start(Model.knex());

packages/api/src/controllers/animalController.js

@@ -16,15 +16,14 @@
 import { Model, transaction } from 'objection';
 import AnimalModel from '../models/animalModel.js';
 import baseController from './baseController.js';
-import CustomAnimalBreedModel from '../models/customAnimalBreedModel.js';
-import CustomAnimalTypeModel from '../models/customAnimalTypeModel.js';
-import AnimalGroupModel from '../models/animalGroupModel.js';
-import AnimalGroupRelationshipModel from '../models/animalGroupRelationshipModel.js';
-import { assignInternalIdentifiers } from '../util/animal.js';
+import {
+  assignInternalIdentifiers,
+  upsertGroup,
+  checkAndAddCustomTypeAndBreed,
+} from '../util/animal.js';
 import { handleObjectionError } from '../util/errorCodes.js';
-import { checkAndTrimString } from '../util/util.js';
-import AnimalUseRelationshipModel from '../models/animalUseRelationshipModel.js';
 import { uploadPublicImage } from '../util/imageUpload.js';
+import _pick from 'lodash/pick.js';
 
 const animalController = {
   getFarmAnimals() {
@@ -58,126 +57,120 @@ const animalController = {
   addAnimals() {
     return async (req, res) => {
       const trx = await transaction.start(Model.knex());
-
       try {
         const { farm_id } = req.headers;
         const result = [];
 
-        // avoid attempts to add an already created type or breed to the DB
-        // where multiple animals have the same type_name or breed_name
+        // Create utility object used in type and breed
         const typeIdsMap = {};
         const typeBreedIdsMap = {};
 
         for (const animal of req.body) {
-          if (animal.type_name) {
-            let typeId = typeIdsMap[animal.type_name];
-
-            if (!typeId) {
-              const newType = await baseController.postWithResponse(
-                CustomAnimalTypeModel,
-                { type: animal.type_name, farm_id },
-                req,
-                { trx },
-              );
-              typeId = newType.id;
-              typeIdsMap[animal.type_name] = typeId;
-            }
-            animal.custom_type_id = typeId;
-            delete animal.type_name;
-          }
-
-          if (animal.breed_name) {
-            const typeColumn = animal.default_type_id ? 'default_type_id' : 'custom_type_id';
-            const typeId = animal.type_name
-              ? typeIdsMap[animal.type_name]
-              : animal.default_type_id || animal.custom_type_id;
-            const typeBreedKey = `${typeColumn}_${typeId}_${animal.breed_name}`;
-            let breedId = typeBreedIdsMap[typeBreedKey];
-
-            if (!breedId) {
-              const newBreed = await baseController.postWithResponse(
-                CustomAnimalBreedModel,
-                { farm_id, [typeColumn]: typeId, breed: animal.breed_name },
-                req,
-                { trx },
-              );
-              breedId = newBreed.id;
-              typeBreedIdsMap[typeBreedKey] = breedId;
-            }
-            animal.custom_breed_id = breedId;
-            delete animal.breed_name;
-          }
+          await checkAndAddCustomTypeAndBreed(
+            req,
+            typeIdsMap,
+            typeBreedIdsMap,
+            animal,
+            farm_id,
+            trx,
+          );
+
+          await upsertGroup(req, animal, farm_id, trx);
 
           // Remove farm_id if it happens to be set in animal object since it should be obtained from header
           delete animal.farm_id;
 
-          const groupName = checkAndTrimString(animal.group_name);
-          delete animal.group_name;
-
-          const individualAnimalResult = await baseController.postWithResponse(
+          const individualAnimalResult = await baseController.insertGraphWithResponse(
             AnimalModel,
             { ...animal, farm_id },
             req,
             { trx },
           );
 
-          const groupIds = [];
-          if (groupName) {
-            let group = await baseController.existsInTable(trx, AnimalGroupModel, {
-              name: groupName,
-              farm_id,
-              deleted: false,
-            });
-
-            if (!group) {
-              group = await baseController.postWithResponse(
-                AnimalGroupModel,
-                { name: groupName, farm_id },
-                req,
-                { trx },
-              );
-            }
-
-            groupIds.push(group.id);
-
-            // Insert into join table
-            await AnimalGroupRelationshipModel.query(trx).insert({
-              animal_id: individualAnimalResult.id,
-              animal_group_id: group.id,
-            });
-          }
-
-          individualAnimalResult.group_ids = groupIds;
-
-          const animalUseRelationships = [];
-          if (animal.animal_use_relationships?.length) {
-            for (const relationship of animal.animal_use_relationships) {
-              animalUseRelationships.push(
-                await baseController.postWithResponse(
-                  AnimalUseRelationshipModel,
-                  { ...relationship, animal_id: individualAnimalResult.id },
-                  req,
-                  { trx },
-                ),
-              );
-            }
-          }
-
-          individualAnimalResult.animal_use_relationships = animalUseRelationships;
+          // Format group_ids
+          individualAnimalResult.group_ids =
+            individualAnimalResult.group_ids?.map((group) => group.animal_group_id) || [];
 
           result.push(individualAnimalResult);
         }
 
         await trx.commit();
 
         await assignInternalIdentifiers(result, 'animal');
+
         return res.status(201).send(result);
       } catch (error) {
         await handleObjectionError(error, res, trx);
       }
     };
   },
+  editAnimals() {
+    return async (req, res) => {
+      const trx = await transaction.start(Model.knex());
+
+      try {
+        const { farm_id } = req.headers;
+        // Create utility object used in type and breed
+        const typeIdsMap = {};
+        const typeBreedIdsMap = {};
+
+        const desiredKeys = [
+          'id',
+          'custom_breed_id',
+          'custom_type_id',
+          'default_breed_id',
+          'default_type_id',
+          'sex_id',
+          'name',
+          'birth_date',
+          'identifier',
+          'identifier_color_id',
+          'identifier_placement_id',
+          'identifier_type_id',
+          'identifier_type_other',
+          'origin_id',
+          'dam',
+          'sire',
+          'brought_in_date',
+          'weaning_date',
+          'notes',
+          'photo_url',
+          'organic_status',
+          'supplier',
+          'price',
+          'sex_detail',
+          'origin_id',
+          'group_ids',
+          'animal_use_relationships',
+        ];
+
+        // select only allowed properties to edit
+        for (const animal of req.body) {
+          await checkAndAddCustomTypeAndBreed(
+            req,
+            typeIdsMap,
+            typeBreedIdsMap,
+            animal,
+            farm_id,
+            trx,
+          );
+
+          await upsertGroup(req, animal, farm_id, trx);
+
+          const keysExisting = desiredKeys.filter((key) => key in animal);
+          const data = _pick(animal, keysExisting);
+
+          await baseController.upsertGraph(AnimalModel, data, req, { trx });
+        }
 
+        await trx.commit();
+        // Do not send result revalidate using tags on frontend
+        return res.status(204).send();
+      } catch (error) {
+        handleObjectionError(error, res, trx);
+      }
+    };
+  },
   removeAnimals() {
     return async (req, res) => {
       const trx = await transaction.start(Model.knex());