@sankhyalabs/core 5.20.0-dev.81 → 5.20.0-dev.83

package/src/dataunit/DataUnit.ts

@@ -55,6 +55,8 @@ export default class DataUnit {
     private _allowReleaseCallbacks: boolean;
     private _waitingToReload: boolean = false;
     private _cancelPagination: boolean = false;
+    private _isMultipleEdition: boolean = false;
+    private _fieldSourceValue: Map<string, string> = new Map<string, string>();
     
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
@@ -183,6 +185,21 @@ export default class DataUnit {
         this._cancelPagination = cancelPagination;
     }
 
+    /**
+     * Informa se o DataUnit está no modo de edição de múltiplos registros.
+     */
+    public get isMultipleEdition(): boolean {
+        return this._isMultipleEdition;
+    }
+
+    /**
+     * Define se o DataUnit está no modo de edição de múltiplos registros.
+     */
+    public set isMultipleEdition(isMultipleEdition) {
+        this._isMultipleEdition = isMultipleEdition;
+        this.dispatchAction(Action.MULTIPLE_EDITION_CHANGED, {isMultipleEdition});
+    }
+
     /**
      * 
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -1031,7 +1048,7 @@ export default class DataUnit {
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
 
-        if(!(newValue instanceof Promise) && ObjectUtils.hasEquivalentProps(currentValue, typedValue)){
+        if(this.areEquivalentValues(newValue, currentValue, typedValue)) {
             return Promise.resolve(false);
         }
 
@@ -1046,7 +1063,7 @@ export default class DataUnit {
             return promise;
         }
 
-        if (currentValue !== typedValue) {
+        if (this.isMultipleEdition || currentValue !== typedValue) {
             const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined, options);
             this._savingLockers.push(promise);
             return promise;
@@ -1055,6 +1072,12 @@ export default class DataUnit {
         return Promise.resolve(false);
     }
 
+    private areEquivalentValues(newValue: any, currentValue: any, typedValue: any) {
+        return !(newValue instanceof Promise)
+          && ObjectUtils.hasEquivalentProps(currentValue, typedValue)
+          && !this.isMultipleEdition;
+    }
+
     /**
      * 
      *  Marca campos como inválidos.
@@ -1265,7 +1288,7 @@ export default class DataUnit {
     public getSelectionInfo(): SelectionInfo{
         const selectionInfo: SelectionInfo = getSelectionInfo(this._stateManager);
         selectionInfo.getAllRecords = () => {
-
+           
             let records = this.allRecordsLoader?.(this) ?? [];
             
             if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
@@ -1938,6 +1961,21 @@ export default class DataUnit {
         this._allowReleaseCallbacks = allow;
     }
 
+
+    /**
+     * Adiciona um mapeamento de origem dos dados de um determinado campo
+     */
+    public addSourceFieldValue(sourceFieldName:string, targetFieldName:string): void{
+        this._fieldSourceValue.set(sourceFieldName, targetFieldName);
+    }
+
+     /**
+     * Retornar o campo de origem dos dados caso exista mapeamento
+     */
+     public getSourceFieldValue(targetFieldName:string): string | undefined{
+        return this._fieldSourceValue.get(targetFieldName);
+    }
+
     private async processLoadingLockers(){
         if(this._loadingLockers.length) {
             await Promise.all(this._loadingLockers);

package/src/dataunit/metadata/DataType.ts

@@ -148,7 +148,7 @@ const isSearchField = (userInterface:UserInterface | undefined): boolean => {
     return userInterface === UserInterface.SEARCH || userInterface === UserInterface.SEARCHPLUS;
 }
 
-export const compareValues = (valueA: any, valueB: any, descriptor: FieldDescriptor): number => {
+export const compareValues = (valueA: any, valueB: any, descriptor: FieldDescriptor, onlyLabel:boolean = false): number => {
     
     if(useStringForComparison(descriptor)){
         return (getFormattedValue(valueA, descriptor) as string).localeCompare(getFormattedValue(valueB, descriptor));
@@ -156,8 +156,8 @@ export const compareValues = (valueA: any, valueB: any, descriptor: FieldDescrip
 
     const {dataType, userInterface} = descriptor;
     if(isSearchField(userInterface) || userInterface === UserInterface.OPTIONSELECTOR){
-        const optionValueA = valueA?.value || valueA;
-        const optionValueB = valueB?.value || valueB;
+        const optionValueA = (onlyLabel ? valueA?.label : valueA?.value) || valueA;
+        const optionValueB = (onlyLabel ? valueB?.label : valueB?.value) || valueB;
         if(isNaN(optionValueA) || isNaN(optionValueB)){
             return (optionValueA as string).localeCompare(optionValueB);
         }

package/src/dataunit/sorting/FieldComparator.ts

@@ -4,16 +4,16 @@ import { FieldDescriptor } from '../metadata/UnitMetadata.js';
 
 export class FieldComparator {
 
-  public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number {
+  public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true, onlyLabel: boolean = false): number {
     const valueA = (asc ? recordA : recordB)[field.name];
     const valueB = (asc ? recordB : recordA)[field.name];
 
-    return FieldComparator.compareValues(field, valueA, valueB);
+    return FieldComparator.compareValues(field, valueA, valueB, onlyLabel);
   }
 
-  public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number {
+  public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any, onlyLabel: boolean = false): number {
     const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
-    return (undefinedComparison != undefined) ? undefinedComparison : compareValues(valueA, valueB, descriptor);
+    return (undefinedComparison != undefined) ? undefinedComparison : compareValues(valueA, valueB, descriptor, onlyLabel);
   }
 
   public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {

package/src/dataunit/state/action/DataUnitAction.ts

@@ -26,6 +26,8 @@ export interface ExecutionContext{
 
 export enum Action{
 
+    MULTIPLE_EDITION_CHANGED = "multipleEditionChanged",
+
     LOADING_METADATA = "loadingMetadata",
     METADATA_LOADED = "metadataLoaded",
     

package/src/utils/SortingUtils.ts

@@ -17,7 +17,16 @@ export default class SortingUtils {
         return (recordA, recordB) => {
             for (const sort of sorting) {
                 if (sort.field){
-                    const result = FieldComparator.compare(dataUnit.getField(sort.field) as FieldDescriptor, recordA, recordB, sort.mode === SortMode.ASC);
+                    let field = dataUnit.getField(sort.field) as FieldDescriptor;
+                    let onlyLabel = false;
+                    if(!field){
+                        const sourceFieldName = dataUnit.getSourceFieldValue(sort.field) ?? "";
+
+                        field = dataUnit.getField(sourceFieldName) as FieldDescriptor;
+                        onlyLabel = true;
+                    }
+
+                    const result = FieldComparator.compare(field, recordA, recordB, sort.mode === SortMode.ASC, onlyLabel);
                     if (result != 0) {
                         return result;
                     }