@elasticias/screens 1.0.49 → 1.0.50

package/fesm2022/elasticias-screens.mjs

@@ -4,7 +4,7 @@ import { PersistedState, StorageUtils, AppUtils, CsvUtils } from '@elasticias/ut
 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 { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { TranslateService } from '@ngx-translate/core';
@@ -1575,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)
@@ -1585,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
@@ -2224,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');
@@ -2246,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.
@@ -2287,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.
      */
@@ -2452,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
@@ -2811,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'.