@sumaris-net/ngx-components 18.14.0 → 18.14.2

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

@@ -0,0 +1,741 @@
+import { ChangeDetectorRef, Directive, EventEmitter, Optional } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AlertController, IonRouterOutlet, NavController, ToastController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, of } from 'rxjs';
+import { isMoment } from 'moment';
+import { LocalSettingsService } from '../../services/local-settings.service';
+import { debounceTime, filter, map, mergeMap } from 'rxjs/operators';
+import { AppTabEditor, AppTabEditorOptions } from './tab-editor.class';
+import { AppFormUtils } from '../form.utils';
+import { Alerts } from '../../../shared/alerts';
+import { ErrorCodes, ServerErrorCodes } from '../../services/errors';
+import { equals, isInt, isNil, isNilOrBlank, isNotEmptyArray, isNotNil, isNotNilOrBlank, toBoolean, toNumber } from '../../../shared/functions';
+import { DateFormatService } from '../../../shared/pipes/date-format.pipe';
+import { ENVIRONMENT } from '../../../../environments/environment.class';
+import { firstFalse, firstNotNilPromise, waitForFalse } from '../../../shared/observables';
+import { FormErrorTranslator } from '../../../shared/validator/form-error-adapter.class';
+import { isStartableService } from '../../../shared/services/startable-service.class';
+import * as i0 from "@angular/core";
+export class AppEditorOptions extends AppTabEditorOptions {
+    autoLoad;
+    autoLoadDelay;
+    pathIdAttribute;
+    enableListenChanges;
+    listenIntervalInSeconds;
+    /**
+     * Change page route (window URL) when saving for the first time
+     */
+    autoUpdateRoute; // Default to true
+    /**
+     * Open the next tab, after saving for the first time
+     */
+    autoOpenNextTab; // Default to true
+    i18nPrefix;
+}
+// @dynamic
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class AppEntityEditor extends AppTabEditor {
+    dataType;
+    dataService;
+    data;
+    previousDataId;
+    defaultBackHref;
+    historyIcon;
+    titleSubject = new BehaviorSubject(undefined);
+    onUpdateView = new EventEmitter();
+    /**
+     *  @deprecated
+     */
+    get $title() {
+        return this.titleSubject;
+    }
+    cd;
+    dateFormat;
+    settings;
+    environment;
+    routerOutlet;
+    errorTranslator;
+    _usageMode;
+    _enableListenChanges;
+    _listenIntervalInSeconds;
+    _pathIdAttribute;
+    _autoLoad;
+    _autoLoadDelay;
+    _autoUpdateRoute;
+    _autoOpenNextTab;
+    _listenChangesSubscription;
+    get usageMode() {
+        return this._usageMode;
+    }
+    set usageMode(value) {
+        if (this._usageMode !== value) {
+            this._usageMode = value;
+            this.markForCheck();
+        }
+    }
+    get isOnFieldMode() {
+        return this.settings.isOnFieldMode(this._usageMode);
+    }
+    get isNewData() {
+        return isNil(this.data?.id);
+    }
+    get service() {
+        return this.dataService;
+    }
+    get autoOpenNextTab() {
+        return this._autoOpenNextTab;
+    }
+    set autoOpenNextTab(value) {
+        this._autoOpenNextTab = value;
+    }
+    get pathIdAttribute() {
+        return this._pathIdAttribute;
+    }
+    constructor(injector, dataType, dataService, options) {
+        super(injector.get(ActivatedRoute), injector.get(Router), injector.get(NavController), injector.get(AlertController), injector.get(TranslateService), options);
+        this.dataType = dataType;
+        this.dataService = dataService;
+        this.environment = injector.get(ENVIRONMENT);
+        options = {
+            // Default options
+            enableListenChanges: this.environment.entityEditor?.enableListenChanges || false, // False  by default
+            listenIntervalInSeconds: toNumber(this.environment.entityEditor?.listenIntervalInSeconds, 0), // no timer by default
+            pathIdAttribute: 'id',
+            autoLoad: true,
+            autoUpdateRoute: true,
+            i18nPrefix: '',
+            // Following options are override inside ngOnInit()
+            // autoOpenNextTab: ...,
+            // Override defaults
+            ...options,
+        };
+        this.cd = injector.get(ChangeDetectorRef);
+        this.settings = injector.get(LocalSettingsService);
+        this.errorTranslator = injector.get(FormErrorTranslator);
+        this.routerOutlet = injector.get(IonRouterOutlet);
+        this.dateFormat = injector.get(DateFormatService);
+        this.toastController = injector.get(ToastController);
+        this._enableListenChanges = options.enableListenChanges;
+        this._listenIntervalInSeconds = options.listenIntervalInSeconds;
+        this._pathIdAttribute = options.pathIdAttribute;
+        this._autoLoad = options.autoLoad;
+        this._autoLoadDelay = options.autoLoadDelay;
+        this._autoUpdateRoute = options.autoUpdateRoute;
+        this._autoOpenNextTab = options.autoOpenNextTab;
+        this.i18nContext = {
+            prefix: options.i18nPrefix,
+            suffix: '',
+        };
+        // FOR DEV ONLY ----
+        //this.debug = !environment.production;
+        this._logPrefix = '[entity-editor] ';
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // Defaults
+        this._autoOpenNextTab = toBoolean(this._autoOpenNextTab, !this.isOnFieldMode);
+        this.historyIcon = this.historyIcon || { icon: 'list' };
+        // Register forms
+        this.registerForms();
+        // Disable page, during load
+        this.disable();
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        // Load data
+        if (this._autoLoad) {
+            setTimeout(() => this.loadFromRoute(), this._autoLoadDelay);
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.titleSubject.complete();
+        this.titleSubject.unsubscribe();
+        this.onUpdateView.complete();
+        this.onUpdateView.unsubscribe();
+    }
+    waitIdle(opts) {
+        // Wait end of saving
+        if (this.saving)
+            return waitForFalse(this.savingSubject, { stop: this.destroySubject });
+        return super.waitIdle(opts);
+    }
+    /**
+     * Load data from id, using the dataService
+     *
+     * @param id
+     * @param opts
+     */
+    async load(id, opts) {
+        if (!this.dataService)
+            throw new Error("Cannot load data: missing 'dataService'!");
+        this.resetError();
+        // New data
+        if (isNil(id)) {
+            try {
+                // Create using default values
+                const data = new this.dataType();
+                this._usageMode = this.computeUsageMode(data);
+                await this.onNewEntity(data, opts);
+                await this.updateView(data, {
+                    openTabIndex: 0,
+                    ...opts,
+                });
+            }
+            catch (err) {
+                this.setError(err, { emitEvent: false });
+                this.selectedTabIndex = 0;
+            }
+            finally {
+                this.markAsLoaded();
+            }
+        }
+        // Load existing data
+        else {
+            try {
+                const data = await this.dataService.load(id, opts);
+                if (!data)
+                    throw { code: ErrorCodes.DATA_NOT_FOUND_ERROR, message: 'ERROR.DATA_NO_FOUND' };
+                this._usageMode = this.computeUsageMode(data);
+                await this.onEntityLoaded(data, opts);
+                await this.updateView(data, opts);
+                this.startListenChanges();
+            }
+            catch (err) {
+                this.setError(err);
+                this.selectedTabIndex = 0;
+            }
+            finally {
+                this.markAsLoaded();
+            }
+        }
+    }
+    canUserWrite(data, opts) {
+        return this.dataService.canUserWrite(data, opts);
+    }
+    startListenChanges() {
+        // Skip if disabled, or already listening
+        if (this._listenChangesSubscription || !this._enableListenChanges)
+            return;
+        // Skip if new (nothing to listen)
+        if (this.isNewData)
+            return;
+        // Listen for changes on server
+        const subscription = this.listenChanges(this.data.id, {
+            interval: this._listenIntervalInSeconds,
+        })
+            ?.pipe(filter(isNotNil), mergeMap((data) => this.saving
+            ? // If saving, wait end, to avoid to detect self changes
+                firstFalse(this.savingSubject).pipe(map(() => data), debounceTime(500))
+            : of(data)))
+            .subscribe((data) => {
+            const isNewer = isMoment(data.updateDate) && (!this.data.updateDate || data.updateDate.isAfter(this.data.updateDate));
+            if (!isNewer)
+                return; // Skip
+            // Editor has no changes: reload
+            if (!this.dirty) {
+                if (this.debug)
+                    console.debug(`[data-editor] Changes detected on server, at {${data.updateDate}}: reloading page...`);
+                this.reload();
+            }
+            // Cannot reload: alert the user
+            else {
+                if (this.debug)
+                    console.debug(`[data-editor] Changes detected on server, at {${data.updateDate}}, but page is dirty: skip reloading.`);
+                this.showToast({ message: 'ERROR.DATA_UPDATE_DATE_CHANGED', type: 'warning', showCloseButton: true });
+            }
+        });
+        // Register subscription
+        if (subscription) {
+            this._listenChangesSubscription = subscription;
+            this.registerSubscription(this._listenChangesSubscription);
+            subscription.add(() => {
+                this.unregisterSubscription(subscription);
+                this._listenChangesSubscription = null;
+            });
+        }
+    }
+    stopListenChanges() {
+        this._listenChangesSubscription?.unsubscribe();
+    }
+    async ready(opts) {
+        await super.ready(opts);
+        // Wait service to be ready
+        if (isStartableService(this.dataService)) {
+            await this.dataService.ready();
+        }
+    }
+    async updateView(data, opts) {
+        const idChanged = isNotNil(data.id) &&
+            this.previousDataId !== undefined && // Ignore if first loading (=undefined)
+            this.previousDataId !== data.id;
+        opts = {
+            updateRoute: this._autoUpdateRoute && idChanged && !this.loading,
+            ...opts,
+        };
+        this.data = data;
+        this.previousDataId = data.id || null;
+        await this.ready();
+        await this.setValue(data);
+        if (!opts || opts.emitEvent !== false) {
+            this.markAsPristine();
+            this.markAsUntouched();
+            this.updateViewState(data);
+            // Need to update route
+            if (opts.updateRoute === true) {
+                this.updateTabAndRoute(data, opts)
+                    // Update the title - should be executed AFTER updateRoute because of path change - fix #185
+                    .then(() => this.updateTitle(data));
+            }
+            else {
+                // Update the next tab
+                this.updateTabIndex(opts.openTabIndex);
+                // Update the title.
+                this.updateTitle(data);
+            }
+            this.onUpdateView.emit(data);
+        }
+    }
+    /**
+     * Enable or disable state
+     */
+    updateViewState(data, opts) {
+        if (this.isNewData || this.canUserWrite(data)) {
+            this.enable(opts);
+        }
+        else {
+            this.disable(opts);
+            // Allow to sort tables
+            this.tables?.forEach((t) => t.enableSort());
+            this.asyncTables?.forEach((t) => t.enableSort());
+        }
+    }
+    /**
+     * Update the route location, and open the next tab
+     */
+    async updateTabAndRoute(data, opts) {
+        const queryParams = { ...this.queryParams };
+        // Open the next tab
+        this.updateTabIndex(opts && opts.openTabIndex);
+        if (!this.queryTabIndexParamName || !this.route)
+            return; // Skip route update
+        // Update route location
+        queryParams[this.queryTabIndexParamName] = this.selectedTabIndex !== 0 ? this.selectedTabIndex : undefined;
+        await this.updateRoute(data, queryParams);
+    }
+    /**
+     * Update the route location, and open the next tab
+     */
+    updateTabIndex(tabIndex) {
+        if (isNotNil(tabIndex) && tabIndex >= 0 && tabIndex !== this.selectedTabIndex) {
+            this.selectedTabIndex = tabIndex;
+            this.markForCheck();
+        }
+    }
+    async saveAndClose(event, options) {
+        const saved = await this.save(event);
+        if (saved) {
+            await this.close(event);
+        }
+        return saved;
+    }
+    async close(event) {
+        if (event) {
+            if (event.defaultPrevented)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+        }
+        return this.goBack();
+    }
+    /**
+     * 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) {
+            console.debug('[data-editor] Skip save: editor is busy (loading or saving)');
+            return false;
+        }
+        if (!this.dirty && !this.isNewData) {
+            console.debug('[data-editor] Skip save: editor not dirty');
+            return true;
+        }
+        // Wait end of async validation
+        await this.waitWhilePending();
+        // If invalid
+        if (this.invalid) {
+            this.logFormErrors();
+            this.openFirstInvalidTab();
+            this.scrollToTop();
+            this.markAllAsTouched();
+            this.submitted = true;
+            return false;
+        }
+        this.markAsSaving();
+        this.resetError();
+        if (this.debug)
+            console.debug('[data-editor] Saving data...');
+        try {
+            // Compute next tab index (if enable)
+            const nextTabIndex = this._autoOpenNextTab && isNil(this.previousDataId) && this.computeNextTabIndex();
+            // Save all dirty tables
+            const saved = await this.saveDirtyChildren();
+            if (!saved)
+                return false;
+            // Get data
+            const data = await this.getValue();
+            this.disable();
+            // Save form
+            const updatedData = await this.dataService.save(data, opts);
+            await this.onEntitySaved(updatedData);
+            // Update the view (e.g metadata)
+            await this.updateView(updatedData, {
+                // Open next tab only if user has not changed it
+                openTabIndex: nextTabIndex > this._selectedTabIndex ? nextTabIndex : undefined,
+                ...opts,
+            });
+            // Subscribe to remote changes
+            if (!this._listenChangesSubscription)
+                this.startListenChanges();
+            this.submitted = false;
+            return true;
+        }
+        catch (err) {
+            this.submitted = true;
+            this.selectedTabIndex = 0; // Can be override by subclasses, using setError()
+            this.setError(err);
+            this.scrollToTop(); // Scroll to top (to show error)
+            this.markAsDirty();
+            this.enable();
+            // Concurrent change on pod
+            if (err.code === ServerErrorCodes.BAD_UPDATE_DATE && isNotNil(this.data.id)) {
+                // Call a data reload (in background), to update the GraphQL cache, and allow to cancel changes
+                this.dataService.load(this.data.id, { fetchPolicy: 'network-only' }).then(() => {
+                    console.debug('[data-editor] Data cache reloaded. User can reload page');
+                });
+            }
+            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;
+        // Ask user confirmation
+        const confirmation = await Alerts.askDeleteConfirmation(this.alertCtrl, this.translate);
+        if (!confirmation)
+            return;
+        console.debug('[data-editor] Asking to delete...');
+        this.markAsSaving();
+        this.resetError();
+        try {
+            // Get data
+            const data = await this.getValue();
+            const isNew = this.isNewData;
+            this.disable();
+            if (!isNew) {
+                await this.dataService.delete(data);
+            }
+            await this.onEntityDeleted(data);
+            // Remove page history
+            this.removePageHistory();
+        }
+        catch (err) {
+            this.submitted = true;
+            this.selectedTabIndex = 0;
+            this.setError(err);
+            this.markAsSaved();
+            this.enable();
+            return false;
+        }
+        // Wait, then go back (wait is need in order to update back href is need)
+        await setTimeout(() => this.goBack(), 500);
+        return true;
+    }
+    async reload() {
+        this.markAsLoading();
+        await this.load(this.data?.id, { fetchPolicy: 'network-only' });
+    }
+    async unload(opts) {
+        await super.unload(opts);
+        this.stopListenChanges();
+        this.form.reset();
+        this.registerForms();
+        this.data = null;
+        // TODO: find a way to remove current page from the navigation history
+    }
+    async goBack(event) {
+        // Go back
+        if (this.toolbar?.canGoBack) {
+            return this.toolbar.goBack();
+        }
+        else if (this.defaultBackHref) {
+            return this.navController.navigateBack(this.defaultBackHref);
+        }
+        else {
+            // Back to home
+            return this.navController.navigateBack('/');
+        }
+    }
+    resetError(opts) {
+        super.resetError(opts);
+    }
+    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 || 'error-details';
+                userMessage += `<br/><small class="${cssClass}" title="${detailMessage}">`;
+                userMessage += detailMessage.length < 70 ? detailMessage : detailMessage.substring(0, 67) + '...';
+                userMessage += '</small>';
+            }
+            super.setError(userMessage, opts);
+        }
+    }
+    /**
+     * Load data from the snapshot route
+     *
+     * @protected
+     */
+    loadFromRoute() {
+        const route = this.route.snapshot;
+        if (!route || isNilOrBlank(this._pathIdAttribute)) {
+            throw new Error("Unable to load from route: missing 'route' or 'options.pathIdAttribute'.");
+        }
+        let id = route.params[this._pathIdAttribute];
+        if (isNil(id) || id === 'new') {
+            return this.load(undefined, route.params);
+        }
+        else {
+            // Convert as number, if need
+            if (isInt(id)) {
+                id = parseInt(id);
+            }
+            return this.load(id, route.params);
+        }
+    }
+    /**
+     * Return undefined to keep same tab
+     *
+     * @protected
+     */
+    computeNextTabIndex() {
+        const nextTabIndex = this.selectedTabIndex + 1;
+        return nextTabIndex < this.tabCount ? nextTabIndex : undefined;
+    }
+    async onBeforeEntityLoad() {
+        // can be overwritten by subclasses
+    }
+    async onNewEntity(data, options) {
+        // can be overwritten by subclasses
+    }
+    async onEntityLoaded(data, options) {
+        // can be overwritten by subclasses
+    }
+    async onEntitySaved(data) {
+        // can be overwritten by subclasses
+    }
+    async onEntityDeleted(data) {
+        // can be overwritten by subclasses
+    }
+    computeUsageMode(data) {
+        // can be overwritten by subclasses
+        // Using local settings default value
+        return this.settings.usageMode;
+    }
+    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.titleSubject.next(title);
+        // If NOT data, then add to page history
+        if (!this.isNewData) {
+            const page = await this.computePageHistory(title);
+            if (page)
+                return this.addToPageHistory(page);
+        }
+    }
+    async addToPageHistory(page, opts) {
+        if (!page)
+            return; // Skip
+        return this.settings.addToPageHistory(page, {
+            removePathQueryParams: true,
+            removeTitleSmallTag: true,
+            emitEvent: false,
+            ...opts,
+        });
+    }
+    async computePageHistory(title) {
+        if (this.debug)
+            console.debug('[entity-editor] Computing page history, using url: ' + this.router.url);
+        return {
+            title,
+            path: this.router.url,
+        };
+    }
+    async removePageHistory(opts) {
+        return this.settings.removePageHistory(this.router.url, opts);
+    }
+    computePageUrl(id) {
+        const parentUrl = this.getParentPageUrl();
+        return parentUrl && `${parentUrl}/${id}`;
+    }
+    getParentPageUrl(withQueryParams) {
+        let parentUrl = this.defaultBackHref;
+        // Remove query params
+        if (withQueryParams !== true && parentUrl && parentUrl.indexOf('?') !== -1) {
+            parentUrl = parentUrl.substring(0, parentUrl.indexOf('?'));
+        }
+        return parentUrl;
+    }
+    listenChanges(id, opts) {
+        return this.dataService.listenChanges(this.data.id, {
+            // Make sure to skip cache, because NOT the full graph will be fetched by subscription
+            // When a changes occur, we call reload() to force refetching the full graph
+            fetchPolicy: 'no-cache',
+            ...opts,
+        });
+    }
+    markForCheck() {
+        this.cd.markForCheck();
+    }
+    /**
+     * Update the route, without reloading the component
+     *
+     * @param data
+     * @param queryParams
+     * @protected
+     */
+    async updateRoute(data, queryParams) {
+        data = data || this.data;
+        if (!data || !this.route)
+            return false;
+        const currId = this.route.snapshot.paramMap.get(this.pathIdAttribute);
+        const futureId = isNotNil(data.id) ? data.id.toString() : 'new';
+        if (queryParams) {
+            this.queryParams = {
+                ...this.queryParams,
+                ...queryParams,
+            };
+        }
+        if (currId === futureId) {
+            // Update queryParam only (not the path)
+            // /!\ We should get query Params from the updated route, and not from snapshot that can be outdated
+            const actualQueryParams = await firstNotNilPromise(this.route.queryParams);
+            if (!equals(actualQueryParams, this.queryParams)) {
+                if (this.debug)
+                    console.debug(`${this._logPrefix}Updating route using queryParams: `, this.queryParams);
+                return await this.router.navigate(['.'], {
+                    relativeTo: this.route,
+                    replaceUrl: false,
+                    queryParams: this.queryParams,
+                    state: { animated: false },
+                });
+            }
+        }
+        else {
+            const path = this.computePageUrl(isNotNil(data.id) ? data.id : 'new');
+            const commands = path && typeof path === 'string' ? path.split('/').slice(1) : path;
+            if (isNotEmptyArray(commands)) {
+                // Current route was '/new' => change to '/new?id=:id' (to allow CustomReuseStrategy to detect that route can be reused)
+                if (currId === 'new' && this.queryParams[this.pathIdAttribute] !== futureId) {
+                    if (this.debug)
+                        console.debug(`${this._logPrefix}Updating route /new into /:id, using queryParams: `, queryParams);
+                    this.queryParams[this.pathIdAttribute] = futureId;
+                    const res = await this.router.navigate(['.'], {
+                        relativeTo: this.route,
+                        replaceUrl: true,
+                        queryParams: this.queryParams,
+                        state: { animated: false },
+                    });
+                    if (!res)
+                        return false;
+                }
+                if (this.debug)
+                    console.debug(`${this._logPrefix}Updating route to: ` + path);
+                return await this.router.navigate(commands, {
+                    replaceUrl: true,
+                    queryParams: this.queryParams,
+                    state: { animated: false },
+                });
+            }
+            return Promise.reject('Missing page URL');
+        }
+    }
+    /* -- 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();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppEntityEditor, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: AppEntityEditor, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppEntityEditor, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: undefined }, { type: undefined }, { type: AppEditorOptions, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-editor.class.js","sourceRoot":"","sources":["../../../../../../../src/app/core/form/entity/entity-editor.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectorRef, Directive, EventEmitter, Injector, OnDestroy, OnInit, Optional } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { AlertController, IonRouterOutlet, NavController, ToastController } from '@ionic/angular';\n\nimport { TranslateService } from '@ngx-translate/core';\nimport { BehaviorSubject, Observable, of, Subject, Subscription } from 'rxjs';\nimport { isMoment } from 'moment';\nimport { AddToPageHistoryOptions, LocalSettingsService } from '../../services/local-settings.service';\nimport { debounceTime, filter, map, mergeMap } from 'rxjs/operators';\nimport { Entity } from '../../services/model/entity.model';\nimport { UsageMode } from '../../services/model/settings.model';\nimport { FormGroup } from '@angular/forms';\nimport { AppTabEditor, AppTabEditorOptions, IAppTabEditor } from './tab-editor.class';\nimport { AppFormUtils } from '../form.utils';\nimport { Alerts } from '../../../shared/alerts';\nimport { AppErrorWithDetails, ErrorCodes, ServerErrorCodes } from '../../services/errors';\nimport { equals, isInt, isNil, isNilOrBlank, isNotEmptyArray, isNotNil, isNotNilOrBlank, toBoolean, toNumber } from '../../../shared/functions';\nimport { EntityServiceLoadOptions, IEntityService } from '../../../shared/services/entity-service.class';\nimport { DateFormatService } from '../../../shared/pipes/date-format.pipe';\nimport { Environment, ENVIRONMENT } from '../../../../environments/environment.class';\nimport { HistoryPageReference } from '../../services/model/history.model';\nimport { firstFalse, firstNotNilPromise, waitForFalse, WaitForOptions } from '../../../shared/observables';\nimport { FormErrorTranslator } from '../../../shared/validator/form-error-adapter.class';\nimport { isStartableService } from '../../../shared/services/startable-service.class';\n\nexport interface IAppEntityEditor<T> extends IAppTabEditor<T> {\n  usageMode: UsageMode;\n  isNewData: boolean;\n}\n\nexport class AppEditorOptions extends AppTabEditorOptions {\n  autoLoad?: boolean;\n  autoLoadDelay?: number;\n  pathIdAttribute?: string;\n  enableListenChanges?: boolean;\n  listenIntervalInSeconds?: number;\n\n  /**\n   * Change page route (window URL) when saving for the first time\n   */\n  autoUpdateRoute?: boolean; // Default to true\n\n  /**\n   * Open the next tab, after saving for the first time\n   */\n  autoOpenNextTab?: boolean; // Default to true\n\n  i18nPrefix?: string;\n}\n\n// @dynamic\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class AppEntityEditor<\n    T extends Entity<T, ID>,\n    S extends IEntityService<T, ID> = IEntityService<T, any>,\n    ID = number,\n    LO extends EntityServiceLoadOptions = EntityServiceLoadOptions,\n  >\n  extends AppTabEditor<T, ID, LO>\n  implements OnInit, OnDestroy, AfterViewInit, IAppEntityEditor<T>\n{\n  data: T;\n  previousDataId: ID;\n\n  defaultBackHref: string;\n  historyIcon: { icon?: string; matIcon?: string };\n\n  readonly titleSubject = new BehaviorSubject<string>(undefined);\n  readonly onUpdateView = new EventEmitter<T>();\n\n  /**\n   *  @deprecated\n   */\n  protected get $title(): Subject<string> {\n    return this.titleSubject;\n  }\n\n  protected readonly cd: ChangeDetectorRef;\n  protected readonly dateFormat: DateFormatService;\n  protected readonly settings: LocalSettingsService;\n  protected readonly environment: Environment;\n  protected readonly routerOutlet: IonRouterOutlet;\n  protected errorTranslator: FormErrorTranslator;\n\n  private _usageMode: UsageMode;\n  private readonly _enableListenChanges: boolean;\n  private readonly _listenIntervalInSeconds: number;\n  private readonly _pathIdAttribute: string;\n  private readonly _autoLoad: boolean;\n  private readonly _autoLoadDelay: number;\n  private readonly _autoUpdateRoute: boolean;\n  private _autoOpenNextTab: boolean;\n  private _listenChangesSubscription: Subscription;\n\n  get usageMode(): UsageMode {\n    return this._usageMode;\n  }\n\n  set usageMode(value: UsageMode) {\n    if (this._usageMode !== value) {\n      this._usageMode = value;\n      this.markForCheck();\n    }\n  }\n\n  get isOnFieldMode(): boolean {\n    return this.settings.isOnFieldMode(this._usageMode);\n  }\n\n  get isNewData(): boolean {\n    return isNil(this.data?.id);\n  }\n\n  get service(): S {\n    return this.dataService;\n  }\n\n  get autoOpenNextTab(): boolean {\n    return this._autoOpenNextTab;\n  }\n\n  set autoOpenNextTab(value: boolean) {\n    this._autoOpenNextTab = value;\n  }\n\n  protected get pathIdAttribute(): string {\n    return this._pathIdAttribute;\n  }\n\n  protected constructor(\n    injector: Injector,\n    protected dataType: new () => T,\n    protected dataService?: S,\n    @Optional() options?: AppEditorOptions\n  ) {\n    super(\n      injector.get(ActivatedRoute),\n      injector.get(Router),\n      injector.get(NavController),\n      injector.get(AlertController),\n      injector.get(TranslateService),\n      options\n    );\n    this.environment = injector.get(ENVIRONMENT);\n    options = <AppEditorOptions>{\n      // Default options\n      enableListenChanges: this.environment.entityEditor?.enableListenChanges || false, // False  by default\n      listenIntervalInSeconds: toNumber(this.environment.entityEditor?.listenIntervalInSeconds, 0), // no timer by default\n      pathIdAttribute: 'id',\n      autoLoad: true,\n      autoUpdateRoute: true,\n      i18nPrefix: '',\n\n      // Following options are override inside ngOnInit()\n      // autoOpenNextTab: ...,\n\n      // Override defaults\n      ...options,\n    };\n\n    this.cd = injector.get(ChangeDetectorRef);\n    this.settings = injector.get(LocalSettingsService);\n    this.errorTranslator = injector.get(FormErrorTranslator);\n    this.routerOutlet = injector.get(IonRouterOutlet);\n    this.dateFormat = injector.get(DateFormatService);\n    this.toastController = injector.get(ToastController);\n    this._enableListenChanges = options.enableListenChanges;\n    this._listenIntervalInSeconds = options.listenIntervalInSeconds;\n    this._pathIdAttribute = options.pathIdAttribute;\n    this._autoLoad = options.autoLoad;\n    this._autoLoadDelay = options.autoLoadDelay;\n    this._autoUpdateRoute = options.autoUpdateRoute;\n    this._autoOpenNextTab = options.autoOpenNextTab;\n    this.i18nContext = {\n      prefix: options.i18nPrefix,\n      suffix: '',\n    };\n\n    // FOR DEV ONLY ----\n    //this.debug = !environment.production;\n    this._logPrefix = '[entity-editor] ';\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n\n    // Defaults\n    this._autoOpenNextTab = toBoolean(this._autoOpenNextTab, !this.isOnFieldMode);\n    this.historyIcon = this.historyIcon || { icon: 'list' };\n\n    // Register forms\n    this.registerForms();\n\n    // Disable page, during load\n    this.disable();\n  }\n\n  ngAfterViewInit() {\n    super.ngAfterViewInit();\n\n    // Load data\n    if (this._autoLoad) {\n      setTimeout(() => this.loadFromRoute(), this._autoLoadDelay);\n    }\n  }\n\n  ngOnDestroy() {\n    super.ngOnDestroy();\n    this.titleSubject.complete();\n    this.titleSubject.unsubscribe();\n    this.onUpdateView.complete();\n    this.onUpdateView.unsubscribe();\n  }\n\n  waitIdle(opts?: WaitForOptions): Promise<void> {\n    // Wait end of saving\n    if (this.saving) return waitForFalse(this.savingSubject, { stop: this.destroySubject });\n\n    return super.waitIdle(opts);\n  }\n\n  /**\n   * Load data from id, using the dataService\n   *\n   * @param id\n   * @param opts\n   */\n  async load(\n    id?: ID,\n    opts?: EntityServiceLoadOptions & {\n      emitEvent?: boolean;\n      openTabIndex?: number;\n      updateRoute?: boolean;\n      [key: string]: any;\n    }\n  ) {\n    if (!this.dataService) throw new Error(\"Cannot load data: missing 'dataService'!\");\n\n    this.resetError();\n\n    // New data\n    if (isNil(id)) {\n      try {\n        // Create using default values\n        const data = new this.dataType();\n        this._usageMode = this.computeUsageMode(data);\n        await this.onNewEntity(data, opts);\n        await this.updateView(data, {\n          openTabIndex: 0,\n          ...opts,\n        });\n      } catch (err) {\n        this.setError(err, { emitEvent: false });\n        this.selectedTabIndex = 0;\n      } finally {\n        this.markAsLoaded();\n      }\n    }\n\n    // Load existing data\n    else {\n      try {\n        const data = await this.dataService.load(id, opts);\n        if (!data) throw { code: ErrorCodes.DATA_NOT_FOUND_ERROR, message: 'ERROR.DATA_NO_FOUND' };\n        this._usageMode = this.computeUsageMode(data);\n        await this.onEntityLoaded(data, opts);\n        await this.updateView(data, opts);\n        this.startListenChanges();\n      } catch (err) {\n        this.setError(err);\n        this.selectedTabIndex = 0;\n      } finally {\n        this.markAsLoaded();\n      }\n    }\n  }\n\n  canUserWrite(data: T, opts?: any): boolean {\n    return this.dataService.canUserWrite(data, opts);\n  }\n\n  startListenChanges() {\n    // Skip if disabled, or already listening\n    if (this._listenChangesSubscription || !this._enableListenChanges) return;\n    // Skip if new (nothing to listen)\n    if (this.isNewData) return;\n\n    // Listen for changes on server\n    const subscription = this.listenChanges(this.data.id, {\n      interval: this._listenIntervalInSeconds,\n    })\n      ?.pipe(\n        filter(isNotNil),\n        mergeMap((data) =>\n          this.saving\n            ? // If saving, wait end, to avoid to detect self changes\n              firstFalse(this.savingSubject).pipe(\n                map(() => data),\n                debounceTime(500)\n              )\n            : of(data)\n        )\n      )\n      .subscribe((data: T) => {\n        const isNewer = isMoment(data.updateDate) && (!this.data.updateDate || data.updateDate.isAfter(this.data.updateDate));\n        if (!isNewer) return; // Skip\n\n        // Editor has no changes: reload\n        if (!this.dirty) {\n          if (this.debug) console.debug(`[data-editor] Changes detected on server, at {${data.updateDate}}: reloading page...`);\n          this.reload();\n        }\n        // Cannot reload: alert the user\n        else {\n          if (this.debug) console.debug(`[data-editor] Changes detected on server, at {${data.updateDate}}, but page is dirty: skip reloading.`);\n          this.showToast({ message: 'ERROR.DATA_UPDATE_DATE_CHANGED', type: 'warning', showCloseButton: true });\n        }\n      });\n\n    // Register subscription\n    if (subscription) {\n      this._listenChangesSubscription = subscription;\n      this.registerSubscription(this._listenChangesSubscription);\n      subscription.add(() => {\n        this.unregisterSubscription(subscription);\n        this._listenChangesSubscription = null;\n      });\n    }\n  }\n\n  stopListenChanges() {\n    this._listenChangesSubscription?.unsubscribe();\n  }\n\n  async ready(opts?: WaitForOptions): Promise<void> {\n    await super.ready(opts);\n\n    // Wait service to be ready\n    if (isStartableService(this.dataService)) {\n      await this.dataService.ready();\n    }\n  }\n\n  async updateView(\n    data: T | null,\n    opts?: {\n      emitEvent?: boolean;\n      openTabIndex?: number;\n      updateRoute?: boolean;\n    }\n  ): Promise<void> {\n    const idChanged =\n      isNotNil(data.id) &&\n      this.previousDataId !== undefined && // Ignore if first loading (=undefined)\n      this.previousDataId !== data.id;\n\n    opts = {\n      updateRoute: this._autoUpdateRoute && idChanged && !this.loading,\n      ...opts,\n    };\n\n    this.data = data;\n    this.previousDataId = data.id || null;\n\n    await this.ready();\n    await this.setValue(data);\n\n    if (!opts || opts.emitEvent !== false) {\n      this.markAsPristine();\n      this.markAsUntouched();\n      this.updateViewState(data);\n\n      // Need to update route\n      if (opts.updateRoute === true) {\n        this.updateTabAndRoute(data, opts)\n          // Update the title - should be executed AFTER updateRoute because of path change - fix #185\n          .then(() => this.updateTitle(data));\n      } else {\n        // Update the next tab\n        this.updateTabIndex(opts.openTabIndex);\n\n        // Update the title.\n        this.updateTitle(data);\n      }\n\n      this.onUpdateView.emit(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.canUserWrite(data)) {\n      this.enable(opts);\n    } else {\n      this.disable(opts);\n\n      // Allow to sort tables\n      this.tables?.forEach((t) => t.enableSort());\n      this.asyncTables?.forEach((t) => t.enableSort());\n    }\n  }\n\n  /**\n   * Update the route location, and open the next tab\n   */\n  async updateTabAndRoute(\n    data: T,\n    opts?: {\n      openTabIndex?: number;\n    }\n  ): Promise<void> {\n    const queryParams = { ...this.queryParams };\n\n    // Open the next tab\n    this.updateTabIndex(opts && opts.openTabIndex);\n\n    if (!this.queryTabIndexParamName || !this.route) return; // Skip route update\n\n    // Update route location\n    queryParams[this.queryTabIndexParamName] = this.selectedTabIndex !== 0 ? this.selectedTabIndex : undefined;\n    await this.updateRoute(data, queryParams);\n  }\n\n  /**\n   * Update the route location, and open the next tab\n   */\n  updateTabIndex(tabIndex?: number) {\n    if (isNotNil(tabIndex) && tabIndex >= 0 && tabIndex !== this.selectedTabIndex) {\n      this.selectedTabIndex = tabIndex;\n      this.markForCheck();\n    }\n  }\n\n  async saveAndClose(event: Event, options?: any): Promise<boolean> {\n    const saved = await this.save(event);\n    if (saved) {\n      await this.close(event);\n    }\n    return saved;\n  }\n\n  async close(event: Event) {\n    if (event) {\n      if (event.defaultPrevented) return;\n      event.preventDefault();\n      event.stopPropagation();\n    }\n\n    return this.goBack();\n  }\n\n  /**\n   * Save the editor, by calling the dataService.save().\n   * Ensure that editor if valid. If not, display an error\n   *\n   * @param event\n   * @param opts\n   */\n  async save(event?: Event, opts?: any): Promise<boolean> {\n    if (this.loading || this.saving) {\n      console.debug('[data-editor] Skip save: editor is busy (loading or saving)');\n      return false;\n    }\n    if (!this.dirty && !this.isNewData) {\n      console.debug('[data-editor] Skip save: editor 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.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('[data-editor] Saving data...');\n\n    try {\n      // Compute next tab index (if enable)\n      const nextTabIndex = this._autoOpenNextTab && isNil(this.previousDataId) && this.computeNextTabIndex();\n\n      // Save all dirty tables\n      const saved = await this.saveDirtyChildren();\n      if (!saved) return false;\n\n      // Get data\n      const data = await this.getValue();\n\n      this.disable();\n\n      // Save form\n      const updatedData = await this.dataService.save(data, opts);\n\n      await this.onEntitySaved(updatedData);\n\n      // Update the view (e.g metadata)\n      await this.updateView(updatedData, {\n        // Open next tab only if user has not changed it\n        openTabIndex: nextTabIndex > this._selectedTabIndex ? nextTabIndex : undefined,\n        ...opts,\n      });\n\n      // Subscribe to remote changes\n      if (!this._listenChangesSubscription) this.startListenChanges();\n\n      this.submitted = false;\n\n      return true;\n    } catch (err) {\n      this.submitted = true;\n      this.selectedTabIndex = 0; // Can be override by subclasses, using setError()\n      this.setError(err);\n      this.scrollToTop(); // Scroll to top (to show error)\n      this.markAsDirty();\n      this.enable();\n\n      // Concurrent change on pod\n      if (err.code === ServerErrorCodes.BAD_UPDATE_DATE && isNotNil(this.data.id)) {\n        // Call a data reload (in background), to update the GraphQL cache, and allow to cancel changes\n        this.dataService.load(this.data.id, { fetchPolicy: 'network-only' }).then(() => {\n          console.debug('[data-editor] Data cache reloaded. User can reload page');\n        });\n      }\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      // 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): Promise<boolean> {\n    if (this.loading || this.saving) return false;\n\n    // Ask user confirmation\n    const confirmation = await Alerts.askDeleteConfirmation(this.alertCtrl, this.translate);\n    if (!confirmation) return;\n\n    console.debug('[data-editor] Asking to delete...');\n\n    this.markAsSaving();\n    this.resetError();\n\n    try {\n      // Get data\n      const data = await this.getValue();\n      const isNew = this.isNewData;\n\n      this.disable();\n\n      if (!isNew) {\n        await this.dataService.delete(data);\n      }\n\n      await this.onEntityDeleted(data);\n\n      // Remove page history\n      this.removePageHistory();\n    } catch (err) {\n      this.submitted = true;\n      this.selectedTabIndex = 0;\n      this.setError(err);\n      this.markAsSaved();\n      this.enable();\n      return false;\n    }\n\n    // Wait, then go back (wait is need in order to update back href is need)\n    await setTimeout(() => this.goBack(), 500);\n\n    return true;\n  }\n\n  async reload() {\n    this.markAsLoading();\n    await this.load(this.data?.id, { fetchPolicy: 'network-only' });\n  }\n\n  async unload(opts?: { emitEvent?: boolean }): Promise<void> {\n    await super.unload(opts);\n    this.stopListenChanges();\n    this.form.reset();\n    this.registerForms();\n    this.data = null;\n    // TODO: find a way to remove current page from the navigation history\n  }\n\n  async goBack(event?: Event): Promise<void | boolean> {\n    // Go back\n    if (this.toolbar?.canGoBack) {\n      return this.toolbar.goBack();\n    } else if (this.defaultBackHref) {\n      return this.navController.navigateBack(this.defaultBackHref);\n    } else {\n      // Back to home\n      return this.navController.navigateBack('/');\n    }\n  }\n\n  resetError(opts?: { emitEvent?: boolean }) {\n    super.resetError(opts);\n  }\n\n  setError(err: string | AppErrorWithDetails, opts?: { emitEvent?: boolean; detailsCssClass?: string }) {\n    if (!err) {\n      super.setError(undefined, opts);\n    } else if (typeof err === 'string') {\n      console.error('[entity-editor] Error: ' + (err || ''));\n      super.setError(err as string, opts);\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' ? (err.details as string) : err.details.message;\n      if (isNotNilOrBlank(detailMessage)) {\n        const cssClass = opts?.detailsCssClass || 'error-details';\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  /**\n   * Load data from the snapshot route\n   *\n   * @protected\n   */\n  protected loadFromRoute(): Promise<void> {\n    const route = this.route.snapshot;\n    if (!route || isNilOrBlank(this._pathIdAttribute)) {\n      throw new Error(\"Unable to load from route: missing 'route' or 'options.pathIdAttribute'.\");\n    }\n    let id = route.params[this._pathIdAttribute];\n    if (isNil(id) || id === 'new') {\n      return this.load(undefined, route.params);\n    } else {\n      // Convert as number, if need\n      if (isInt(id)) {\n        id = parseInt(id);\n      }\n      return this.load(id, route.params);\n    }\n  }\n\n  /**\n   * Return undefined to keep same tab\n   *\n   * @protected\n   */\n  protected computeNextTabIndex(): number | undefined {\n    const nextTabIndex = this.selectedTabIndex + 1;\n    return nextTabIndex < this.tabCount ? nextTabIndex : undefined;\n  }\n\n  protected async onBeforeEntityLoad(): Promise<void> {\n    // can be overwritten by subclasses\n  }\n\n  protected async onNewEntity(data: T, options?: EntityServiceLoadOptions): Promise<void> {\n    // can be overwritten by subclasses\n  }\n\n  protected async onEntityLoaded(data: T, options?: EntityServiceLoadOptions): Promise<void> {\n    // can be overwritten by subclasses\n  }\n\n  protected async onEntitySaved(data: T): Promise<void> {\n    // can be overwritten by subclasses\n  }\n\n  protected async onEntityDeleted(data: T): Promise<void> {\n    // can be overwritten by subclasses\n  }\n\n  protected computeUsageMode(data: T): UsageMode {\n    // can be overwritten by subclasses\n    // Using local settings default value\n    return this.settings.usageMode;\n  }\n\n  protected waitWhilePending(opts?: WaitForOptions): Promise<void> {\n    return AppFormUtils.waitWhilePending(this, opts);\n  }\n\n  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.titleSubject.next(title);\n\n    // If NOT data, then add to page history\n    if (!this.isNewData) {\n      const page = await this.computePageHistory(title);\n      if (page) return this.addToPageHistory(page);\n    }\n  }\n\n  protected async addToPageHistory(page: HistoryPageReference, opts?: AddToPageHistoryOptions) {\n    if (!page) return; // Skip\n\n    return this.settings.addToPageHistory(page, {\n      removePathQueryParams: true,\n      removeTitleSmallTag: true,\n      emitEvent: false,\n      ...opts,\n    });\n  }\n\n  protected async computePageHistory(title: string): Promise<HistoryPageReference> {\n    if (this.debug) console.debug('[entity-editor] Computing page history, using url: ' + this.router.url);\n    return {\n      title,\n      path: this.router.url,\n    };\n  }\n\n  protected async removePageHistory(opts?: { emitEvent?: boolean }) {\n    return this.settings.removePageHistory(this.router.url, opts);\n  }\n\n  protected computePageUrl(id: ID | 'new'): string | any[] {\n    const parentUrl = this.getParentPageUrl();\n    return parentUrl && `${parentUrl}/${id}`;\n  }\n\n  protected getParentPageUrl(withQueryParams?: boolean) {\n    let parentUrl = this.defaultBackHref;\n\n    // Remove query params\n    if (withQueryParams !== true && parentUrl && parentUrl.indexOf('?') !== -1) {\n      parentUrl = parentUrl.substring(0, parentUrl.indexOf('?'));\n    }\n\n    return parentUrl;\n  }\n\n  protected listenChanges(id: ID, opts?: any): Observable<T | undefined> {\n    return this.dataService.listenChanges(this.data.id, {\n      // Make sure to skip cache, because NOT the full graph will be fetched by subscription\n      // When a changes occur, we call reload() to force refetching the full graph\n      fetchPolicy: 'no-cache',\n      ...opts,\n    });\n  }\n\n  protected markForCheck() {\n    this.cd.markForCheck();\n  }\n\n  /**\n   * Update the route, without reloading the component\n   *\n   * @param data\n   * @param queryParams\n   * @protected\n   */\n  protected async updateRoute(data?: T, queryParams?: any): Promise<boolean> {\n    data = data || this.data;\n    if (!data || !this.route) return false;\n\n    const currId = this.route.snapshot.paramMap.get(this.pathIdAttribute);\n    const futureId = isNotNil(data.id) ? data.id.toString() : 'new';\n    if (queryParams) {\n      this.queryParams = {\n        ...this.queryParams,\n        ...queryParams,\n      };\n    }\n    if (currId === futureId) {\n      // Update queryParam only (not the path)\n      // /!\\ We should get query Params from the updated route, and not from snapshot that can be outdated\n      const actualQueryParams = await firstNotNilPromise(this.route.queryParams);\n      if (!equals(actualQueryParams, this.queryParams)) {\n        if (this.debug) console.debug(`${this._logPrefix}Updating route using queryParams: `, this.queryParams);\n        return await this.router.navigate(['.'], {\n          relativeTo: this.route,\n          replaceUrl: false,\n          queryParams: this.queryParams,\n          state: { animated: false },\n        });\n      }\n    } else {\n      const path = this.computePageUrl(isNotNil(data.id) ? data.id : 'new');\n      const commands: any[] = path && typeof path === 'string' ? path.split('/').slice(1) : (path as any[]);\n      if (isNotEmptyArray(commands)) {\n        // Current route was '/new' => change to '/new?id=:id' (to allow CustomReuseStrategy to detect that route can be reused)\n        if (currId === 'new' && this.queryParams[this.pathIdAttribute] !== futureId) {\n          if (this.debug) console.debug(`${this._logPrefix}Updating route /new into /:id, using queryParams: `, queryParams);\n          this.queryParams[this.pathIdAttribute] = futureId;\n          const res = await this.router.navigate(['.'], {\n            relativeTo: this.route,\n            replaceUrl: true,\n            queryParams: this.queryParams,\n            state: { animated: false },\n          });\n          if (!res) return false;\n        }\n\n        if (this.debug) console.debug(`${this._logPrefix}Updating route to: ` + path);\n        return await this.router.navigate(commands, {\n          replaceUrl: true,\n          queryParams: this.queryParams,\n          state: { animated: false },\n        });\n      }\n      return Promise.reject('Missing page URL');\n    }\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  /* -- protected abstract methods (to override) -- */\n\n  protected abstract computeTitle(data: T): Promise<string>;\n\n  protected abstract get form(): FormGroup;\n\n  protected abstract getFirstInvalidTabIndex(): number;\n\n  protected abstract registerForms(): void;\n\n  abstract setValue(data: T, opts?: { onlySelf?: boolean; emitEvent?: boolean }): Promise<void> | void;\n}\n"]}