@elasticias/screens 1.0.48 → 1.0.50

package/fesm2022/elasticias-screens.mjs

@@ -1,13 +1,13 @@
 import * as i0 from '@angular/core';
-import { Input, Component, signal, InjectionToken, inject, ChangeDetectorRef, ViewChild, Injector, computed, DestroyRef } from '@angular/core';
+import { Input, Component, signal, InjectionToken, inject, ChangeDetectorRef, ViewChild, Injector, DestroyRef, computed } from '@angular/core';
 import { PersistedState, StorageUtils, AppUtils, CsvUtils } from '@elasticias/utils';
-import { Subject, combineLatest, take, merge, map, distinctUntilChanged } from 'rxjs';
+import { Subject, combineLatest, take, from, merge, map, distinctUntilChanged } from 'rxjs';
 import { Permissions } from '@elasticias/types';
 import { Router, ActivatedRoute } from '@angular/router';
-import { CacheService, ToastService, ConfirmDialogService, EfShortcutService } from '@elasticias/core';
+import { CacheService, ToastService, ConfirmDialogService, EfShortcutService, isServerReported, extractProblem } from '@elasticias/core';
 import { Location } from '@angular/common';
-import { TranslateService } from '@ngx-translate/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { TranslateService } from '@ngx-translate/core';
 
 class AbstractEntity {
     clone(entity) {
@@ -1054,6 +1054,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
 class AbstractSearchScreenV2 extends AbstractScreenComponent {
     screenState = ScreenStateEnum.SEARCH;
     injector = inject(Injector);
+    destroyRef = inject(DestroyRef);
+    /**
+     * A delete confirm is loading or open. A second click (or the row
+     * shortcut) meanwhile is ignored, so one gesture cannot start two impact
+     * reads or stack two confirms. Cleared when the confirm is answered
+     * (PrimeNG calls reject on close and Escape too) or when the read
+     * yields no confirm.
+     */
+    deleteConfirmBusy = false;
     serviceInstance;
     /**
      * Translate lazily, through the injector.
@@ -1566,6 +1575,7 @@ class AbstractSearchScreenV2 extends AbstractScreenComponent {
                 this.totalCount.set(result?.totalCount ?? 0);
                 this.cacheService.setCache(this.screenStateKey, this.criteria());
                 this.loading.set(false);
+                this.afterSearch(result);
             },
             error: (err) => {
                 if (seq !== this.searchSeq)
@@ -1576,6 +1586,15 @@ class AbstractSearchScreenV2 extends AbstractScreenComponent {
             },
         });
     }
+    /**
+     * Hook for a screen whose search returns more than a page of rows (counts,
+     * facets, a summary): called with the raw response after `items` and
+     * `totalCount` are set, for the latest issued search only. A stale or
+     * failed search never reaches it.
+     */
+    afterSearch(_result) {
+        /* no-op by default */
+    }
     /* ── Convenience criteria mutators ───────────────────────────── */
     setSearchText(text) {
         // Templates bind this to ef-smart-bar's (search), and that binding has
@@ -1818,29 +1837,93 @@ class AbstractSearchScreenV2 extends AbstractScreenComponent {
     getDeleteConfirmName(_id) {
         return undefined;
     }
+    /**
+     * Async details for the delete confirmation, read before it opens. Use
+     * it when the confirm has to say what the delete will take with it, such
+     * as how many products lose a collection:
+     *
+     * ```ts
+     * protected override getDeleteConfirmOptions(id: any) {
+     *   return this.collectionsClient.deleteImpact(id).pipe(
+     *     map(impact => ({
+     *       messageKey: impact.onHome ? 'x_delete_message_home' : 'x_delete_message',
+     *       messageParams: { count: impact.productCount ?? 0 },
+     *     })),
+     *   );
+     * }
+     * ```
+     *
+     * The returned options are merged over `{ intent: 'delete', name:
+     * getDeleteConfirmName(id) }`. Only the first value of an Observable is
+     * used. If the read fails (the HTTP interceptor toasts it) or completes
+     * without a value, no confirm opens and nothing is deleted. Return
+     * `undefined`, the default, to open the confirm at once. While the read
+     * is in flight or the confirm is open, another delete is ignored, and a
+     * screen destroyed during the read opens nothing.
+     */
+    getDeleteConfirmOptions(_id) {
+        return undefined;
+    }
     delete(id) {
         if (!id) {
             this.recordNotFound();
             return;
         }
+        if (this.deleteConfirmBusy)
+            return;
+        this.deleteConfirmBusy = true;
+        const details = this.getDeleteConfirmOptions(id);
+        if (!details) {
+            this.openDeleteConfirm(id, {});
+            return;
+        }
+        let opened = false;
+        from(details)
+            // A screen left while the read was in flight opens nothing.
+            .pipe(take(1), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: (extra) => {
+                opened = true;
+                this.openDeleteConfirm(id, extra ?? {});
+            },
+            // A failed read is the interceptor's to report; without its details
+            // the confirm would understate what the delete takes with it.
+            error: () => {
+                this.deleteConfirmBusy = false;
+            },
+            complete: () => {
+                if (!opened)
+                    this.deleteConfirmBusy = false;
+            },
+        });
+    }
+    openDeleteConfirm(id, extra) {
+        const { accept: _a, reject: _r, intent: _i, ...details } = extra;
         this.confirmDialogService.confirm({
             intent: 'delete',
             name: this.getDeleteConfirmName(id),
-            accept: () => this.serviceInstance.delete(id).subscribe({
-                next: (result) => {
-                    if (result?.errors?.length) {
-                        this.handleErrors(result.errors);
-                    }
-                    else {
-                        this.search();
-                        this.toastService.showSuccess();
-                    }
-                },
-                // The HTTP error interceptor surfaces the message (toast). Swallow
-                // here so a rejected delete (e.g. a 422 business-rule violation)
-                // doesn't bubble up as an unhandled error.
-                error: () => undefined,
-            }),
+            ...details,
+            reject: () => {
+                this.deleteConfirmBusy = false;
+            },
+            accept: () => {
+                this.deleteConfirmBusy = false;
+                this.serviceInstance.delete(id).subscribe({
+                    next: (result) => {
+                        if (result?.errors?.length) {
+                            this.handleErrors(result.errors);
+                        }
+                        else {
+                            this.search();
+                            this.toastService.showSuccess();
+                        }
+                    },
+                    // The HTTP error interceptor surfaces the message (toast). Swallow
+                    // here so a rejected delete (e.g. a 422 business-rule violation)
+                    // doesn't bubble up as an unhandled error.
+                    error: () => undefined,
+                });
+            },
         });
     }
     duplicate(id) {
@@ -2151,14 +2234,7 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
         }
         this.loadSub?.unsubscribe();
         this.loadSub = this.serviceInstance.get(id).subscribe({
-            next: (result) => {
-                const vm = new ViewModelEntity(result);
-                vm.id = id;
-                this.entity.set(vm);
-                this.loading.set(false);
-                this.afterLoad();
-                this.loadAuditHistory();
-            },
+            next: (result) => this.applyLoaded(result, id),
             error: (err) => {
                 console.error('AbstractDetailScreenV2.loadData failed', err);
                 this.errorMsg.set(err?.message ?? 'Erreur de chargement');
@@ -2173,6 +2249,15 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
             },
         });
     }
+    /** Install a fetched (or save-returned) record as the current entity. */
+    applyLoaded(result, id) {
+        const vm = new ViewModelEntity(result);
+        vm.id = id;
+        this.entity.set(vm);
+        this.loading.set(false);
+        this.afterLoad();
+        this.loadAuditHistory();
+    }
     /**
      * Persist the entity. Routes to `service.create()` when in new
      * or duplicate mode, `service.update(id, entity)` when editing.
@@ -2214,9 +2299,44 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
                     this.setFormErrors(response.errors);
                     this.onSaveError(response.errors);
                 }
+                if (!isCreate && this.isStaleSave(response))
+                    this.offerStaleReload();
             },
         });
     }
+    /**
+     * True when a failed save means the record changed since it was loaded:
+     * a refusal whose `ruleCode` is in the config's `STALE_RULE_CODES`. A bare
+     * 409 is a duplicate (e.g. a slug already taken), not a stale record, so
+     * it never offers a reload. Only a refusal
+     * the app's interceptor already toasted counts, so the user is never
+     * told twice.
+     */
+    isStaleSave(error) {
+        if (!isServerReported(error))
+            return false;
+        const problem = extractProblem(error);
+        if (!problem)
+            return false;
+        const codes = this.getConfig()?.STALE_RULE_CODES ?? [];
+        return !!problem.ruleCode && codes.includes(problem.ruleCode);
+    }
+    /**
+     * Asks, in an accessible confirm dialog (focus trapped, Escape cancels),
+     * whether to reload the record. Accepting discards the unsaved edits,
+     * and the message says so. The refusal itself was already toasted.
+     * App keys: `ef_stale_reload` (button), `ef_stale_reload_confirm`
+     * (message) and optionally `ef_stale_reload_header`.
+     */
+    offerStaleReload() {
+        this.confirmDialogService.confirm({
+            messageKey: 'ef_stale_reload_confirm',
+            headerKey: 'ef_stale_reload_header',
+            acceptLabelKey: 'ef_stale_reload',
+            icon: 'pi pi-refresh',
+            accept: () => this.loadData(),
+        });
+    }
     /**
      * Soft-delete-then-navigate-back. Confirms with the user first.
      */
@@ -2379,9 +2499,24 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
             this.router.navigate([this.detailsBaseUrl(), newId]);
         }
         else {
-            // Update succeeded in place — refresh the change-history so the new
-            // entry shows without a manual reload.
-            this.loadAuditHistory();
+            if (cfg?.RELOAD_AFTER_SAVE) {
+                // The record carries server-owned state (a concurrency
+                // revision): take the fresh copy. An update response that is
+                // the saved record itself (same id) is used as is, anything
+                // else (void, id, flag) triggers one GET. Both refresh history.
+                const id = this.entityId();
+                if (result && typeof result === 'object' && String(result.id) === String(id)) {
+                    this.applyLoaded(result, id);
+                }
+                else {
+                    this.loadData();
+                }
+            }
+            else {
+                // Update succeeded in place — refresh the change-history so the new
+                // entry shows without a manual reload.
+                this.loadAuditHistory();
+            }
         }
     }
     /** Override to surface form-level validation errors after a 4xx
@@ -2738,6 +2873,24 @@ class ScreenConfig {
      * to opt out. Must match the backend IAuditable.AuditEntityType (e.g. 'Client').
      */
     AUDIT_ENTITY_TYPE;
+    /**
+     * Detail screens: business-rule codes (422 `ruleCode`) meaning "the record
+     * changed since you loaded it", e.g. ERP `['BR_SO_0123']`. A failed update
+     * with one of them offers a "reload" confirm; accepting
+     * reloads the record and drops the unsaved edits. The app must define the
+     * i18n keys `ef_stale_reload` (button), `ef_stale_reload_confirm` (message,
+     * say that unsaved edits are lost) and `ef_stale_reload_header`.
+     */
+    STALE_RULE_CODES;
+    /**
+     * Detail screens: after a successful in-place update (not a create or
+     * duplicate) refresh the record, so server-owned fields such as a
+     * concurrency revision are current for the next save. Uses the update
+     * response when it is the saved record (an object whose `id` is the
+     * screen's entity id), otherwise one `get(id)`. Change history reloads
+     * either way. Default false: the record is left as edited.
+     */
+    RELOAD_AFTER_SAVE;
     /**
      * Report screens (AbstractReportScreenV2): starting period preset for the
      * screen's ef-datepicker-advanced. Unset → 'last_30_days'.