Preserve Workbench business rule payloads for clearer validation errors

specifyweb/backend/workbench/upload/tests/test_upload_results_json.py

@@ -4,6 +4,8 @@
 import unittest
 from jsonschema import validate, Draft7Validator # type: ignore
 
+from specifyweb.backend.businessrules.exceptions import BusinessRuleException
+
 from ..upload_result import *
 from ..upload_results_schema import schema
 
@@ -36,6 +38,37 @@ def testFailedBusinessRule(self, failedBusinessRule: FailedBusinessRule):
         j = json.dumps(failedBusinessRule.to_json())
         self.assertEqual(failedBusinessRule, FailedBusinessRule.from_json(json.loads(j)))
 
+    def testBusinessRuleExceptionPayload(self):
+        info = ReportInfo(
+            tableName="Collectionobject",
+            columns=["catalogNumber"],
+            treeInfo=None,
+        )
+        payload = {
+            "localizationKey": "childFieldNotUnique",
+            "table": "Collectionobject",
+            "fieldName": "catalognumber",
+            "fieldData": {"catalognumber": "0037481"},
+            "parentField": "collection",
+            "parentData": {"collection": "Collection object (360449)"},
+            "conflicting": [3347460],
+        }
+
+        self.assertEqual(
+            to_failed_business_rule(
+                BusinessRuleException(
+                    "Collectionobject must have unique catalognumber in collection",
+                    payload,
+                ),
+                info,
+            ),
+            FailedBusinessRule(
+                "Collectionobject must have unique catalognumber in collection",
+                payload,
+                info,
+            ),
+        )
+
     @given(noMatch=infer)
     def testNoMatch(self, noMatch: NoMatch):
         j = json.dumps(noMatch.to_json())

specifyweb/backend/workbench/upload/treerecord.py

@@ -47,6 +47,7 @@
     FailedBusinessRule,
     ReportInfo,
     TreeInfo,
