@sankhyalabs/core 5.17.3 → 5.18.0-ms.1

package/src/dataunit/DataUnit.ts

@@ -26,6 +26,9 @@ import { v4 as uuid } from "uuid";
 import { DataUnitStorage } from "./DataUnitStorage.js";
 import { getInvalidFieldMessage, InvalidFieldsReducer } from "./state/slice/InvalidFieldsSlice.js";
 import { getLoadingProperties, LoadingPropertiesReducer } from "./state/slice/LoadingProperties.js";
+import SortingUtils from "../utils/SortingUtils.js";
+import ServiceCanceledException from "../exceptions/ServiceCanceledException.js";
+import SilentException from "../exceptions/SilentException.js";
 
 /***
  * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
@@ -33,11 +36,12 @@ import { getLoadingProperties, LoadingPropertiesReducer } from "./state/slice/Lo
 export default class DataUnit {
     
     public static CHANGING_PAGE_LOADING_SOURCE = "CHANGING_PAGE_LOADING_SOURCE";
+    public static ALL_RECORDS_SELECTION_SOURCE = "ALL_RECORDS_SELECTION_SOURCE";
     public static DEFAULT_DATAUNIT_NAME = "dataunit";
 
     private _uuid: string;
     private _name: string;
-    private _observers: Array<(action: DataUnitAction, options?:DataUnitEventOptions) => void>;
+    private _observers: Map<string, (action: DataUnitAction, options?: DataUnitEventOptions) => void>;
     private _sortingProvider?: SortingProvider;
     private _filterProviders: Map<string, FilterProvider>;
     private _stateManager: StateManager;
@@ -49,12 +53,15 @@ export default class DataUnit {
     private _savingLockers: Promise<any>[] = [];
     private _defaultSorting: Array<Sort>;
     private _allowReleaseCallbacks: boolean;
+    private _waitingToReload: boolean = false;
+    private _cancelPagination: boolean = false;
     
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
     public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
     public removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
     public recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
+    public allRecordsLoader?: (dataUnit: DataUnit) => Array<Record> | undefined;
 
     constructor(name: string = DataUnit.DEFAULT_DATAUNIT_NAME, parentDataUnit?: DataUnit) {
         this._uuid = uuid()
@@ -76,7 +83,7 @@ export default class DataUnit {
                 SnapshotReducer
             ]
         );
-        this._observers = [];
+        this._observers = new Map();
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
         this._defaultSorting = [];
@@ -114,7 +121,7 @@ export default class DataUnit {
     public releaseCallbacks(){
         if(!this._allowReleaseCallbacks) return;
 
-        this._observers = [];
+        this._observers = new Map();
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
         this._interceptors = new Map();
@@ -146,6 +153,36 @@ export default class DataUnit {
         return this._uuid;
     }
 
+
+    /**
+     * Retorna se o dataUnit está com recarregamento pendente.
+     */
+    public isWaitingToReload(): boolean {
+        return this._waitingToReload;
+    }
+
+    /**
+     * Define se o dataUnit tem um recarregamento pendente.
+     * @param isWaiting
+     */
+    public setWaitingToReload(isWaiting: boolean){
+        this._waitingToReload = isWaiting;
+    }
+
+    /**
+     * Informa se a paginação deve ser cancelada.
+     */
+    public get cancelPagination(): boolean {
+        return this._cancelPagination;
+    }
+
+    /**
+     * Informa se a paginação deve ser cancelada.
+     */
+    public set cancelPagination(cancelPagination: boolean) {
+        this._cancelPagination = cancelPagination;
+    }
+
     /**
      * 
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -350,6 +387,9 @@ export default class DataUnit {
      * 
     */
     public async gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+        if(this._pageSize === 0) {
+            return;
+        }
 
         let request = getCurrentRequest(this._stateManager);
 
