Merged in task/dspace-cris-2023_02_x/DSC-2599 (pull request DSpace#3828)

FrancescoMolinaro · Andrea Barbasso · commit 5f03a061b2b4 · 2026-04-22T10:32:52.000Z
Task/dspace cris 2023 02 x/DSC-2599

Approved-by: Andrea Barbasso
diff --git a/src/app/shared/form/form.component.ts b/src/app/shared/form/form.component.ts
@@ -194,55 +194,74 @@ export class FormComponent implements OnDestroy, OnInit {
       this.formService.getForm(this.formId).pipe(
         filter((formState: FormEntry) => !!formState && (isNotEmpty(formState.errors) || isNotEmpty(this.formErrors))),
         map((formState) => formState.errors),
-        distinctUntilChanged())
-        .subscribe((errors: FormError[]) => {
-          const { formGroup, formModel } = this;
-          errors
-            .filter((error: FormError) => findIndex(this.formErrors, {
-              fieldId: error.fieldId,
-              fieldIndex: error.fieldIndex
-            }) === -1)
-            .forEach((error: FormError) => {
-              const { fieldId } = error;
-              const { fieldIndex } = error;
-              let field: AbstractControl;
-              if (!!this.parentFormModel) {
-                field = this.formBuilderService.getFormControlById(fieldId, formGroup.parent as UntypedFormGroup, formModel, fieldIndex);
-              } else {
-                field = this.formBuilderService.getFormControlById(fieldId, formGroup, formModel, fieldIndex);
-              }
+        distinctUntilChanged(),
+      ).subscribe((errors: FormError[]) => {
+        const { formGroup, formModel } = this;
+
+        const prevMap = new Map<string, FormError>(
+          this.formErrors.map(e => [`${e.fieldId}:${e.fieldIndex}`, e]),
+        );
+        const nextMap = new Map<string, FormError>(
+          errors.map(e => [`${e.fieldId}:${e.fieldIndex}`, e]),
+        );
+
+        if (isEqual(prevMap, nextMap)) {
+          return;
+        }
 
-              if (field) {
-                const modelArrayIndex = fieldIndex > 0 ? fieldIndex : null;
-                const model: DynamicFormControlModel = this.formBuilderService.findById(fieldId, formModel, modelArrayIndex);
-                this.formService.addErrorToField(field, model, error.message);
-                this.changeDetectorRef.detectChanges();
-              }
-            });
-
-          this.formErrors
-            .filter((error: FormError) => findIndex(errors, {
-              fieldId: error.fieldId,
-              fieldIndex: error.fieldIndex
-            }) === -1)
-            .forEach((error: FormError) => {
-              const { fieldId } = error;
-              const { fieldIndex } = error;
-              let field: AbstractControl;
-              if (!!this.parentFormModel) {
-                field = this.formBuilderService.getFormControlById(fieldId, formGroup.parent as UntypedFormGroup, formModel, fieldIndex);
-              } else {
-                field = this.formBuilderService.getFormControlById(fieldId, formGroup, formModel, fieldIndex);
+        const getControl = (err: FormError): AbstractControl | null => {
+          return this.parentFormModel
+            ? this.formBuilderService.getFormControlById(err.fieldId, formGroup.parent as UntypedFormGroup, formModel, err.fieldIndex)
+            : this.formBuilderService.getFormControlById(err.fieldId, formGroup, formModel, err.fieldIndex);
+        };
+
+        const getModel = (err: FormError): DynamicFormControlModel => {
+          const modelArrayIndex = err.fieldIndex > 0 ? err.fieldIndex : null;
+          return this.formBuilderService.findById(err.fieldId, formModel, modelArrayIndex);
+        };
+        // Add or change (including revert) errors
+        errors.forEach(next => {
+          const key = `${next.fieldId}:${next.fieldIndex}`;
+          const prev = prevMap.get(key);
+          if (!prev || prev.message !== next.message) {
+            // Remove old message if changed
+            if (prev) {
+              const prevControl = getControl(prev);
+              if (prevControl) {
+                const prevModel = getModel(prev);
+                this.formService.removeErrorFromField(prevControl, prevModel, prev.message);
+                this.formService.removeError(this.formId, prev.fieldId, prev.fieldIndex);
+                this.formErrors.splice(findIndex(this.formErrors, prev), 1);
               }
+            }
+            // Add new message
+            const control = getControl(next);
+            if (control) {
+              const model = getModel(next);
+              this.formService.addErrorToField(control, model, next.message);
+              this.formErrors.push(next);
+            }
+          }
+        });
+
+        const removedErrors: FormError[] = [];
+        // Remove errors for fields no longer present
+        this.formErrors.forEach(prev => {
+          const key = `${prev.fieldId}:${prev.fieldIndex}`;
+          if (!nextMap.has(key) && prevMap.has(key)) {
+            const control = getControl(prev);
+            if (control) {
+              const model = getModel(prev);
+              this.formService.removeErrorFromField(control, model, prev.message);
+              this.formService.removeError(this.formId, prev.fieldId, prev.fieldIndex);
+              removedErrors.push(prev);
+            }
+          }
+        });
 
-              if (field) {
-                const model: DynamicFormControlModel = this.formBuilderService.findById(fieldId, formModel);
-                this.formService.removeErrorFromField(field, model, error.message);
-              }
-            });
-          this.formErrors = errors;
-          this.changeDetectorRef.detectChanges();
-        })
+        this.formErrors = this.formErrors.filter(error => !removedErrors.includes(error));
+        this.changeDetectorRef.detectChanges();
+      }),
     );
   }
 