+    to_failed_business_rule,
 )
 from .uploadable import (
     Row,
@@ -954,7 +955,7 @@ def _upload(
                         obj = self._do_insert(model, **new_attrs)
                 except (BusinessRuleException, IntegrityError) as e:
                     return UploadResult(
-                        FailedBusinessRule(str(e), {}, info), parent_result, {}
+                        to_failed_business_rule(e, info), parent_result, {}
                     )
 
             result = UploadResult(Uploaded(obj.id, info, []), parent_result, {})

specifyweb/backend/workbench/upload/upload_result.py

@@ -5,6 +5,18 @@
 from .parsing import WorkBenchParseFailure
 
 Failure = Literal["Failure"]
+BUSINESS_RULE_EXCEPTION_MODULE = "specifyweb.backend.businessrules.exceptions"
+BUSINESS_RULE_EXCEPTION_NAME = "BusinessRuleException"
+BusinessRulePayloadValue = (
+    str
+    | int
+    | bool
+    | None
+    | list[str]
+    | list[int]
+    | dict[str, str | int | bool | None]
+)
+BusinessRulePayload = dict[str, BusinessRulePayloadValue]
 
 
 class TreeInfo(NamedTuple):
@@ -215,7 +227,7 @@ def from_json(json: dict) -> "Deleted":
 
 class FailedBusinessRule(NamedTuple):
     message: str
-    payload: dict[str, str | int | list[str] | list[int]]
+    payload: BusinessRulePayload
     info: ReportInfo
 
     def get_id(self) -> Failure:
@@ -238,6 +250,24 @@ def from_json(json: dict) -> "FailedBusinessRule":
         )
 
 
+def is_business_rule_exception_with_payload(exception: Exception) -> bool:
+    exception_class = exception.__class__
+    return (
+        exception_class.__module__ == BUSINESS_RULE_EXCEPTION_MODULE
+        and exception_class.__name__ == BUSINESS_RULE_EXCEPTION_NAME
+        and len(exception.args) >= 2
+        and isinstance(exception.args[0], str)
+        and isinstance(exception.args[1], dict)
+    )
+
+
+def to_failed_business_rule(exception: Exception, info: ReportInfo) -> FailedBusinessRule:
+    if is_business_rule_exception_with_payload(exception):
+        return FailedBusinessRule(exception.args[0], exception.args[1], info)
+
+    return FailedBusinessRule(str(exception), {}, info)
+
+
 class NoMatch(NamedTuple):
     info: ReportInfo
 

specifyweb/backend/workbench/upload/upload_table.py

@@ -39,6 +39,7 @@
     PicklistAddition,
     ParseFailures,
     PropagatedFailure,
+    to_failed_business_rule,
 )
 from .uploadable import (
     NULL_RECORD,
@@ -760,7 +761,7 @@ def _do_upload(
                 picklist_additions = self._do_picklist_additions()
             except (BusinessRuleException, IntegrityError) as e:
                 return UploadResult(
-                    FailedBusinessRule(str(e), {}, info), to_one_results, {}
+                    to_failed_business_rule(e, info), to_one_results, {}
                 )
 
         record = Uploaded(uploaded.id, info, picklist_additions)
@@ -865,7 +866,7 @@ def delete_row(self, parent_obj=None) -> UploadResult:
                 reference_record.delete()
                 result = Deleted(self.current_id, info)
             except (BusinessRuleException, IntegrityError) as e:
-                result = FailedBusinessRule(str(e), {}, info)
+                result = to_failed_business_rule(e, info)
 
         to_one_deleted: dict[str, UploadResult] = {
             key: value.delete_row()
@@ -1066,7 +1067,7 @@ def _do_upload(
                     picklist_additions = self._do_picklist_additions()
                 except (BusinessRuleException, IntegrityError) as e:
                     return UploadResult(
-                        FailedBusinessRule(str(e), {}, info), to_one_results, {}
+                        to_failed_business_rule(e, info), to_one_results, {}
                     )
 
         record: Updated | NoChange = (

specifyweb/frontend/js_src/lib/components/WorkBench/resultsParser.ts

@@ -15,7 +15,7 @@ import {
   formatDisjunction,
 } from '../Atoms/Internationalization';
 import { getField } from '../DataModel/helpers';
-import { tables } from '../DataModel/tables';
+import { getTable, tables } from '../DataModel/tables';
 import type { Tables } from '../DataModel/types';
 
 /*
@@ -256,14 +256,96 @@ export function resolveBackendParsingMessage(
   else return undefined;
 }
 
+function withConflictingRecordIds(
+  message: LocalizedString,
+  payload: IR<unknown>
+): LocalizedString {
+  const conflicting = payload.conflicting;
+  return Array.isArray(conflicting) && conflicting.length > 0
+    ? localized(
+        `${message} (Conflicting record IDs: ${conflicting.join(', ')})`
+      )
+    : message;
+}
+
+function getStringPayload(payload: IR<unknown>, key: string): string {
+  const value = payload[key];
+  return typeof value === 'string' ? value : '';
+}
+
+function getSchemaTableLabel(tableName: string): LocalizedString {
+  return getTable(tableName)?.label ?? localized(tableName);
+}
+
+function getSchemaFieldLabel(
+  tableName: string,
+  fieldName: string
+): LocalizedString {
+  const lookupFieldName = fieldName.split('__').join('.');
+  return (
+    getTable(tableName)?.getField(lookupFieldName)?.label ??
+    localized(fieldName)
+  );
+}
+
+function getSchemaFieldLabels(
+  tableName: string,
+  fieldNames: string
+): LocalizedString {
+  const labels = fieldNames
+    .split(',')
+    .map((fieldName) => fieldName.trim())
+    .filter((fieldName) => fieldName.length > 0)
+    .map((fieldName) => getSchemaFieldLabel(tableName, fieldName));
+  return labels.length === 0
+    ? localized(fieldNames)
+    : formatConjunction(labels);
+}
+
+function resolveBackendBusinessRuleMessage(
+  payload: IR<unknown>
+): LocalizedString | undefined {
+  const tableName = getStringPayload(payload, 'table');
+  if (payload.localizationKey === 'fieldNotUnique')
+    return withConflictingRecordIds(
+      backEndText.fieldNotUnique({
+        tableName: getSchemaTableLabel(tableName),
+        fieldName: getSchemaFieldLabels(
+          tableName,
+          getStringPayload(payload, 'fieldName')
+        ),
+      }),
+      payload
+    );
+  else if (payload.localizationKey === 'childFieldNotUnique')
+    return withConflictingRecordIds(
+      backEndText.childFieldNotUnique({
+        tableName: getSchemaTableLabel(tableName),
+        fieldName: getSchemaFieldLabels(
+          tableName,
+          getStringPayload(payload, 'fieldName')
+        ),
+        parentField: getSchemaFieldLabels(
+          tableName,
+          getStringPayload(payload, 'parentField')
+        ),
+      }),
+      payload
+    );
+  else return undefined;
+}
+
 /** Back-end sends a validation key. Front-end translates it */
 export function resolveValidationMessage(
   key: string,
   payload: IR<unknown>
 ): LocalizedString {
   const baseParsedMessage = resolveBackendParsingMessage(key, payload);
+  const businessRuleMessage = resolveBackendBusinessRuleMessage(payload);
   if (baseParsedMessage !== undefined) {
     return baseParsedMessage;
+  } else if (businessRuleMessage !== undefined) {
+    return businessRuleMessage;
   } else if (key === 'failedParsingPickList')
     return backEndText.failedParsingPickList({
       value: `"${payload.value as string}"`,