@@ -482,6 +522,14 @@ export default class DataUnit {
                                     const {errorCode} = cause;
                                     this.dispatchAction(Action.SAVING_ERROR);
                                     this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                                    if(cause instanceof ServiceCanceledException){
+                                        console.debug("Service canceled: " + cause.message);
+                                        resolve();
+                                    } 
+                                    if(cause instanceof SilentException){
+                                        fail(cause);
+                                        return;
+                                    }
                                     fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
                                 });
                             } else {
@@ -551,8 +599,8 @@ export default class DataUnit {
             if(selection.isAllRecords()){
                 throw new Error("Exclusão remota não implementada.");
             }
-            const records = selection?.records || [];
-            const recordIds = selection?.recordIds || [];
+            const records = selection?.records as Array<Record> || [];
+            const recordIds = selection?.recordIds as Array<string> || [];
             return this.removeRecords(recordIds, records, buffered, undefined, silent);
         }
         return Promise.resolve([]);
@@ -655,13 +703,13 @@ export default class DataUnit {
     */
     public getFormattedValue(fieldName: string, value?: any): string {
         const descriptor = this.getField(fieldName);
-        if (value === undefined) {
+        if (value == undefined) {
             value = this.getFieldValue(fieldName);
         } else if (typeof value === "string" && descriptor?.dataType != DataType.TEXT){
             value = this.valueFromString(fieldName, value);
         }
 
-        if(value === undefined){
+        if(value == undefined){
             return "";
         }
 
@@ -732,6 +780,7 @@ export default class DataUnit {
         return this.dispatchAction(Action.PAGINATION_UPDATED, info, undefined);
     }
 
+
     /**
      * 
      * Define a lógica de ordenação dos registros.
@@ -796,7 +845,8 @@ export default class DataUnit {
      * 
      */
     public set records(records: Array<Record>) {
-        this.dispatchAction(Action.DATA_LOADED, { records }, undefined);
+        const paginationInfo = this.getPaginationInfo();
+        this.dispatchAction(Action.DATA_LOADED, { records, paginationInfo }, undefined);
     }
 
     /**
@@ -889,8 +939,12 @@ export default class DataUnit {
     public copySelected(executionCtx?: ExecutionContext): void {
         const selectionInfo = this.getSelectionInfo();
         if (selectionInfo) {
-            const selectedRecords = selectionInfo.records;
+            if(selectionInfo.isAllRecords()){
+                throw new Error("Erro interno: Impossível copiar os registros selecionados pois a seleção atual é virtual.");
+            }
+            const selectedRecords = selectionInfo.records as Array<Record>;
             if(selectedRecords){
+                
                 this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
             }
         }
@@ -956,21 +1010,31 @@ export default class DataUnit {
      * @param fieldName -Identificador do campo a ser modificado.
      * @param newValue - Valor a ser inserido no campo.
      * @param records - Indica quais registros foram afetados pela alteração no valor do campo.
+     * @param options - Configurações do evento
      * @returns - Promise que será resolvida quando o novo valor for persistido no state.
-     * 
-    */
+     *
+     */
     public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>, options?:DataUnitEventOptions): Promise<boolean> {
+        const noRecordSelected = !this.hasNewRecord() && !this.getSelectedRecord();
+
+        const suppressCreateNewRecord = options?.suppressCreateNewRecord;
+
+        if(noRecordSelected && suppressCreateNewRecord) return Promise.resolve(false);
+
+        if(noRecordSelected) await this.addRecord();
 
-        if(!this.hasNewRecord() && !this.getSelectedRecord())  await this.addRecord();
-        
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
-        
+
+        if(!(newValue instanceof Promise) && ObjectUtils.hasEquivalentProps(currentValue, typedValue)){
+            return Promise.resolve(false);
+        }
+
         if(newValue instanceof Promise){
             const promise:Promise<boolean> = new Promise(accept => {
                 newValue.then(resolvedValue => {
                     this.dispatchAction(Action.DATA_RESOLVED, { [fieldName]: resolvedValue, records }, undefined);
-                    accept(this.setFieldValue(fieldName, resolvedValue, records));
+                    accept(this.setFieldValue(fieldName, resolvedValue, records,  options));
                 });
             });
             this._savingLockers.push(promise);
@@ -999,6 +1063,18 @@ export default class DataUnit {
         this.dispatchAction(Action.FIELD_INVALIDATED, { fieldName, message, recordId }, undefined);
     }
 
+    /**
+     * 
+     *  Cancela o saving exibindo os campos invalidos.
+     * 
+     * @param filds - Lista dos campos
+     * @param recordId - Indica qual registro está com os campos inválido.
+     * 
+    */
+    public savingCanceled(fields: Array<{name: string, message: string}>, recordId: string): void {
+        this.dispatchAction(Action.SAVING_CANCELED, { fields, recordId }, undefined);
+    }
+
     /**
      * 
      *  Limpa campos inválidos.
@@ -1106,7 +1182,7 @@ export default class DataUnit {
     public setSelection(selection: Array<string> | SelectionMode.ALL_RECORDS, executionCtx?: ExecutionContext): Promise<SelectionInfo> {
         return new Promise(resolve => {
             this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx)
-                .then(()=>resolve(getSelectionInfo(this._stateManager)));
+                .then(()=>resolve(this.getSelectionInfo()));
         });
     }
 
@@ -1127,35 +1203,53 @@ export default class DataUnit {
      * 
      * @param selection - IDs dos registros selecionados no snapshot atual
      * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
-     * 
      * @returns - Informações sobre a seleção.
     */
     public updatePageSelection(selection: Array<string>, executionCtx?: ExecutionContext): Promise<SelectionInfo|undefined>{
-
-        if(!selection){
-            return Promise.resolve(this.getSelectionInfo());
-        }
+        if(!selection) return Promise.resolve(this.getSelectionInfo());
 
         return new Promise(resolve => {
-            const newSelection: Set<string> = new Set(getSelection(this._stateManager));
-            const currentRecords = getCurrentRecords(this._stateManager) || new Map();
-            Array.from(currentRecords.keys()).forEach(
-                recordId => {
-                    if(selection.includes(recordId)){
-                        newSelection.add(recordId);
-                    } else {
-                        newSelection.delete(recordId);
-                    }
-                }
-            );
+            const newSelection: Set<string> = new Set(selection);
 
             this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) }, executionCtx)
-                .then(()=>{
-                    resolve(this.getSelectionInfo())
-                });
+                .then(()=> resolve(this.getSelectionInfo()));
+        });
+    }
+
+
+    private updatePageSelectionAll(addRecords: boolean): Promise<SelectionInfo|undefined>{
+        return new Promise(resolve => {
+            const newSelection: Set<string> = new Set<string>();
+
+            const cachedSelection = getSelection(this._stateManager);
+            cachedSelection.forEach(item => newSelection.add(item));
+
+            const recordsIds = this.records.map(r => r.__record__id__);
+            recordsIds.forEach(id => addRecords ? newSelection.add(id): newSelection.delete(id));
+
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) })
+              .then(()=> resolve(this.getSelectionInfo()));
         });
     }
 
