[AAE-8086] Remove form rules events that kill performance (#7583)

* [AAE-8086] Remove form rules events that kill performance

* [AAE-8086] Handle form loaded event in form rules

lib/core/form/models/form-rules.model.spec.ts

@@ -22,6 +22,10 @@ import { TranslateModule } from '@ngx-translate/core';
 import { ByPassFormRuleManager, FormRulesManager, formRulesManagerFactory, FORM_RULES_MANAGER } from '../models/form-rules.model';
 import { Injector } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
+import { FormModel } from '../components/widgets/core/form.model';
+import { FormRulesEvent } from '../events/form-rules.event';
+import { FormEvent } from '../events/form.event';
+import { FormService } from '../services/form.service';
 
 class CustomRuleManager extends FormRulesManager<any> {
     protected getRules() {
@@ -37,6 +41,7 @@ describe('Form Rules', () => {
 
     let injector: Injector;
     const customRuleManager = new CustomRuleManager(null);
+    let formService: FormService;
 
     describe('Injection token provided', () => {
         setupTestBed({
@@ -55,6 +60,7 @@ describe('Form Rules', () => {
 
         beforeEach(() => {
             injector = TestBed.inject(Injector);
+            formService = TestBed.inject(FormService);
         });
 
         it('factory function should not return bypass service', () => {
@@ -69,9 +75,29 @@ describe('Form Rules', () => {
             rulesManager.initialize(null);
             expect(customRuleManager.initialize).toHaveBeenCalled();
         });
+
+        it('should send the form loaded event when initialized', async (done) => {
+            const rulesManager = new CustomRuleManager(formService);
+            const getRulesSpy = spyOn<any>(rulesManager, 'getRules').and.returnValue({});
+            const formModel = new FormModel({ id: 'mock' }, {}, false);
+            const formEvent = new FormEvent(formModel);
+            const event = new FormRulesEvent('formLoaded', formEvent);
+
+            formService.formRulesEvent.subscribe(formRulesEvent => {
+                expect(formRulesEvent).toEqual(event);
+                done();
+            });
+
+            rulesManager.initialize(formModel);
+            expect(getRulesSpy).toHaveBeenCalled();
+        });
     });
 
     describe('Injection token not provided', () => {
+        let formModel: FormModel;
+        let rulesManager: FormRulesManager<any>;
+        let getRulesSpy: jasmine.Spy;
+
         setupTestBed({
             imports: [
                 TranslateModule.forRoot(),
@@ -82,12 +108,28 @@ describe('Form Rules', () => {
 
         beforeEach(() => {
             injector = TestBed.inject(Injector);
+            rulesManager = formRulesManagerFactory<any>(injector);
+            getRulesSpy = spyOn<any>(rulesManager, 'getRules');
         });
 
         it('factory function should return bypass service', () => {
-            const rulesManager = formRulesManagerFactory<any>(injector);
-
             expect(rulesManager instanceof ByPassFormRuleManager).toBeTruthy();
         });
+
+        it('should get rules when form is not readonly', () => {
+            formModel = new FormModel({}, {}, false);
+
+            rulesManager.initialize(formModel);
+
+            expect(getRulesSpy).toHaveBeenCalled();
+        });
+
+        it('should not get rules when form is readonly', () => {
+            formModel = new FormModel({}, {}, true);
+
+            rulesManager.initialize(formModel);
+
+            expect(getRulesSpy).not.toHaveBeenCalled();
+        });
     });
 });

lib/core/form/models/form-rules.model.ts

@@ -18,6 +18,7 @@
 import { InjectionToken, Injector } from '@angular/core';
 import { Subject } from 'rxjs';
 import { filter, takeUntil } from 'rxjs/operators';
+import { FormEvent } from '../events';
 import { FormRulesEvent } from '../events/form-rules.event';
 import { FormModel, FormService } from '../public-api';
 
@@ -45,16 +46,21 @@ export abstract class FormRulesManager<T> {
         }
 
         this.formModel = formModel;
-        const rules = this.getRules();
 
-        if (!!rules) {
+        if (!this.formModel.readOnly) {
-            this.formService.formRulesEvent
+            const rules = this.getRules();
-                .pipe(
+
-                    filter(event => !!event.form.id && event.form.id === formModel?.id),
+            if (!!rules) {
-                    takeUntil(this.onDestroy$)
+                this.formService.formRulesEvent
-                ).subscribe(event => {
+                    .pipe(
-                    this.handleRuleEvent(event, rules);
+                        filter(event => !!event.form.id && event.form.id === formModel?.id),
-                });
+                        takeUntil(this.onDestroy$)
+                    ).subscribe(event => {
+                        this.handleRuleEvent(event, rules);
+                    });
+
+                this.formService.formRulesEvent.next(new FormRulesEvent('formLoaded', new FormEvent(formModel)));
+            }
         }
 
         this.initialized = true;

lib/core/form/services/form.service.spec.ts

@@ -21,9 +21,6 @@ import { FormService } from './form.service';
 import { setupTestBed } from '../../testing/setup-test-bed';
 import { CoreTestingModule } from '../../testing/core.testing.module';
 import { TranslateModule } from '@ngx-translate/core';
-import { FormEvent, ValidateDynamicTableRowEvent, ValidateFormEvent, ValidateFormFieldEvent } from '../events';
-import { take } from 'rxjs/operators';
-import { FormModel } from '../components/widgets/core/form.model';
 
 declare let jasmine: any;
 
@@ -412,68 +409,4 @@ describe('Form service', () => {
             });
         });
     });
-
-    describe('Form rules', () => {
-        const event = new FormEvent('mock');
-
-        it('should emit the formLoaded in the formRulesEvent observable', async(done) => {
-            service.formRulesEvent.pipe(take(1)).subscribe(formRuleEvent => {
-                expect(formRuleEvent.event).toBeFalsy();
-                expect(formRuleEvent.field).toBeFalsy();
-                expect(formRuleEvent.form).toEqual('mock');
-                expect(formRuleEvent.type).toEqual('formLoaded');
-                done();
-            });
-
-            service.formLoaded.next(event);
-        });
-
-        it('should emit the formDataRefreshed in the formRulesEvent observable', async(done) => {
-            service.formRulesEvent.pipe(take(1)).subscribe(formRuleEvent => {
-                expect(formRuleEvent.event).toBeFalsy();
-                expect(formRuleEvent.field).toBeFalsy();
-                expect(formRuleEvent.form).toEqual('mock');
-                expect(formRuleEvent.type).toEqual('formDataRefreshed');
-                done();
-            });
-
-            service.formDataRefreshed.next(event);
-        });
-
-        it('should emit the formValidated in the formRulesEvent observable', async(done) => {
-            service.formRulesEvent.pipe(take(1)).subscribe(formRuleEvent => {
-                expect(formRuleEvent.event).toBeFalsy();
-                expect(formRuleEvent.field).toBeFalsy();
-                expect(formRuleEvent.form).toEqual('mock');
-                expect(formRuleEvent.type).toEqual('formValidated');
-                done();
-            });
-
-            service.validateForm.next(new ValidateFormEvent('mock'));
-        });
-
-        it('should emit the fieldValidated in the formRulesEvent observable', async(done) => {
-            service.formRulesEvent.pipe(take(1)).subscribe(formRuleEvent => {
-                expect(formRuleEvent.event).toBeFalsy();
-                expect(formRuleEvent.field).toBeFalsy();
-                expect(formRuleEvent.form).toEqual('mock');
-                expect(formRuleEvent.type).toEqual('fieldValidated');
-                done();
-            });
-
-            service.validateFormField.next(new ValidateFormFieldEvent('mock', null));
-        });
-
-        it('should emit the fieldDynamicTableRowValidated in the formRulesEvent observable', async(done) => {
-            service.formRulesEvent.pipe(take(1)).subscribe(formRuleEvent => {
-                expect(formRuleEvent.event).toBeFalsy();
-                expect(formRuleEvent.field).toBeFalsy();
-                expect(formRuleEvent.form).toEqual('mock');
-                expect(formRuleEvent.type).toEqual('fieldDynamicTableRowValidated');
-                done();
-            });
-
-            service.validateDynamicTableRow.next(new ValidateDynamicTableRowEvent('mock' as unknown as FormModel, null, null, null));
-        });
-    });
 });

lib/core/form/services/form.service.ts

@@ -136,12 +136,6 @@ export class FormService implements FormValidationService {
     constructor(private ecmModelService: EcmModelService,
                 private apiService: AlfrescoApiService,
                 protected logService: LogService) {
-
-        this.formLoaded.subscribe(event => this.formRulesEvent.next(new FormRulesEvent('formLoaded', event)));
-        this.formDataRefreshed.subscribe(event => this.formRulesEvent.next(new FormRulesEvent('formDataRefreshed', event)));
-        this.validateForm.subscribe(event => this.formRulesEvent.next(new FormRulesEvent('formValidated', event)));
-        this.validateFormField.subscribe(event => this.formRulesEvent.next(new FormRulesEvent('fieldValidated', event)));
-        this.validateDynamicTableRow.subscribe(event => this.formRulesEvent.next(new FormRulesEvent('fieldDynamicTableRowValidated', event)));
     }
 
     /**