@sankhyalabs/core 1.0.23 → 1.0.26

package/src/dataunit/DataUnit.ts

@@ -1,11 +1,11 @@
-import { UnitMetadata, FieldMetadata } from "./metadata/UnitMetadata";
+import { UnitMetadata, FieldDescriptor, SortingProvider, FilterProvider, Sort, Filter } from "./metadata/UnitMetadata";
 import { convertType } from "./metadata/DataType";
 
 import { DataUnitAction, Action } from "./state/action/DataUnitAction";
 import StateManager from "./state/StateManager";
 
 import { HistReducer, canRedo, canUndo } from "./state/HistReducer";
-import { UnitMetadataReducer, getFieldMetadata, getMetadata } from "./state/slice/UnitMetadataSlice";
+import { UnitMetadataReducer, getField, getMetadata } from "./state/slice/UnitMetadataSlice";
 import { RecordsReducer } from "./state/slice/RecordsSlice";
 import { SelectionReducer, getSelection, hasNext, hasPrevious } from "./state/slice/SelectionSlice";
 import { ChangesReducer, isDirty, getChangesToSave } from "./state/slice/ChangesSlice";
@@ -13,14 +13,17 @@ import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice";
 import { AddedRecordsReducer } from "./state/slice/AddedRecordsSlice";
 import { CurrentRecordsReducer, getCurrentRecords, getFieldValue } from "./state/slice/CurrentRecordsSlice";
 
