@sumaris-net/ngx-components 2.0.0-rc3 → 2.0.0-rc30

package/esm2020/src/app/core/form/entity/entity-editor-modal.class.mjs

@@ -0,0 +1,421 @@
+import { ChangeDetectorRef, Directive, Input, Optional } from '@angular/core';
+import { Router } from '@angular/router';
+import { AlertController, ModalController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { LocalSettingsService } from '../../services/local-settings.service';
+import { AppTabEditor, AppTabEditorOptions } from './editor.class';
+import { AppFormUtils } from '../form.utils';
+import { Alerts } from '../../../shared/alerts';
+import { ErrorCodes } from '../../services/errors';
+import { isNil, isNotNil, isNotNilOrBlank } from '../../../shared/functions';
+import { DateFormatPipe } from '../../../shared/pipes/date-format.pipe';
+import { ENVIRONMENT } from '../../../../environments/environment.class';
+import { waitForFalse } from '../../../shared/observables';
+import { FormErrorTranslator } from '../../../shared/validator/form-error-adapter.class';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class AppEntityEditorModalOptions extends AppTabEditorOptions {
+}
+// @dynamic
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class AppEntityEditorModal extends AppTabEditor {
+    constructor(injector, dataType, options) {
+        super(null, injector.get(Router), injector.get(AlertController), injector.get(TranslateService), options);
+        this.dataType = dataType;
+        this.savingSubject = new BehaviorSubject(false);
+        this.$title = new Subject();
+        this.i18nSuffix = null;
+        this.environement = injector.get(ENVIRONMENT);
+        options = {
+            // Default options
+            i18nPrefix: '',
+            // Override defaults
+            ...options
+        };
+        this.queryTabIndexParamName = undefined; // Important: avoid query parameter changed
+        this.settings = injector.get(LocalSettingsService);
+        this.errorTranslator = injector.get(FormErrorTranslator);
+        this.cd = injector.get(ChangeDetectorRef);
+        this.dateFormat = injector.get(DateFormatPipe);
+        this.modalCtrl = injector.get(ModalController);
+        this.i18nContext = {
+            prefix: options.i18nPrefix,
+            suffix: this.i18nSuffix || ''
+        };
+        // FOR DEV ONLY ----
+        //this.debug = !environment.production;
+    }
+    set isNew(value) {
+        this._isNew = value;
+    }
+    get isNew() {
+        return isNotNil(this._isNew) ? this._isNew : isNil(this.data?.id);
+    }
+    /**
+     * @deprecated use isNew instead
+     */
+    get isNewData() {
+        return this.isNew;
+    }
+    /**
+     * @deprecated use isNew instead
+     */
+    set isNewData(value) {
+        this.isNew = value;
+    }
+    set disabled(value) {
+        this._enabled = !value;
+    }
+    get disabled() {
+        return !this._enabled;
+    }
+    get isOnFieldMode() {
+        return this.settings.isOnFieldMode(this._usageMode);
+    }
+    get saving() {
+        return this.savingSubject.value;
+    }
+    markAsSaving(opts) {
+        if (this.savingSubject.value !== true) {
+            this.savingSubject.next(true);
+            if (!opts || opts.emitEvent !== false)
+                this.markForCheck();
+        }
+    }
+    markAsSaved(opts) {
+        if (this.savingSubject.value !== false) {
+            this.savingSubject.next(false);
+            if (!opts || opts.emitEvent !== false)
+                this.markForCheck();
+        }
+    }
+    ngOnInit() {
+        // Default values
+        this.mobile = isNotNil(this.mobile) ? this.mobile : this.settings.mobile;
+        super.ngOnInit();
+        // Register forms
+        this.registerForms();
+        // Disable
+        if (this.disabled)
+            this.disable();
+        if (this.isNewData) {
+            // Update the title.
+            this.updateTitle();
+        }
+        else {
+            // Update title each time value changes
+            this.registerSubscription(this.form.valueChanges
+                .pipe(debounceTime(250))
+                .subscribe(json => this.updateTitle(json)));
+        }
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.onAfterModalInit) {
+            Promise.resolve(this.onAfterModalInit(this))
+                .then(() => this.load());
+        }
+        else {
+            // Use a timeout to avoid error 'NG0100: ExpressionChangedAfterItHasBeenCheckedError'
+            setTimeout(() => this.load());
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.$title.complete();
+        this.$title.unsubscribe();
+        this.savingSubject.unsubscribe();
+    }
+    waitIdle(opts) {
+        // Wait end of saving
+        if (this.saving)
+            return waitForFalse(this.savingSubject);
+        return super.waitIdle(opts);
+    }
+    async load() {
+        this.markAsReady();
+        this.markAsLoading();
+        try {
+            await this.updateView(this.data);
+        }
+        catch (err) {
+            if (err === 'CANCELLED')
+                return;
+            this.setError(err);
+            this.selectedTabIndex = 0;
+        }
+        finally {
+            this.markAsLoaded();
+        }
+    }
+    reload() {
+        if (this.dirty) {
+            return this.load();
+        }
+    }
+    unload(opts) {
+        throw new Error("No implemented on modal");
+    }
+    async updateView(data, opts) {
+        this.resetError();
+        if (!this.data)
+            throw { code: ErrorCodes.DATA_NOT_FOUND_ERROR, message: 'ERROR.DATA_NO_FOUND' };
+        await this.setValue(data);
+        if (!opts || opts.emitEvent !== false) {
+            this.markAsPristine();
+            this.markAsUntouched();
+            this.updateViewState(data);
+            // Update the title.
+            this.updateTitle(data);
+        }
+    }
+    /**
+     * Enable or disable state
+     */
+    updateViewState(data, opts) {
+        if (this.isNewData || this.enabled) {
+            this.enable(opts);
+        }
+        else {
+            this.disable(opts);
+            // Allow to sort table
+            this.tables?.forEach(t => t.enableSort());
+        }
+    }
+    async saveAndClose(event) {
+        const data = await this.saveAndGetDataIfValid();
+        if (data) {
+            this.modalCtrl.dismiss(data);
+            return true;
+        }
+        return false;
+    }
+    async close(event) {
+        if (this.dirty) {
+            const saveBeforeLeave = await Alerts.askSaveBeforeLeave(this.alertCtrl, this.translate, event);
+            // User cancelled
+            if (isNil(saveBeforeLeave) || event && event.defaultPrevented) {
+                return;
+            }
+            // Is user confirm: close normally
+            if (saveBeforeLeave === true) {
+                await this.saveAndClose(event);
+                return;
+            }
+        }
+        await this.modalCtrl.dismiss();
+    }
+    /**
+     * Save the editor, by calling the dataService.save().
+     * Ensure that editor if valid. If not, display an error
+     * @param event
+     * @param opts
+     */
+    async save(event, opts) {
+        if (this.loading || this.saving || this.disabled) {
+            console.debug(this._logPrefix + 'Skip save: modal is busy (loading or saving)');
+            return false;
+        }
+        if (!this.dirty) {
+            console.debug(this._logPrefix + 'Skip save: modal not dirty');
+            return true;
+        }
+        // Wait end of async validation
+        await this.waitWhilePending();
+        // If invalid
+        if (this.invalid) {
+            this.logFormErrors();
+            this.setError('COMMON.FORM.HAS_ERROR');
+            this.openFirstInvalidTab();
+            this.scrollToTop();
+            this.markAllAsTouched();
+            this.submitted = true;
+            return false;
+        }
+        this.markAsSaving();
+        this.resetError();
+        if (this.debug)
+            console.debug(this._logPrefix + 'Saving data...');
+        try {
+            // Save all dirty children
+            const saved = await this.saveDirtyChildren();
+            if (!saved)
+                return false;
+            // Fill data
+            this.data = await this.getValue();
+            // Mark as submitted
+            this.submitted = true;
+            return true;
+        }
+        catch (err) {
+            this.submitted = true;
+            this.setError(err);
+            this.selectedTabIndex = 0;
+            this.scrollToTop(); // Scroll to top (to show error)
+            this.markAsDirty();
+            this.enable();
+            return false;
+        }
+        finally {
+            this.markAsSaved();
+        }
+    }
+    /**
+     * Save data (if dirty and valid), and return it. Otherwise, return nil value.
+     */
+    async saveAndGetDataIfValid() {
+        // Form is not valid
+        if (!this.valid) {
+            // Make sure validation is finished
+            await AppFormUtils.waitWhilePending(this);
+            // If invalid: Open the first tab in error
+            if (this.invalid) {
+                this.openFirstInvalidTab();
+                return undefined;
+            }
+            // Continue (valid)
+        }
+        // Form is valid, but not saved
+        if (this.dirty) {
+            const saved = await this.save(new Event('save'));
+            if (!saved)
+                return undefined;
+        }
+        // Valid and saved data
+        return this.data;
+    }
+    async delete(event) {
+        if (this.loading || this.saving)
+            return false;
+        this.markAsSaving();
+        this.resetError();
+        try {
+            // Delegate deletion to modal caller
+            if (this.onDelete) {
+                const result = await this.onDelete(event, this.data);
+                // User cancelled
+                if (isNil(result) || (event && event.defaultPrevented))
+                    return;
+                if (result) {
+                    await this.modalCtrl.dismiss(this.data, 'delete');
+                }
+            }
+            // Or dismiss, with the role 'delete'
+            else {
+                if (this.isNewData) {
+                    console.error(this._logPrefix + "Trying to delete a new data. Make no sense!");
+                }
+                await this.modalCtrl.dismiss(this.data, 'delete');
+            }
+        }
+        catch (err) {
+            this.submitted = true;
+            this.setError(err);
+            this.selectedTabIndex = 0;
+            this.markAsSaved();
+            if (this.enabled)
+                this.enable();
+            return false;
+        }
+    }
+    resetError(opts) {
+        if (isNotNilOrBlank(this.error)) {
+            this.error = null;
+            if (!opts || opts.emitEvent !== false)
+                this.markForCheck();
+        }
+    }
+    setError(err, opts) {
+        if (!err) {
+            super.setError(undefined, opts);
+        }
+        else if (typeof err === 'string') {
+            console.error('[entity-editor] Error: ' + (err || ''));
+            super.setError(err, opts);
+        }
+        else {
+            console.error('[entity-editor] Error: ' + err.message || '', err);
+            let userMessage = err.message && this.translate.instant(err.message) || err;
+            // Add details error (if any) under the main message
+            const detailMessage = (!err.details || typeof err.details === 'string')
+                ? err.details
+                : err.details.message;
+            if (isNotNilOrBlank(detailMessage)) {
+                const cssClass = opts?.detailsCssClass || 'hidden-xs hidden-sm';
+                userMessage += `<br/><small class="${cssClass}" title="${detailMessage}">`;
+                userMessage += detailMessage.length < 70 ? detailMessage : detailMessage.substring(0, 67) + '...';
+                userMessage += '</small>';
+            }
+            super.setError(userMessage, opts);
+        }
+    }
+    /* -- protected methods -- */
+    waitWhilePending(opts) {
+        return AppFormUtils.waitWhilePending(this, opts);
+    }
+    async getValue() {
+        const json = await this.getJsonValueToSave();
+        const res = new this.dataType();
+        res.fromObject(json);
+        return res;
+    }
+    getJsonValueToSave() {
+        return Promise.resolve(this.form.value);
+    }
+    /**
+     * Compute the title
+     *
+     * @param data
+     */
+    async updateTitle(data) {
+        data = data || this.data;
+        const title = await this.computeTitle(data);
+        this.$title.next(title);
+    }
+    async scrollToTop(duration) {
+        if (this.content) {
+            return this.content.scrollToTop(duration);
+        }
+    }
+    markForCheck() {
+        this.cd?.markForCheck();
+    }
+    /* -- private functions -- */
+    /**
+     * Open the first tab that is invalid
+     */
+    openFirstInvalidTab() {
+        const invalidTabIndex = this.getFirstInvalidTabIndex();
+        if (invalidTabIndex !== -1 && this.selectedTabIndex !== invalidTabIndex) {
+            this.selectedTabIndex = invalidTabIndex;
+            this.markForCheck();
+        }
+    }
+}
+AppEntityEditorModal.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: AppEntityEditorModal, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+AppEntityEditorModal.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.8", type: AppEntityEditorModal, inputs: { data: "data", mobile: "mobile", usageMode: "usageMode", onAfterModalInit: "onAfterModalInit", onDelete: "onDelete", i18nSuffix: "i18nSuffix", isNew: "isNew", isNewData: "isNewData", disabled: "disabled" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: AppEntityEditorModal, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: undefined }, { type: undefined, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { data: [{
+                type: Input
+            }], mobile: [{
+                type: Input
+            }], usageMode: [{
+                type: Input
+            }], onAfterModalInit: [{
+                type: Input
+            }], onDelete: [{
+                type: Input
+            }], i18nSuffix: [{
+                type: Input
+            }], isNew: [{
+                type: Input
+            }], isNewData: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-editor-modal.class.js","sourceRoot":"","sources":["../../../../../../../src/app/core/form/entity/entity-editor-modal.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, ChangeDetectorRef, Directive, Injector, Input, OnDestroy, OnInit, Optional} from '@angular/core';\nimport {Router} from '@angular/router';\nimport {AlertController, ModalController} from '@ionic/angular';\n\nimport {TranslateService} from '@ngx-translate/core';\nimport {BehaviorSubject, Subject} from 'rxjs';\nimport {LocalSettingsService} from '../../services/local-settings.service';\nimport {Entity} from '../../services/model/entity.model';\nimport {UsageMode} from '../../services/model/settings.model';\nimport {FormGroup} from '@angular/forms';\nimport {AppTabEditor, AppTabEditorOptions} from './editor.class';\nimport {AppFormUtils} from '../form.utils';\nimport {Alerts} from '../../../shared/alerts';\nimport {ErrorCodes} from '../../services/errors';\nimport {isNil, isNotNil, isNotNilOrBlank} from '../../../shared/functions';\nimport {DateFormatPipe} from '../../../shared/pipes/date-format.pipe';\nimport {Environment, ENVIRONMENT} from '../../../../environments/environment.class';\nimport {waitForFalse, WaitForOptions} from '../../../shared/observables';\nimport {FormErrorTranslator} from '../../../shared/validator/form-error-adapter.class';\nimport {AppErrorWithDetails} from './entity-editor.class';\nimport {debounceTime} from 'rxjs/operators';\n\n\nexport interface IEntityEditorModalOptions<\n  T extends Entity<T, ID>  = Entity<any, any>,\n  ID = number> {\n\n  // Data\n  isNew: boolean;\n  data: T;\n  disabled: boolean;\n\n  onAfterModalInit?: <M extends AppEntityEditorModal<T, ID>>(modal: M) => void | Promise<void>;\n  onDelete?: (event: Event, data: T) => Promise<boolean>;\n\n  usageMode: UsageMode;\n  mobile: boolean;\n  i18nSuffix?: string;\n}\n\nexport class AppEntityEditorModalOptions extends AppTabEditorOptions {\n  i18nPrefix?: string;\n}\n\n// @dynamic\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class AppEntityEditorModal<\n  T extends Entity<T, ID>,\n  ID = number,\n  O extends AppEntityEditorModalOptions = AppEntityEditorModalOptions\n  >\n  extends AppTabEditor<T, ID>\n  implements OnInit, OnDestroy, AfterViewInit, IEntityEditorModalOptions<T, ID> {\n\n  private _usageMode: UsageMode;\n  protected _logPrefix;\n  protected _isNew: boolean;\n\n  protected readonly dateFormat: DateFormatPipe;\n  protected readonly cd: ChangeDetectorRef;\n  protected readonly settings: LocalSettingsService;\n  protected readonly modalCtrl: ModalController;\n  protected readonly environement: Environment;\n  protected errorTranslator: FormErrorTranslator;\n\n  readonly savingSubject = new BehaviorSubject<boolean>(false);\n\n  $title = new Subject<string>();\n\n  @Input() data: T;\n  @Input() mobile: boolean;\n  @Input() usageMode: UsageMode;\n  @Input() onAfterModalInit: <M extends AppEntityEditorModal<T, ID>>(modal: M) => void | Promise<void>;\n  @Input() onDelete: (event: Event, data: T) => Promise<boolean>;\n  @Input() i18nSuffix: string = null;\n\n  @Input() set isNew(value: boolean) {\n    this._isNew = value;\n  }\n\n  get isNew(): boolean {\n    return isNotNil(this._isNew) ? this._isNew : isNil(this.data?.id);\n  }\n\n  /**\n   * @deprecated use isNew instead\n   */\n  get isNewData(): boolean {\n    return this.isNew;\n  }\n  /**\n   * @deprecated use isNew instead\n   */\n  @Input() set isNewData(value: boolean) {\n    this.isNew = value;\n  }\n\n  @Input() set disabled(value: boolean) {\n    this._enabled = !value;\n  }\n\n  get disabled(): boolean {\n    return !this._enabled;\n  }\n\n  get isOnFieldMode(): boolean {\n    return this.settings.isOnFieldMode(this._usageMode);\n  }\n\n  get saving(): boolean {\n    return this.savingSubject.value;\n  }\n\n  markAsSaving(opts?: { emitEvent?: boolean }){\n    if (this.savingSubject.value !== true) {\n      this.savingSubject.next(true);\n      if (!opts || opts.emitEvent !== false) this.markForCheck();\n    }\n  }\n\n  markAsSaved(opts?: { emitEvent?: boolean }){\n    if (this.savingSubject.value !== false) {\n      this.savingSubject.next(false);\n      if (!opts || opts.emitEvent !== false) this.markForCheck();\n    }\n  }\n\n  protected constructor(\n    injector: Injector,\n    protected dataType: new() => T,\n    @Optional() options?: O\n  ) {\n    super(null,\n      injector.get(Router),\n      injector.get(AlertController),\n      injector.get(TranslateService),\n      options);\n    this.environement = injector.get(ENVIRONMENT);\n    options = <O>{\n      // Default options\n      i18nPrefix: '',\n\n      // Override defaults\n      ...options\n    };\n\n    this.queryTabIndexParamName = undefined; // Important: avoid query parameter changed\n    this.settings = injector.get(LocalSettingsService);\n    this.errorTranslator = injector.get(FormErrorTranslator);\n    this.cd = injector.get(ChangeDetectorRef);\n    this.dateFormat = injector.get(DateFormatPipe);\n    this.modalCtrl = injector.get(ModalController);\n    this.i18nContext = {\n      prefix: options.i18nPrefix,\n      suffix: this.i18nSuffix || ''\n    };\n\n    // FOR DEV ONLY ----\n    //this.debug = !environment.production;\n  }\n\n  ngOnInit() {\n\n    // Default values\n    this.mobile = isNotNil(this.mobile) ? this.mobile : this.settings.mobile;\n\n    super.ngOnInit();\n\n    // Register forms\n    this.registerForms();\n\n    // Disable\n    if (this.disabled) this.disable();\n\n    if (this.isNewData) {\n      // Update the title.\n      this.updateTitle();\n    }\n\n    else {\n      // Update title each time value changes\n      this.registerSubscription(\n        this.form.valueChanges\n          .pipe(debounceTime(250))\n          .subscribe(json => this.updateTitle(json))\n      );\n    }\n  }\n\n  ngAfterViewInit() {\n    super.ngAfterViewInit();\n\n    if (this.onAfterModalInit) {\n      Promise.resolve(this.onAfterModalInit(this))\n        .then(() => this.load());\n    }\n    else {\n      // Use a timeout to avoid error 'NG0100: ExpressionChangedAfterItHasBeenCheckedError'\n      setTimeout(() => this.load());\n    }\n  }\n\n  ngOnDestroy() {\n    super.ngOnDestroy();\n    this.$title.complete();\n    this.$title.unsubscribe();\n    this.savingSubject.unsubscribe();\n  }\n\n  waitIdle(opts?: WaitForOptions): Promise<void> {\n    // Wait end of saving\n    if (this.saving) return waitForFalse(this.savingSubject);\n\n    return super.waitIdle(opts);\n  }\n\n  async load() {\n    this.markAsReady();\n    this.markAsLoading();\n\n    try {\n      await this.updateView(this.data);\n    }\n    catch(err) {\n      if (err === 'CANCELLED') return;\n      this.setError(err);\n      this.selectedTabIndex = 0;\n    }\n    finally {\n      this.markAsLoaded();\n    }\n  }\n\n  reload(): Promise<void> {\n    if (this.dirty) {\n      return this.load();\n    }\n  }\n\n  unload(opts?: { emitEvent?: boolean }): Promise<void> {\n    throw new Error(\"No implemented on modal\");\n  }\n\n  async updateView(data: T | null, opts?: {\n    emitEvent?: boolean;\n    openTabIndex?: number;\n  }): Promise<void> {\n\n    this.resetError();\n\n    if (!this.data) throw {code: ErrorCodes.DATA_NOT_FOUND_ERROR, message: 'ERROR.DATA_NO_FOUND'};\n\n    await this.setValue(data);\n\n    if (!opts || opts.emitEvent !== false) {\n      this.markAsPristine();\n      this.markAsUntouched();\n      this.updateViewState(data);\n\n      // Update the title.\n      this.updateTitle(data);\n    }\n  }\n\n  /**\n   * Enable or disable state\n   */\n  updateViewState(data: T, opts?: {onlySelf?: boolean; emitEvent?: boolean }) {\n    if (this.isNewData || this.enabled) {\n      this.enable(opts);\n    }\n    else {\n      this.disable(opts);\n\n      // Allow to sort table\n      this.tables?.forEach(t => t.enableSort());\n    }\n  }\n\n  async saveAndClose(event?: Event|Event): Promise<boolean> {\n\n    const data = await this.saveAndGetDataIfValid();\n    if (data) {\n      this.modalCtrl.dismiss(data);\n      return true;\n    }\n    return false;\n  }\n\n  async close(event: Event|Event): Promise<void> {\n    if (this.dirty) {\n      const saveBeforeLeave = await Alerts.askSaveBeforeLeave(this.alertCtrl, this.translate, event);\n\n      // User cancelled\n      if (isNil(saveBeforeLeave) || event && event.defaultPrevented) {\n        return;\n      }\n\n      // Is user confirm: close normally\n      if (saveBeforeLeave === true) {\n        await this.saveAndClose(event);\n        return;\n      }\n    }\n\n    await this.modalCtrl.dismiss();\n  }\n\n  /**\n   * Save the editor, by calling the dataService.save().\n   * Ensure that editor if valid. If not, display an error\n   * @param event\n   * @param opts\n   */\n  async save(event?: Event|Event, opts?: any): Promise<boolean> {\n    if (this.loading || this.saving || this.disabled) {\n      console.debug(this._logPrefix + 'Skip save: modal is busy (loading or saving)');\n      return false;\n    }\n    if (!this.dirty) {\n      console.debug(this._logPrefix + 'Skip save: modal not dirty');\n      return true;\n    }\n\n    // Wait end of async validation\n    await this.waitWhilePending();\n\n    // If invalid\n    if (this.invalid) {\n      this.logFormErrors();\n      this.setError('COMMON.FORM.HAS_ERROR');\n      this.openFirstInvalidTab();\n      this.scrollToTop();\n      this.markAllAsTouched();\n\n      this.submitted = true;\n      return false;\n    }\n\n    this.markAsSaving();\n    this.resetError();\n\n    if (this.debug) console.debug(this._logPrefix + 'Saving data...');\n\n    try {\n      // Save all dirty children\n      const saved = await this.saveDirtyChildren();\n      if (!saved) return false;\n\n      // Fill data\n      this.data = await this.getValue();\n\n      // Mark as submitted\n      this.submitted = true;\n\n      return true;\n    } catch (err) {\n      this.submitted = true;\n      this.setError(err);\n      this.selectedTabIndex = 0;\n      this.scrollToTop(); // Scroll to top (to show error)\n      this.markAsDirty();\n      this.enable();\n\n      return false;\n    } finally {\n      this.markAsSaved();\n    }\n  }\n\n  /**\n   * Save data (if dirty and valid), and return it. Otherwise, return nil value.\n   */\n  async saveAndGetDataIfValid(): Promise<T | undefined> {\n    // Form is not valid\n    if (!this.valid) {\n\n      // Make sure validation is finished\n      await AppFormUtils.waitWhilePending(this);\n\n      // If invalid: Open the first tab in error\n      if (this.invalid) {\n        this.openFirstInvalidTab();\n        return undefined;\n      }\n\n      // Continue (valid)\n    }\n\n    // Form is valid, but not saved\n    if (this.dirty) {\n      const saved = await this.save(new Event('save'));\n      if (!saved) return undefined;\n    }\n\n    // Valid and saved data\n    return this.data;\n  }\n\n  async delete(event?: Event|Event) {\n    if (this.loading || this.saving) return false;\n\n    this.markAsSaving();\n    this.resetError();\n    try {\n\n      // Delegate deletion to modal caller\n      if (this.onDelete) {\n        const result = await this.onDelete(event, this.data);\n\n        // User cancelled\n        if (isNil(result) || (event && event.defaultPrevented)) return;\n\n        if (result) {\n          await this.modalCtrl.dismiss(this.data, 'delete');\n        }\n      }\n\n      // Or dismiss, with the role 'delete'\n      else {\n        if (this.isNewData) {\n          console.error(this._logPrefix + \"Trying to delete a new data. Make no sense!\");\n        }\n\n        await this.modalCtrl.dismiss(this.data, 'delete');\n      }\n    }\n    catch (err) {\n      this.submitted = true;\n      this.setError(err);\n      this.selectedTabIndex = 0;\n      this.markAsSaved();\n      if (this.enabled) this.enable();\n      return false;\n    }\n  }\n\n  resetError(opts?: {emitEvent?: boolean}) {\n    if (isNotNilOrBlank(this.error)) {\n      this.error = null;\n      if (!opts || opts.emitEvent !== false) this.markForCheck();\n    }\n  }\n\n  setError(err: string | AppErrorWithDetails, opts?: {emitEvent?: boolean; detailsCssClass?: string;}) {\n    if (!err) {\n      super.setError(undefined, opts);\n    }\n    else if (typeof err === 'string') {\n      console.error('[entity-editor] Error: ' + (err || ''));\n      super.setError(err as string, opts);\n    }\n    else {\n      console.error('[entity-editor] Error: ' + err.message || '', err);\n      let userMessage = err.message && this.translate.instant(err.message) || err;\n\n      // Add details error (if any) under the main message\n      const detailMessage = (!err.details || typeof err.details === 'string')\n        ? err.details as string\n        : err.details.message;\n      if (isNotNilOrBlank(detailMessage)) {\n        const cssClass = opts?.detailsCssClass || 'hidden-xs hidden-sm';\n        userMessage += `<br/><small class=\"${cssClass}\" title=\"${detailMessage}\">`;\n        userMessage += detailMessage.length < 70 ? detailMessage : detailMessage.substring(0, 67) + '...';\n        userMessage += '</small>';\n      }\n      super.setError(userMessage, opts);\n    }\n  }\n\n  /* -- protected abstract methods (to override) -- */\n\n  protected abstract registerForms();\n\n  protected abstract computeTitle(data: T): Promise<string>;\n\n  protected abstract setValue(data: T): Promise<void> | void;\n\n  protected abstract get form(): FormGroup;\n\n  protected abstract getFirstInvalidTabIndex(): number;\n\n  /* -- protected methods -- */\n\n  protected waitWhilePending(opts?: WaitForOptions): Promise<void> {\n    return AppFormUtils.waitWhilePending(this, opts);\n  }\n\n  protected async getValue(): Promise<T> {\n    const json = await this.getJsonValueToSave();\n\n    const res = new this.dataType();\n    res.fromObject(json);\n\n    return res;\n  }\n\n  protected getJsonValueToSave(): Promise<any> {\n    return Promise.resolve(this.form.value);\n  }\n\n  /**\n   * Compute the title\n   *\n   * @param data\n   */\n  protected async updateTitle(data?: T) {\n    data = data || this.data;\n    const title = await this.computeTitle(data);\n    this.$title.next(title);\n  }\n\n  protected async scrollToTop(duration?: number) {\n    if (this.content) {\n      return this.content.scrollToTop(duration);\n    }\n  }\n\n  protected markForCheck() {\n    this.cd?.markForCheck();\n  }\n\n  /* -- private functions -- */\n\n  /**\n   * Open the first tab that is invalid\n   */\n  private openFirstInvalidTab() {\n    const invalidTabIndex = this.getFirstInvalidTabIndex();\n    if (invalidTabIndex !== -1 && this.selectedTabIndex !== invalidTabIndex) {\n      this.selectedTabIndex = invalidTabIndex;\n      this.markForCheck();\n    }\n  }\n\n}\n"]}