diff --git a/src/app/shared/form/form.service.spec.ts b/src/app/shared/form/form.service.spec.ts
@@ -10,6 +10,7 @@ import { AppState } from '../../app.reducer';
 import { formReducer } from './form.reducer';
 import { getMockFormBuilderService } from '../mocks/form-builder-service.mock';
 import { DynamicConcatModel } from './builder/ds-dynamic-form-ui/models/ds-dynamic-concat.model';
+import { getMockTranslateService } from '../mocks/translate.service.mock';
 
 describe('FormService test suite', () => {
   const config = {
@@ -24,6 +25,7 @@ describe('FormService test suite', () => {
   let service: FormService;
   let builderService: FormBuilderService;
   let formGroup: UntypedFormGroup;
+  const translateService = getMockTranslateService();
 
   const formModel: DynamicFormControlModel[] = [
     new DynamicInputModel({ id: 'author', value: 'test' }),
@@ -129,10 +131,10 @@ describe('FormService test suite', () => {
         name_CONCAT_SECOND_INPUT: new FormControl(undefined)
       });
 
-      formGroup = new UntypedFormGroup({ author, title, date, description, addressLocation, name });
-      controls = { author, title, date, description , addressLocation, name };
-      service = new FormService(builderService, store);
-    })
+    formGroup = new UntypedFormGroup({ author, title, date, description, addressLocation, name });
+    controls = { author, title, date, description , addressLocation, name };
+    service = new FormService(builderService, store, translateService);
+  }),
   )
   ;
 
@@ -226,6 +228,17 @@ describe('FormService test suite', () => {
 
   });
 
+  it('should show correct error message if a different error is already present in the field and a new is added', () => {
+    let control = controls.description;
+    let model = formModel.find((mdl: DynamicFormControlModel) => mdl.id === 'description');
+
+    service.addErrorToField(control, model, 'error.test.message');
+    service.addErrorToField(control, model, 'error.test.newMessage');
+    service.removeErrorFromField(control, model, 'error.test.message');
+
+    expect(control.errors).toEqual({ newMessage: true });
+  });
+
   it('should remove error from field', () => {
     let control = controls.description;
     let model = formModel.find((mdl: DynamicFormControlModel) => mdl.id === 'description');
@@ -249,7 +262,7 @@ describe('FormService test suite', () => {
 
     service.removeErrorFromField(control, model, 'error.required');
 
-    expect(control.errors).toBeNull();
+    expect(control.errors).toEqual(null);
   });
 
   it('should remove errors from fields of concat group', () => {
@@ -258,8 +271,8 @@ describe('FormService test suite', () => {
     let control = controls.name;
     let model = formModel.find((mdl: DynamicFormControlModel) => mdl.id === 'name_CONCAT_GROUP');
     let errorKeys: string[];
-
-    service.addErrorToField(control, model, 'Test error message');
+    const messageKey = 'Test error message';
+    service.addErrorToField(control, model, messageKey);
     errorKeys = Object.keys(control.errors);
 
     service.removeErrorFromField(control, model, errorKeys[0]);
@@ -271,7 +284,7 @@ describe('FormService test suite', () => {
 
     // the group's inputs should no longer have an error
     Object.values(control.controls).forEach((subControl: AbstractControl) => {
-      expect(control.errors).toBeNull();
+      expect(control.errors).toEqual(null);
     });
   });
 
diff --git a/src/app/shared/form/form.service.ts b/src/app/shared/form/form.service.ts
@@ -8,7 +8,7 @@ import { AppState } from '../../app.reducer';
 import { formObjectFromIdSelector } from './selectors';
 import { FormBuilderService } from './builder/form-builder.service';
 import { DynamicFormControlEvent, DynamicFormControlModel, DynamicFormGroupModel } from '@ng-dynamic-forms/core';
-import { isEmpty, isNotUndefined } from '../empty.util';
+import { hasValue, isEmpty, isNotUndefined } from '../empty.util';
 import uniqueId from 'lodash/uniqueId';
 import {
   FormAddError,
@@ -22,13 +22,15 @@ import {
 import { FormEntry, FormError, FormTouchedState } from './form.reducer';
 import { environment } from '../../../environments/environment';
 import { DynamicLinkModel } from './builder/ds-dynamic-form-ui/models/ds-dynamic-link.model';
+import { TranslateService } from '@ngx-translate/core';
 
 @Injectable()
 export class FormService {
 
   constructor(
     private formBuilderService: FormBuilderService,
-    private store: Store<AppState>) {
+    private store: Store<AppState>,
+    private translateService: TranslateService) {
   }
 
   /**
@@ -136,15 +138,19 @@ export class FormService {
     }
     const errors: string[] = Object.keys(field.errors)
       .filter((errorKey) => field.errors[errorKey] === true)
-      .map((errorKey) => `error.validation.${errorKey}`);
+      .map((errorKey) => {
+        const defaultErrorKey = `error.validation.${errorKey}`;
+        const customErrorKey = `error.validation.${formId}.${errorKey}`;
+        const hasDefaultLabel = this.translateService.instant(defaultErrorKey) !== defaultErrorKey;
+        return hasDefaultLabel ? defaultErrorKey : customErrorKey;
+      });
     errors.forEach((error) => this.addError(formId, fieldId, fieldIndex, error));
   }
 
   public addErrorToField(field: AbstractControl, model: DynamicFormControlModel, message: string) {
 
     const error = {}; // create the error object
     const errorKey = this.getValidatorNameFromMap(message);
-    let errorMsg = message;
 
     // if form control model has no errorMessages object, create it
     if (!model.errorMessages) {
@@ -155,11 +161,7 @@ export class FormService {
     if (isEmpty(model.errorMessages[errorKey])) {
       // put the error message in the form control model
       model.errorMessages[errorKey] = message;
-    } else {
-      // Use correct error messages from the model
-      errorMsg = model.errorMessages[errorKey];
     }
-
     if (!field.hasError(errorKey)) {
       error[errorKey] = true;
       // add the error in the form control
@@ -182,10 +184,10 @@ export class FormService {
   public removeErrorFromField(field: AbstractControl, model: DynamicFormControlModel, messageKey: string) {
     const error = {};
     const errorKey = this.getValidatorNameFromMap(messageKey);
-
     if (field.hasError(errorKey)) {
       error[errorKey] = null;
-      field.setErrors(error);
+      const updatedError = { ...field.errors, ...error };
+      field.setErrors(updatedError);
       field.clearValidators();
       field.updateValueAndValidity();
     }
@@ -199,7 +201,13 @@ export class FormService {
       });
     }
 
-    field.markAsUntouched();
+    const currentErrors = field.errors;
+    const hasDifferentErrors = hasValue(currentErrors) && Object.keys(currentErrors).filter((key) => currentErrors[key]).length > 0;
+
+    if (!hasDifferentErrors) {
+      field.markAsUntouched();
+    }
+
   }
 
   public resetForm(formGroup: UntypedFormGroup, groupModel: DynamicFormControlModel[], formId: string) {