+
 export default class DataUnit {
 
     private _name: string;
     private _observers: Array<(action: DataUnitAction) => void>;
+    private _sortingProvider?: SortingProvider;
+    private _filterProviders: Array<FilterProvider>;
     private _stateManager: StateManager;
 
     public metadataLoader?: (dataUnit: string) => Promise<UnitMetadata>;
-    public dataLoader?: (dataUnit: string) => Promise<Array<Record>>;
+    public dataLoader?: (dataUnit: string, sort?: Array<Sort>, filters?: Array<Filter>) => Promise<Array<Record>>;
     public saveLoader?: (dataUnit: string, changes: Array<Change>) => Promise<Array<SavedRecord>>;
 
     constructor(name: string) {
@@ -38,6 +41,8 @@ export default class DataUnit {
             ]
         );
         this._observers = [];
+        this._filterProviders = [];
+        this._sortingProvider = undefined;
     }
 
     public get name(): string {
@@ -46,12 +51,24 @@ export default class DataUnit {
 
     // Métodos privados
     private validateAndTypeValue(fieldName: string, newValue: any): any {
-        const fmd: FieldMetadata|undefined = getFieldMetadata(this._stateManager, fieldName);
-        if (!fmd) {
-            throw new Error(`Campo ${fieldName} não encontrado.`);
-        }
+        //FIXME: Validações devem ser feitas aqui
+        const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
+    }
+
+    private getFilters(): Array<Filter> | undefined{
+        let filters: Array<Filter> | undefined = undefined;
+        this._filterProviders.forEach(p => {
+            const f = p.getFilter(this.name);
+            if(f){
+                filters = (filters||[]).concat(f);
+            }
+        });
+        return filters;
+    }
 
-        return convertType(fmd.dataType, newValue);
+    private getSort(): Array<Sort> | undefined{
+        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
     }
 
     // Loaders
@@ -59,39 +76,71 @@ export default class DataUnit {
         this.dispatchAction(Action.LOADING_METADATA);
         if (this.metadataLoader) {
             this.metadataLoader(this._name).then(
-                metadata => this.dispatchAction(Action.METADATA_LOADED, metadata)
+                metadata => this.metadata = metadata
             );
         }
     }
 
-    public loadData(): void {
+    public loadData(): Promise<Array<Record>> {
         this.dispatchAction(Action.LOADING_DATA);
-        if (this.dataLoader) {
-            this.dataLoader(this._name).then(
-                records => this.dispatchAction(Action.DATA_LOADED, records)
-            );
-        }
+        return new Promise((resolve, fail)=>{
+            if (this.dataLoader) {
+                const sort = this.getSort();
+                const filters = this.getFilters();
+                this.dataLoader(this._name, sort, filters).then(
+                    records => {
+                        this.records = records;
+                        resolve(this.records);
+                    }
+                ).catch(()=>fail());
+            }
+        });
     }
 
     public saveData(): void {
 
-        const changes: Array<Change> = getChangesToSave(this._stateManager);
+        const changes: Array<Change> = getChangesToSave(this._name, this._stateManager);
 
-        if(changes.length > 0){
+        if (changes.length > 0) {
             this.dispatchAction(Action.SAVING_DATA);
-            if(this.saveLoader){
+            if (this.saveLoader) {
                 this.saveLoader(this._name, changes).then(
-                    records => this.dispatchAction(Action.DATA_SAVED, {changes, records})
+                    records => this.dispatchAction(Action.DATA_SAVED, { changes, records })
                 );
             }
         }
     }
 
     // API
-    public getMetadata(): UnitMetadata {
+    public addFilterProvider(provider: FilterProvider): void{
+        this._filterProviders.push(provider);
+    }
+
+    public set sortingProvider(provider: SortingProvider){
+        this._sortingProvider = provider;
+    }
+
+    public set metadata(md: UnitMetadata) {
+        this.dispatchAction(Action.METADATA_LOADED, md);
+    }
+
+    public get metadata(): UnitMetadata {
         return getMetadata(this._stateManager);
     }
 
+    public set records(r: Array<Record>){
+        this.dispatchAction(Action.DATA_LOADED, r);
+    }
+    
+    public get records(): Array<Record>{
+        const records = getCurrentRecords(this._stateManager);
+        return records ? Array.from(records.values()) : [];
+    }
+    
+    public getField(fieldName: string): FieldDescriptor | undefined{
+        return getField(this._stateManager, fieldName);
+    }
+
     public addRecord(): void {
         this.dispatchAction(Action.RECORDS_ADDED, [{}]);
     }
@@ -103,15 +152,20 @@ export default class DataUnit {
         }
     }
 
-    public getRecords(): Array<Record>|undefined {
-        const records = getCurrentRecords(this._stateManager);
-        return records ? Array.from(records.values()) : undefined;
-    }
-
     public getFieldValue(fieldName: string): any {
         return getFieldValue(this._stateManager, fieldName);
     }
 
+    public setFieldValue(fieldName: string, newValue: any, records?: Array<string>): void {
+
+        const typedValue = this.validateAndTypeValue(fieldName, newValue);
+        const currentValue = this.getFieldValue(fieldName);
+
+        if (currentValue !== typedValue) {
+            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
+        }
+    }
+
     public getSelection(): Array<string> {
         return getSelection(this._stateManager);
     }
@@ -132,16 +186,6 @@ export default class DataUnit {
         this.dispatchAction(Action.PREVIOUS_SELECTED);
     }
 
-    public setFieldValue(fieldName: string, newValue: any): void {
-
-        const typedValue = this.validateAndTypeValue(fieldName, newValue);
-        const currentValue = this.getFieldValue(fieldName);
-
-        if (currentValue !== typedValue) {
-            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue });
-        }
-    }
-
     public cancelEdition(): void {
         this.dispatchAction(Action.EDITION_CANCELED);
     }
@@ -190,7 +234,6 @@ export default class DataUnit {
     public unsubscribe(observer: Function) {
         this._observers = this._observers.filter(f => f !== observer);
     }
-
 }
 
 export interface Record {
@@ -199,7 +242,7 @@ export interface Record {
     [key: string]: any;
 }
 
-export interface SavedRecord extends Record{
+export interface SavedRecord extends Record {
     __old__id__?: string;
 }
 
@@ -211,12 +254,14 @@ export enum ChangeOperation {
 
 export class Change {
 
+    public dataUnit: string;
     public record: Record;
     public updatingFields: any;
 
     private _operation: ChangeOperation;
 
-    constructor(record: Record, updates: any, operation: ChangeOperation) {
+    constructor(dataUnit: string, record: Record, updates: any, operation: ChangeOperation) {
+        this.dataUnit = dataUnit;
         this.record = record;
         this.updatingFields = updates;
         this._operation = operation;

package/src/dataunit/metadata/DataType.ts

@@ -3,7 +3,7 @@ export enum DataType{
     DATE = "DATE",
     TEXT = "TEXT",
     BOOLEAN = "BOOLEAN",
-    JSON = "JSON"
+    OBJECT = "OBJECT"
 }
 
 export const convertType = (dataType:DataType, value: any): any => {
@@ -13,8 +13,8 @@ export const convertType = (dataType:DataType, value: any): any => {
     switch (dataType){
         case DataType.NUMBER:
             return value === "" || isNaN(value) ? null : Number(value);
-        case DataType.JSON:
-            return JSON.parse(value);
+        case DataType.OBJECT:
+            return typeof value === "string" ? JSON.parse(value) : value;
         case DataType.BOOLEAN:
             return Boolean(value);
         case DataType.DATE:
@@ -30,7 +30,7 @@ export const toString = (dataType:DataType, value: any): string => {
         return value;
     }
 
-    if(dataType === DataType.JSON){
+    if(dataType === DataType.OBJECT){
         return JSON.stringify(value);
     } else {
         return value.toString();

package/src/dataunit/metadata/UnitMetadata.ts

@@ -3,32 +3,58 @@ import { DataType } from "./DataType";
 export interface UnitMetadata{
     name: string;
     label: string;
-    fields: Array<FieldMetadata>;
+    fields: Array<FieldDescriptor>;
 }
 
-export interface FieldMetadata {
+export interface FieldDescriptor {
     name: string;
     label: string;
     dataType: DataType;
     userInterface?: UserInterface;
-    defaultValue?: string;
+    defaultValue?: any;
+    visible?: boolean;
     readOnly?: boolean;
     required?: boolean;
-    properties?: Array<UIProperty>;
+    properties?: any;
     dependencies?: Array<FieldDependency>;
 }
 
-export interface UIProperty {
-    name: string;
-    value: string;
-}
-
 export interface FieldDependency {
     masterFields: Array<string>;
     type: DependencyType;
     expression: string;
 }
 
+export interface Filter{
+    name: string;
+    expression: string;
+    params?: Array<FilterParam>
+}
+  
+export interface FilterParam{
+    name: string
+    value: any
+}
+  
+export interface Sort{
+    field: string
+    mode: SortMode
+    dataType: DataType
+}
+
+export interface FilterProvider{
+    getFilter(dataUnit: string): Array<Filter> | undefined;
+}
+
+export interface SortingProvider{
+    getSort(dataUnit: string): Array<Sort> | undefined;
+}
+
+export enum SortMode{
+    ASC = "ASC",
+    DESC = "DESC"
+}
+
 export enum DependencyType {
     SEARCHING = "SEARCHING",
     REQUIREMENT = "REQUIREMENT",

package/src/dataunit/state/slice/ChangesSlice.ts

@@ -16,7 +16,7 @@ class ChangesReducerImpl implements ActionReducer{
         switch(action.type){
 
             case Action.DATA_CHANGED: 
-                const selection = getSelection(stateManager);
+                const selection: Array<string> = action.payload.records || getSelection(stateManager);
                 if(selection){
                     const newState = new Map(currentState);
                     selection.forEach(recordId => {
@@ -54,7 +54,7 @@ export const isDirty = (stateManager: StateManager): boolean => {
     return getChanges(stateManager) !== undefined;
 }
 
-export const getChangesToSave = (stateManager: StateManager): Array<Change> => {
+export const getChangesToSave = (dataUnit: string, stateManager: StateManager): Array<Change> => {
     const result: Array<Change> = [];
 
     const changes = getChanges(stateManager);
@@ -65,7 +65,7 @@ export const getChangesToSave = (stateManager: StateManager): Array<Change> => {
             if(changes){
                 const c = changes.get(r.__record__id__);
                 if (c) {
-                    result.push(new Change(r, c, ChangeOperation.UPDATE));
+                    result.push(new Change(dataUnit, r, c, ChangeOperation.UPDATE));
                 }
             }
         });
@@ -74,7 +74,7 @@ export const getChangesToSave = (stateManager: StateManager): Array<Change> => {
     const addedRecords = getAddedRecords(stateManager);
     if (addedRecords) {
         addedRecords.forEach(r => {
-            result.push(new Change(r, changes?.get(r.__record__id__), ChangeOperation.INSERT));
+            result.push(new Change(dataUnit, r, changes?.get(r.__record__id__), ChangeOperation.INSERT));
         });
     }
 
@@ -83,7 +83,7 @@ export const getChangesToSave = (stateManager: StateManager): Array<Change> => {
     records.forEach(r=>recordsById[r.__record__id__] = r);
     if (removedRecords) {
         removedRecords.forEach(id => {
-            result.push(new Change(recordsById[id], undefined, ChangeOperation.DELETE));
+            result.push(new Change(dataUnit, recordsById[id], undefined, ChangeOperation.DELETE));
         });
     }
 

package/src/dataunit/state/slice/UnitMetadataSlice.ts

@@ -1,6 +1,6 @@
 
 import { ActionReducer, StateAction } from "../StateManager";
-import { UnitMetadata, FieldMetadata } from "../../metadata/UnitMetadata";
+import { UnitMetadata, FieldDescriptor } from "../../metadata/UnitMetadata";
 import { Action } from "../action/DataUnitAction";
 import StateManager from "../StateManager";
 
@@ -24,7 +24,7 @@ export const getMetadata = (stateManager: StateManager): UnitMetadata => {
     return stateManager.select(UnitMetadataReducer.sliceName, (state: UnitMetadata) => state);
 };
 
-export const getFieldMetadata = (stateManager: StateManager, fieldName: string): FieldMetadata|undefined => {
+export const getField = (stateManager: StateManager, fieldName: string): FieldDescriptor|undefined => {
     const md: UnitMetadata = getMetadata(stateManager);
     return md ? md.fields.find(fmd => fmd.name === fieldName) : undefined;
 }

package/src/http/data-fetcher/HttpFetcher.ts

@@ -0,0 +1,174 @@
+import { LoadStateManager, LoadType } from "./state/LoadStateManager";
+import { DataType } from "./../../dataunit/metadata/DataType";
+import {  UserInterface } from "./../../dataunit/metadata/UnitMetadata";
+import { batchRequests, BatchRequestDocument  } from 'graphql-request';
+
+export class HttpFetcher{
+    private static instance: HttpFetcher;
+    private static loadStateManager: LoadStateManager;
+    private static watingRequestsById: Map<string, WaitingRequest >= new Map<string, WaitingRequest>();
+
+    private constructor() {
+        HttpFetcher.loadStateManager = LoadStateManager.get(LoadType.APP_LOAD);
+        HttpFetcher.loadStateManager.onLoaded(this.onApplicationLoaded);
+    }
+
+    public static get(): HttpFetcher {
+        if (!HttpFetcher.instance) {
+            HttpFetcher.instance = new HttpFetcher();
+        }
+        return HttpFetcher.instance;
+    }
+
+    public async callGraphQL(req:any):Promise<any>{
+        if(HttpFetcher.loadStateManager.isPreInitialize()){            
+            const reqKey = this.getReqKey(req);
+            req.queryID = reqKey;
+            req.values.queryID = reqKey;
+
+            if(!HttpFetcher.watingRequestsById.has(reqKey)){
+              HttpFetcher.watingRequestsById.set(reqKey, new WaitingRequest(req));
+            }
+            return HttpFetcher.getWatingRequest(reqKey)?.promise;
+        }else{
+            //TODO: fazer chamada direta para graphQL
+            return new Promise(function(resolve){
+                const md = {
+                    name: "dd://br.com.sankhya.cad.parceiro/Parceiro",
+                    label: "Parceiro",
+                    fields: [
+                      {
+                        name: "CODPARC",
+                        label: "Cód. Parceiro",
+                        dataType: DataType.NUMBER
+                      },
+                      {
+                        name: "NOMEPARC",
+                        label: "Nome",
+                        dataType: DataType.TEXT,
+                        userInterface: UserInterface.LONGTEXT,
+                        required: true
+                      },
+                      {
+                        name: "P",
+                        label: "pera",
+                        dataType: DataType.TEXT,
+                        userInterface: UserInterface.OPTIONSELECTOR,
+                        properties: {options: `{"M": "Madura", "V": "Verde", "P": "Passada"}`}
+                      },
+                      {
+                        name: "ME",
+                        label: "ME",
+                        dataType: DataType.NUMBER,
+                        userInterface: UserInterface.DECIMALNUMBER,
+                        properties: {precision: 4, prettyPrecision: 1}
+                      }
+                    ]
+                  }
+                setTimeout(() => resolve(md));
+            });
+        }  
+    }
+
+    private getReqKey(req:any):string{
+      return window.btoa(this.hashCode(`${req.query}${JSON.stringify(req.values || "")}`)).replaceAll("=", "");
+    }
+
+    private static getQueryTemplate(re:any):string{
+      return (re.query || "").replaceAll("$queryAlias$", re.queryID);
+    }
+
+    private static getWatingRequest(reqID:string):WaitingRequest|undefined{
+      return HttpFetcher.watingRequestsById.get(reqID);
+    }
+
+    private async onApplicationLoaded():Promise<any>{
+      const requestsBatch:Array<BatchRequestDocument> = [];
+          
+      HttpFetcher.watingRequestsById.forEach(async (waitingReq:WaitingRequest) => {
+          let query = HttpFetcher.getQueryTemplate(waitingReq.request);
+          requestsBatch.push({ document: query, variables: {...waitingReq.request.values } });
+      });                        
+      
+      let res:any = undefined;
+      let dataResponse:Array<any> = [];
+      let errorsResponse:Array<any> = [];
+
+      try{
+        res = await batchRequests('http://localhost:8082/', requestsBatch);
+        res.forEach((resItem:any) => {
+          dataResponse.push(resItem.data);
+        });
+      }catch(err:any){
+        res = err.response;
+        const req:any = err.request;
+        Object.entries(res).forEach(([key, val]:Array<any>) => {
+          if(val.errors){
+            errorsResponse.push(val.errors.map((item:any) => {
+              item.request = req;
+              item.index = Number(key);
+              return item;
+            }));
+          }else if(val.data){
+            dataResponse.push(val.data);
+          }
+        });
+      }
+      //Reject primises with errors from query
+      errorsResponse.forEach((errorResponse:any) => {
+        Object.entries(errorResponse).forEach(([key, val]:Array<any>) => {
+          (HttpFetcher.getWatingRequest(val.request.variables[val.index].queryID)?.reject || Promise.reject)(val);
+        });
+      });
+      //Resolve primises with data from query
+      dataResponse.forEach((data:any) => {
+        Object.entries(data).forEach(([key, val]:Array<any>) => {
+          (HttpFetcher.getWatingRequest(key)?.resolve || Promise.resolve)(val);
+        });
+      });
+      HttpFetcher.watingRequestsById.clear();
+    }
+    
+    //TODO: Mover este metodo para o @sankhyalabs/core classe string utils.
+    private hashCode (txt:string):string {
+      var hash = 0, i, chr;
+      if (txt.length === 0) return hash.toString();
+      for (i = 0; i < txt.length; i++) {
+        chr   = txt.charCodeAt(i);
+        hash  = ((hash << 5) - hash) + chr;
+        hash |= 0; // Convert to 32bit integer
+      }
+      return hash.toString();
+    };
+}
+
+class WaitingRequest {
+  private _resolve: Function = () => {};
+  private _reject: Function = () => {};
+  private _promisse: Promise<any>;
+  private _request: any = undefined;
+  
+  constructor(req:any){
+    this._request = req;
+    this._promisse = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+
+  public get resolve():Function{
+    return this._resolve;
+  }
+
+  public get reject():Function{
+    return this._reject;
+  }
+
+  public get promise():Promise<any>{
+    return this._promisse;
+  }
+
+  public get request():any{
+    return this._request;
+  }
+}

package/src/http/data-fetcher/default/application-config-fetcher.ts

@@ -0,0 +1,26 @@
+import { gql } from 'graphql-request';
+import { HttpFetcher } from '../HttpFetcher';
+
+export class ApplicationConfigFetcher {
+
+    private templateByQuery:Map<string, string >= new Map<string, string>();
+    
+    constructor(){
+        this.buldTemplates();
+    }
+
+    private buldTemplates():void{  
+        this.templateByQuery.set('getResource', gql `query($name: String!) {
+            $queryAlias$: getResource(name: $name){
+              name
+              resource
+            }
+        }`);
+    }
+
+    public getResource(name:string, resourceID:string):Promise<any>{
+        const completPath = `cfg://app/${resourceID}/${name}`;
+        return HttpFetcher.get().callGraphQL({ values : { "name": completPath }, query: this.templateByQuery.get("getResource")});
+    }
+    
+}

package/src/http/data-fetcher/default/dataunit-fetcher.ts

@@ -0,0 +1,52 @@
+import { UnitMetadata } from "../../../dataunit/metadata/UnitMetadata";
+import { HttpFetcher } from "../HttpFetcher";
+import { gql } from 'graphql-request';
+import DataUnit from "../../../dataunit/DataUnit";
+
+export class DataUnitFetcher{
+
+    private templateByQuery:Map<string, string >= new Map<string, string>();
+    
+    constructor(){
+        this.buldTemplates();
+    }
+
+    private buldTemplates():void{
+        this.templateByQuery.set('getDataUnit', gql `query($name: String!) {
+            $queryAlias$: getDataUnit(name: $name){
+              name,
+              cardinality,
+              fields{
+                name,
+                defaultValue,
+                label,
+                readOnly,
+                required,
+                dataType,
+                userInterface,
+                properties{
+                  name,
+                  value
+                },
+                dependencies{
+                  masterFields,
+                  type,
+                  expression
+                }
+              }
+            }
+          }`);
+    }
+
+    public getDataUnit(name:string, resourceID:string):Promise<UnitMetadata>{
+        const completPath = `dd://${resourceID}/${name}`;
+        return HttpFetcher.get().callGraphQL({ values : { "name": completPath }, query: this.templateByQuery.get("getDataUnit")});
+    }
+
+    public static bindTo(dataUnit:DataUnit, resourceID:string):DataUnitFetcher{
+        const du = new DataUnitFetcher();
+        dataUnit.metadataLoader = (name:string) => du.getDataUnit(name, resourceID);
+        //TODO: Implementar bind dos demais métodos.
+        return du;
+    }
+}

package/src/http/data-fetcher/default/form-config-fetcher.ts

@@ -0,0 +1,3 @@
+export class FormConfigFetcher {    
+    
+}

package/src/http/data-fetcher/default/grid-config-fetcher.ts

@@ -0,0 +1,3 @@
+export class GridConfigFetcher {
+
+}