+    /**
+     * Seleciona todos os registros da página.
+     *
+     * @returns - Informações sobre a seleção.
+     */
+     public selectAllRecords(): Promise<SelectionInfo|undefined>{
+         return this.updatePageSelectionAll(true);
+    }
+
+    /**
+     * Desseleciona todos os registros da página.
+     *
+     * @returns - Informações sobre a seleção.
+     */
+     public unSelectAllRecords(): Promise<SelectionInfo|undefined>{
+        return this.updatePageSelectionAll(false);
+     }
+
     /**
      * 
      * Obtém informações sobre a seleção atual.
@@ -1163,8 +1257,16 @@ export default class DataUnit {
      * @returns - Objeto com informações como registros selecionados e seleção por critério.
      * 
      **/ 
-    public getSelectionInfo(): SelectionInfo | undefined {
-        return getSelectionInfo(this._stateManager)
+    public getSelectionInfo(): SelectionInfo{
+        const selectionInfo: SelectionInfo = getSelectionInfo(this._stateManager);
+        selectionInfo.getAllRecords = () => this.allRecordsLoader?.(this);
+
+        if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
+            const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
+            selectionInfo.records?.sort(sortingFunction)
+        }
+
+        return selectionInfo;
     }
 
     /**
@@ -1520,10 +1622,7 @@ export default class DataUnit {
         this._stateManager.process(action);
         this?._parentDataUnit?.dispatchAction(Action.CHILD_CHANGED, { srcAction: action, srcDataUnit: this });
         this._observers.forEach(f => {
-            /* 
-            if some observer throws exceptions,
-            should be continued
-            */
+            //if some observer throws exceptions, should be continued
             try {
                 f(action, options);
             } catch (e) {
@@ -1562,10 +1661,17 @@ export default class DataUnit {
      * Ela vai ser chamada sempre que uma ação for despachada (dispatchAction()).
      * 
      * @param observer - Função que recebe como parâmetro as ações que serão monitoradas.
-     * 
+     * @param uuid - Identificador do observer. Quando não informado, será gerado um identificador aleatório.
     */
-    public subscribe(observer: (action: DataUnitAction, options?:DataUnitEventOptions) => void | Promise<void>) {
-        this._observers.push(observer);
+    public subscribe(observer: (action: DataUnitAction, options?: DataUnitEventOptions) => void | Promise<void>, uuid?: string): string {
+        if (uuid) {
+            this._observers.set(uuid, observer);
+        } else {
+            uuid = StringUtils.generateUUID();
+            this._observers.set(uuid, observer);
+        }
+
+        return uuid;
     }
 
     /**
@@ -1573,10 +1679,18 @@ export default class DataUnit {
      * Remove um observer existente.
      * 
      * @param observer - Observer que se deseja remover.
-     * 
+     * @param uuid - Identificador do observer. Quando não informado o delete removera com base no equals do observer.
     */
-    public unsubscribe(observer: Function) {
-        this._observers = this._observers.filter(f => f !== observer);
+    public unsubscribe(observer: Function, uuid?: string) {
+        if (uuid) {
+            this._observers.delete(uuid);
+        } else {
+            this._observers.forEach((valor, chave) => {
+                if (valor == observer) {
+                    this._observers.delete(chave);
+                }
+            });
+        }
     }
 
     /**
@@ -1589,18 +1703,21 @@ export default class DataUnit {
     public reloadCurrentRecord(): Promise<Array<Record>>{        
         return new Promise(async (resolve, fail) => {
             const selection = getSelection(this._stateManager);
-            this.dispatchAction(Action.LOADING_RECORD, selection);
+            await this.dispatchAction(Action.LOADING_RECORD, selection);
             
             if(!this.recordLoader || !this.dataLoader) {
-                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                resolve([]);
                 return;
             }
             
-            this.recordLoader(this, selection).then(response => {
-                this.dispatchAction(Action.RECORD_LOADED, response)
-                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
-            }).catch(cause => {
-                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+            this.recordLoader(this, selection).then(async response => {
+                await this.dispatchAction(Action.RECORD_LOADED, response)
+                await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+
+                resolve(response);
+            }).catch(async cause => {
+                await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                 const {errorCode} = cause;
                 fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
             });
@@ -1695,11 +1812,12 @@ export default class DataUnit {
      * @param fieldName - nome do campo para ficar invisível.
      * 
     */
-    public hideField(fieldName:string) {
+    public hideField(fieldName:string, options:HideFieldOptions) {
         const fieldDescriptor = this.getField(fieldName);
 
         if(fieldDescriptor?.visible === true){
             fieldDescriptor.visible = false;
+            fieldDescriptor.properties = {...fieldDescriptor.properties, visibleOnConfig: options.visibleOnConfig };
             this.metadata = {...this.metadata};
         }
     }
@@ -1739,7 +1857,7 @@ export default class DataUnit {
         }
 
         if (selection) {
-            return selection.records;
+            return selection.records as Array<Record>;
         }
     }
 
@@ -1757,12 +1875,15 @@ export default class DataUnit {
     public getSelection(): Array<string> {
         console.warn("DataUnit: O método `getSelection` foi descontinuado. Use o método `getSelectionInfo`.");
         const selection = this.getSelectionInfo();
+        if(selection == undefined){
+            return [];
+        }
 
-        if(selection != undefined && selection.isAllRecords()){
+        if(selection.isAllRecords()){
             throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
         }
 
-        return selection?.recordIds || [];
+        return selection?.recordIds as Array<string>;
     }
 
     /**
@@ -1943,12 +2064,13 @@ export enum SelectionMode{
 
 export class SelectionInfo{
 
-    private _records: Array<Record>;
     public mode: SelectionMode;
-    private _total?: number;
     public filters?: Array<Filter>;
     public sort?: Array<Sort>;
-
+    public getAllRecords?: () => Array<Record> | undefined;
+    private _records: Array<Record>;
+    private _total?: number;
+    
     constructor(records: Array<Record>, mode: SelectionMode = SelectionMode.SOME_RECORDS, total?:number, filters?: Array<Filter>, sort?: Array<Sort>){
         this._records = records;
         this._total = total;
@@ -1959,7 +2081,10 @@ export class SelectionInfo{
 
     public get records(): Array<Record> | undefined{
         if(this.isAllRecords()){
-            throw new Error("Erro interno: [ALL_RECORDS] - Impossível retornar os registros selecionados numa seleção virtual.")
+            if(this.getAllRecords != undefined){
+                return this.getAllRecords();
+            }
+            throw new Error("Erro interno: Impossível retornar os registros selecionados numa seleção virtual.");
         }
         return this._records;
     }
@@ -1978,7 +2103,7 @@ export class SelectionInfo{
         if(this.isAllRecords()){
             return this._total || 0;
         }
-        return this.records == undefined ? 0: this.records.length;
+        return this.records == undefined ? 0 : (this.records as Array<Record>).length;
     }
 
     public isAllRecords(): boolean{
@@ -1990,4 +2115,8 @@ export class SelectionInfo{
     }
 }
 
-export type DataUnitEventOptions = {[key:string]: any};
+export type DataUnitEventOptions = {[key:string]: any};
+
+export type HideFieldOptions = {
+    visibleOnConfig: boolean
+};

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -1,6 +1,7 @@
 import DateUtils from '../../utils/DateUtils.js';
 import { MaskFormatter } from '../../utils/MaskFormatter.js';
 import { NumberUtils } from '../../utils/NumberUtils.js';
+import { TimeFormatter } from '../../utils/TimeFormatter.js';
 import { DataType, toString } from '../metadata/DataType.js';
 import { FieldDescriptor, UserInterface } from '../metadata/UnitMetadata.js';
 
@@ -13,7 +14,10 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
         if(value && Object.hasOwn(value, "value")){
             return getSearchFormat(value, descriptor);
         }
-        return !value ? "" : value.toString();
+
+        if(value === null || value === undefined) return  "";
+
+        return value.toString();
     }
 
     if(descriptor?.userInterface === UserInterface.OPTIONSELECTOR){
@@ -36,6 +40,10 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
         return DateUtils.formatTime(value);
     }
 
+    if(descriptor?.userInterface === UserInterface.ELAPSEDTIME){
+        return TimeFormatter.prepareValue(value, true);
+    }
+
     if(descriptor?.userInterface === UserInterface.DATETIME){
         return DateUtils.formatDateTime(value);
     }
@@ -43,7 +51,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     const mask = getMask(value, descriptor);
     if(mask != undefined){
         try{
-            return new MaskFormatter(mask).format(value);
+            return new MaskFormatter(mask).format(value, true);
         } catch(error){
             console.warn(`Erro ao formatar valor: ${value}. Mascara: ${mask}. Erro: ${error}`);
         }

package/src/dataunit/loader/DataUnitInMemoryLoaderConfig.ts

@@ -0,0 +1,10 @@
+export interface DataUnitInMemoryLoaderConfig {
+  autoLoad?: boolean;
+  pageSize?: number;
+  recordDateFormat?: RECORD_DATE_FORMAT;
+}
+
+export enum RECORD_DATE_FORMAT {
+  DD_MM_YYYY = 'DD/MM/YYYY',
+  ISO = 'ISO'
+}