UILD-427: Authority validation - Creator of Work

src/common/constants/api.constants.ts

@@ -5,10 +5,11 @@ export const EDITOR_API_BASE_PATH = 'EDITOR_API_BASE_PATH';
 
 // API endpoints
 export const BIBFRAME_API_ENDPOINT = '/linked-data/resource';
-export const INVENTORY_API_ENDPOINT = '/linked-data/inventory-instance'
+export const INVENTORY_API_ENDPOINT = '/linked-data/inventory-instance';
 export const PROFILE_API_ENDPOINT = '/linked-data/profile';
 export const SEARCH_API_ENDPOINT = '/search/linked-data';
 export const SEARCH_RESOURCE_API_ENDPOINT = `${SEARCH_API_ENDPOINT}/works`;
+export const AUTHORITY_ASSIGNMENT_CHECK_API_ENDPOINT = '/linked-data/authority-assignment-check';
 
 export const DEFAULT_PAGES_METADATA = {
   totalElements: 0,

src/common/helpers/complexLookup.helper.ts

@@ -66,3 +66,15 @@ export const getUpdatedSelectedEntries = ({
 
   return selectedEntriesService.get();
 };
+
+export const generateValidationRequestBody = (marcData: MarcDTO | null, target = 'CREATOR_OF_WORK') => {
+  if (!marcData) return {};
+
+  const rawMarcEncoded = JSON.stringify(marcData?.parsedRecord?.content, null, 2);
+  const excapedString = rawMarcEncoded.replace(/\r/g, '\r').replace(/\n/g, '\n');
+
+  return {
+    rawMarc: excapedString,
+    target,
+  };
+};

src/common/hooks/useApi.ts

@@ -0,0 +1,64 @@
+import { useState, useCallback } from 'react';
+import BaseApi from '@common/api/base.api';
+import { StatusType } from '@common/constants/status.constants';
+import { UserNotificationFactory } from '@common/services/userNotification';
+import { useLoadingState, useStatusState } from '@src/store';
+
+interface RequestConfig {
+  url: string;
+  method?: APIRequestMethod;
+  urlParams?: Record<string, string>;
+  urlParam?: { name: string; value: string | number };
+  requestParams?: RequestInit;
+  body?: unknown;
+  errorMessageId?: string;
+}
+
+interface ApiResponse<T> {
+  data: T | null;
+}
+
+export function useApi<T>() {
+  const { setIsLoading } = useLoadingState();
+  const { addStatusMessagesItem } = useStatusState();
+  const [state, setState] = useState<ApiResponse<T>>({
+    data: null,
+  });
+
+  const makeRequest = useCallback(
+    async ({ url, method = 'GET', urlParams, urlParam, requestParams, body, errorMessageId }: RequestConfig) => {
+      setIsLoading(true);
+
+      try {
+        const finalUrl = BaseApi.generateUrl(url, urlParam);
+
+        const response = await BaseApi.getJson({
+          url: finalUrl,
+          urlParams,
+          requestParams: {
+            method,
+            headers: { 'content-type': 'application/json' },
+            ...requestParams,
+            ...(typeof body === 'object' && body !== null ? { body: JSON.stringify(body, null, 2) } : {}),
+          },
+        });
+
+        setState({ data: response });
+
+        return response;
+      } catch (error) {
+        addStatusMessagesItem?.(
+          UserNotificationFactory.createMessage(StatusType.error, errorMessageId ?? 'ld.errorMakingApiRequest'),
+        );
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [],
+  );
+
+  return {
+    ...state,
+    makeRequest,
+  };
+}

src/common/hooks/useComplexLookup.ts

@@ -1,33 +1,42 @@
 import { ChangeEvent, useCallback, useState } from 'react';
 import {
   generateEmptyValueUuid,
+  generateValidationRequestBody,
   getLinkedField,
   getUpdatedSelectedEntries,
   updateLinkedFieldValue,
 } from '@common/helpers/complexLookup.helper';
 import { __MOCK_URI_CHANGE_WHEN_IMPLEMENTING } from '@common/constants/complexLookup.constants';
 import { AdvancedFieldType } from '@common/constants/uiControls.constants';
+import { useInputsState, useMarcPreviewState, useProfileState, useStatusState, useUIState } from '@src/store';
+import { UserNotificationFactory } from '@common/services/userNotification';
+import { StatusType } from '@common/constants/status.constants';
+import { AUTHORITY_ASSIGNMENT_CHECK_API_ENDPOINT } from '@common/constants/api.constants';
 import { useModalControls } from './useModalControls';
 import { useMarcData } from './useMarcData';
 import { useServicesContext } from './useServicesContext';
-import { useInputsState, useMarcPreviewState, useProfileState, useUIState } from '@src/store';
+import { useApi } from './useApi';
+import { useComplexLookupValidation } from './useComplexLookupValidation';
 
 export const useComplexLookup = ({
   entry,
   value,
   lookupConfig,
+  baseLabelType = 'creator',
   onChange,
 }: {
   entry: SchemaEntry;
   value?: UserValueContents[];
   lookupConfig: ComplexLookupsConfigEntry;
+  baseLabelType?: string;
   onChange: (uuid: string, contents: Array<UserValueContents>) => void;
 }) => {
   const { selectedEntriesService } = useServicesContext() as Required<ServicesParams>;
   const [localValue, setLocalValue] = useState<UserValueContents[]>(value || []);
   const { schema } = useProfileState();
   const { selectedEntries, setSelectedEntries } = useInputsState();
   const {
+    complexValue,
     setComplexValue,
     resetComplexValue: resetMarcPreviewData,
     metadata: marcPreviewMetadata,
@@ -38,6 +47,9 @@ export const useComplexLookup = ({
   const { fetchMarcData } = useMarcData(setComplexValue);
   const { uuid, linkedEntry } = entry;
   const linkedField = getLinkedField({ schema, linkedEntry });
+  const { makeRequest } = useApi();
+  const { addStatusMessagesItem } = useStatusState();
+  const { addFailedEntryId, clearFailedEntryIds } = useComplexLookupValidation();
 
   const handleDelete = (id?: string) => {
     onChange(uuid, []);
@@ -56,20 +68,37 @@ export const useComplexLookup = ({
   };
 
   const closeModal = useCallback(() => {
+    clearFailedEntryIds();
     setIsModalOpen(false);
   }, []);
 
-  const handleAssign = async ({ id, title, linkedFieldValue }: ComplexLookupAssignRecordDTO) => {
-    let srsId;
+  const reset = () => {
+    resetMarcPreviewData();
+    resetMarcPreviewMetadata();
+    resetIsMarcPreviewOpen();
+  };
 
-    if (marcPreviewMetadata?.baseId === id) {
-      srsId = marcPreviewMetadata.srsId;
-    } else {
-      const marcData = await fetchMarcData(id, lookupConfig.api.endpoints.marcPreview);
+  const validateMarcRecord = (marcData: MarcDTO | null) => {
+    const { endpoints, validationTarget } = lookupConfig.api;
 
-      srsId = marcData?.matchedId;
-    }
+    return makeRequest({
+      url: endpoints.validation ?? AUTHORITY_ASSIGNMENT_CHECK_API_ENDPOINT,
+      method: 'POST',
+      body: generateValidationRequestBody(marcData, validationTarget?.[baseLabelType]),
+    });
+  };
 
+  const assignMarcRecord = ({
+    id,
+    title,
+    srsId,
+    linkedFieldValue,
+  }: {
+    id: string;
+    title: string;
+    srsId?: string;
+    linkedFieldValue?: string;
+  }) => {
     const newValue = {
       id,
       label: title,
@@ -95,11 +124,37 @@ export const useComplexLookup = ({
 
       setSelectedEntries(updatedSelectedEntries);
     }
+  };
 
-    resetMarcPreviewData();
-    resetMarcPreviewMetadata();
-    resetIsMarcPreviewOpen();
-    closeModal();
+  const handleAssign = async ({ id, title, linkedFieldValue }: ComplexLookupAssignRecordDTO) => {
+    let srsId;
+    let marcData = complexValue;
+
+    if (marcPreviewMetadata?.baseId === id) {
+      srsId = marcPreviewMetadata.srsId;
+    } else {
+      const response = await fetchMarcData(id, lookupConfig.api.endpoints.marcPreview);
+
+      if (response) {
+        marcData = response;
+        srsId = marcData?.matchedId;
+      }
+    }
+
+    const isValid = await validateMarcRecord(marcData);
+
+    if (isValid) {
+      assignMarcRecord({ id, title, srsId, linkedFieldValue });
+      clearFailedEntryIds();
+      reset();
+      closeModal();
+    } else {
+      addFailedEntryId(id);
+
+      addStatusMessagesItem?.(
+        UserNotificationFactory.createMessage(StatusType.error, 'ld.errorValidatingAuthorityRecord'),
+      );
+    }
   };
 
   const handleOnChangeBase = ({ target: { value } }: ChangeEvent<HTMLInputElement>) => {

src/common/hooks/useComplexLookupSearchResults.ts

@@ -4,6 +4,7 @@ import { type Row } from '@components/Table';
 import { useSearchContext } from '@common/hooks/useSearchContext';
 import { ComplexLookupSearchResultsProps } from '@components/ComplexLookupField/ComplexLookupSearchResults';
 import { useSearchState } from '@src/store';
+import { useComplexLookupValidation } from './useComplexLookupValidation';
 
 export const useComplexLookupSearchResults = ({
   onTitleClick,
@@ -13,6 +14,7 @@ export const useComplexLookupSearchResults = ({
   const { onAssignRecord } = useSearchContext();
   const { data, sourceData } = useSearchState();
   const { formatMessage } = useIntl();
+  const { checkFailedId } = useComplexLookupValidation();
 
   const applyActionItems = useCallback(
     (rows: Row[]): Row[] =>
@@ -23,7 +25,13 @@ export const useComplexLookupSearchResults = ({
           formattedRow[key] = {
             ...row[key],
             children: column.formatter
-              ? column.formatter({ row, formatMessage, onAssign: onAssignRecord, onTitleClick })
+              ? column.formatter({
+                  row,
+                  formatMessage,
+                  onAssign: onAssignRecord,
+                  onTitleClick,
+                  checkFailedId,
+                })
               : row[key].label,
           };
         });

src/common/hooks/useComplexLookupValidation.ts

@@ -0,0 +1,25 @@
+import { useComplexLookupState } from '@src/store';
+
+export const useComplexLookupValidation = () => {
+  const {
+    authorityAssignmentCheckFailedIds,
+    addAuthorityAssignmentCheckFailedIdsItem,
+    resetAuthorityAssignmentCheckFailedIds,
+  } = useComplexLookupState();
+
+  const addFailedEntryId = (id: string) => {
+    addAuthorityAssignmentCheckFailedIdsItem?.(id);
+  };
+
+  const clearFailedEntryIds = () => {
+    resetAuthorityAssignmentCheckFailedIds();
+  };
+
+  const checkFailedId = (id?: string) => {
+    if (!id) return false;
+
+    return authorityAssignmentCheckFailedIds.includes(id);
+  };
+
+  return { addFailedEntryId, clearFailedEntryIds, checkFailedId };
+};

src/components/ComplexLookupField/ComplexLookupField.tsx

@@ -30,6 +30,7 @@ export const ComplexLookupField: FC<Props> = ({ value = undefined, id, entry, on
       entry,
       value,
       lookupConfig,
+      baseLabelType: layout?.baseLabelType,
       onChange,
     });
 

src/components/ComplexLookupField/MarcPreviewComplexLookup.tsx

@@ -1,6 +1,7 @@
 import { FC } from 'react';
 import { FormattedDate, FormattedMessage, useIntl } from 'react-intl';
 import { useSearchContext } from '@common/hooks/useSearchContext';
+import { useComplexLookupValidation } from '@common/hooks/useComplexLookupValidation';
 import { useMarcPreviewState, useUIState } from '@src/store';
 import { SearchControlPane } from '@components/SearchControlPane';
 import { MarcContent } from '@components/MarcContent';
@@ -17,6 +18,7 @@ export const MarcPreviewComplexLookup: FC<MarcPreviewComplexLookupProps> = ({ on
   const { formatMessage } = useIntl();
   const { isMarcPreviewOpen } = useUIState();
   const { complexValue: marcPreviewData, metadata: marcPreviewMetadata } = useMarcPreviewState();
+  const { checkFailedId } = useComplexLookupValidation();
 
   const renderCloseButton = () => (
     <Button
@@ -41,18 +43,20 @@ export const MarcPreviewComplexLookup: FC<MarcPreviewComplexLookupProps> = ({ on
 
   const onClickAssignButton = () => {
     onAssignRecord?.({
-      id: marcPreviewMetadata?.baseId || '',
-      title: marcPreviewMetadata?.title || '',
-      linkedFieldValue: marcPreviewMetadata?.headingType || '',
+      id: marcPreviewMetadata?.baseId ?? '',
+      title: marcPreviewMetadata?.title ?? '',
+      linkedFieldValue: marcPreviewMetadata?.headingType ?? '',
     });
   };
 
+  const isDisabledButton = checkFailedId(marcPreviewMetadata?.baseId);
+
   return (
     <>
       {isMarcPreviewOpen && marcPreviewData ? (
         <div className="marc-preview-container">
           <SearchControlPane
-            label={marcPreviewMetadata?.title || ''}
+            label={marcPreviewMetadata?.title ?? ''}
             renderSubLabel={renderSubLabel}
             renderCloseButton={renderCloseButton}
           >
@@ -61,6 +65,7 @@ export const MarcPreviewComplexLookup: FC<MarcPreviewComplexLookupProps> = ({ on
                 type={ButtonType.Highlighted}
                 onClick={onClickAssignButton}
                 ariaLabel={formatMessage({ id: 'ld.aria.marcAuthorityPreview.close' })}
+                disabled={isDisabledButton}
               >
                 <FormattedMessage id="ld.assign" />
               </Button>

src/components/ComplexLookupField/configs/Authorities.tsx

@@ -16,18 +16,18 @@ export const authoritiesTableConfig: SearchResultsTableConfig = {
     },
     title: {
       label: 'ld.headingReference',
-      position: 1,
+      position: 2,
       className: 'cell-fixed cell-fixed-370',
       formatter: TitleFormatter,
     },
     subclass: {
       label: 'ld.typeOfHeading',
-      position: 2,
+      position: 3,
       className: 'cell-fixed cell-fixed-140',
     },
     authoritySource: {
       label: 'ld.authoritySource',
-      position: 3,
+      position: 4,
       className: 'cell-fixed cell-fixed-250',
     },
   },

src/components/ComplexLookupField/formatters/Assign.tsx

@@ -5,11 +5,14 @@ import { Button, ButtonType } from '@components/Button';
 export const AssignFormatter = ({
   row,
   onAssign,
+  checkFailedId,
 }: {
   row: SearchResultsTableRow;
   onAssign: ({ id, title, linkedFieldValue }: ComplexLookupAssignRecordDTO) => void;
+  checkFailedId: (id: string) => boolean;
 }) => {
   const isAuthorized = row.authorized.label === AuthRefType.Authorized;
+  const isDisabled = checkFailedId(row.__meta.id);
 
   return isAuthorized ? (
     <Button
@@ -22,6 +25,7 @@ export const AssignFormatter = ({
         })
       }
       data-testid={`assign-button-${row.__meta.id}`}
+      disabled={isDisabled}
     >
       <FormattedMessage id="ld.assign" />
     </Button>