@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

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

@@ -0,0 +1,139 @@
+
+import { ActionReducer } from "../StateManager.js";
+import StateManager from "../StateManager.js";
+import { Record } from "../../DataUnit.js";
+import { getRecords } from "./RecordsSlice.js";
+import { getSelection } from "./SelectionSlice.js";
+import { getChanges } from "./ChangesSlice.js";
+import { getRemovedRecords } from "./RemovedRecordsSlice.js";
+import { getAddedRecords } from "./AddedRecordsSlice.js";
+
+class SnapshotReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "snapshot";
+
+    public reduce(stateManager: StateManager, currentSnapshot: Snapshot): Snapshot {
+       return buildSnapshot(currentSnapshot, stateManager);
+    }
+}
+
+export const SnapshotReducer = new SnapshotReducerImpl();
+
+export const getSnapshot = (stateManager: StateManager): Snapshot | undefined => {
+    return stateManager.select(SnapshotReducer.sliceName, (state: Snapshot) => state);
+}
+
+export const getCurrentRecords = (stateManager: StateManager): Map<string, Record> => {
+    const snapshot = getSnapshot(stateManager);
+    return snapshot ? snapshot.records : new Map();
+};
+
+export const getSelectionRecordsMap = (stateManager: StateManager): Map<string, Record> => {
+    const snapshot = getSnapshot(stateManager);
+    return snapshot ? snapshot.selectionRecords : new Map();
+};
+
+export const getSelectionRecords = (stateManager: StateManager): Array<Record> | undefined => {
+    const snapshot = getSnapshot(stateManager);
+    return snapshot ? Array.from(snapshot.selectionRecords.values()) : undefined;
+}
+
+export const getModifiedRecords = (stateManager: StateManager): Array<Record> | undefined => {
+
+    const currentRecords = buildCurrentRecords(stateManager);
+    if(!currentRecords){
+        return undefined
+    }
+
+    const changes = getChanges(stateManager);
+    const added = getAddedRecords(stateManager);
+    if(!changes && !added){
+        return undefined
+    }
+    
+    let modifiedIDs = changes ? Array.from(changes.keys()) : [];
+    
+    if(added){
+        modifiedIDs = modifiedIDs.concat(added.map(r=>r.__record__id__));
+    }
+    
+    return Array.from(currentRecords.values()).filter(r=>modifiedIDs.includes(r.__record__id__));
+}
+
+export const getFieldValue = (stateManager: StateManager, fieldName: string): any => {
+    const selection = getSelection(stateManager);
+    if(selection && selection.length > 0){
+        const currentRecords = getSelectionRecords(stateManager);
+        if(currentRecords){
+            const record = currentRecords.find(record => record.__record__id__ === selection[0]);
+            return record ? record[fieldName] : undefined;
+        }
+    }
+    return undefined;
+};
+
+export interface Snapshot{
+    records: Map<string, Record>;
+    selectionRecords: Map<string, Record>
+}
+
+function buildSnapshot(oldSnapshot: Snapshot, stateManager: StateManager): Snapshot{
+
+    let records = getRecords(stateManager) || [];
+    const added = getAddedRecords(stateManager);
+       
+    if(added){
+        records = (records).concat(added);
+    }
+
+    const removedRecords = getRemovedRecords(stateManager);
+    if(removedRecords){
+        records = records.filter(record => !removedRecords.includes(record.__record__id__));
+    }
+
+    const changes = getChanges(stateManager);
+    const snapshotRecords: Map<string, Record> = new Map(records.map(source => [source.__record__id__, {...source, ...changes?.get(source.__record__id__)}]));
+    const selectionRecords: Map<string, Record> = new Map(oldSnapshot?.selectionRecords);
+
+    for (let [chave, valor] of selectionRecords) {
+        selectionRecords.set(chave, {...valor, ...changes?.get(chave)});
+    }
+
+    const selection: Array<string> = getSelection(stateManager);
+    
+    if(selection && selection.length > 0){
+        selection.forEach(recordId => {
+            const record = snapshotRecords.has(recordId) ? snapshotRecords.get(recordId) : oldSnapshot?.records.get(recordId);
+            if(record){
+                selectionRecords.set(recordId, record);
+            }
+        });
+    }
+
+    Array.from(selectionRecords.keys()).forEach(key => {
+        if(!selection.includes(key)){
+            selectionRecords.delete(key);
+        }
+    });
+
+     return {
+        records: snapshotRecords,
+        selectionRecords
+    }
+}
+
+function buildCurrentRecords(stateManager: StateManager) {
+    const currentRecords = getCurrentRecords(stateManager);
+    const selectionRecords = getSelectionRecordsMap(stateManager);
+
+    /**
+     * Precisamos verificar tanto os registros da seleção quanto os da página atual, pois o usuário pode estar tentando
+     * editar um registro que não está na página atual ou que não está selecionado.
+     */
+    selectionRecords.forEach(record => {
+        if (!currentRecords.has(record.__record__id__)) {
+            currentRecords.set(record.__record__id__, record);
+        }
+    });
+    return currentRecords;
+}

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

@@ -0,0 +1,30 @@
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { UnitMetadata, FieldDescriptor } from "../../metadata/UnitMetadata.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+
+
+class UnitMetadataReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "unitMetadata";
+        
+    public reduce(_stateManager:StateManager, currentState: UnitMetadata, action: StateAction): UnitMetadata {
+        if(action.type === Action.METADATA_LOADED){
+            return action.payload;
+        }
+        return currentState;
+    }
+
+}
+
+export const UnitMetadataReducer = new UnitMetadataReducerImpl();
+
+export const getMetadata = (stateManager: StateManager): UnitMetadata => {
+    return stateManager.select(UnitMetadataReducer.sliceName, (state: UnitMetadata) => state);
+};
+
+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/dataunit/state/slice/WaitingChangesSlice.ts

@@ -0,0 +1,74 @@
+
+import { WaitingChange } from "../../DataUnit.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager, { ActionReducer, StateAction } from "../StateManager.js";
+
+class WaitingCheangesReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "waitingChanges";
+
+    public reduce(stateManager:StateManager, currentState: Map<string, WaitingChange>, action: StateAction): Map<string, WaitingChange>|undefined {
+        let newState: Map<string, WaitingChange>;
+        switch(action.type){
+
+            case Action.CHANGING_DATA: 
+                newState = new Map(currentState);
+                Object.entries(action.payload).forEach(([key, value]) => {
+                    newState.set(key, value as WaitingChange);
+                });
+
+                return newState;
+
+            case Action.WAITING_CHANGE_CANCELED: 
+                newState = new Map(currentState);
+                newState.delete(action.payload.fieldName);
+
+                return newState.size === 0 ? undefined : newState;
+
+            case Action.DATA_CHANGED:
+                newState = new Map(currentState);
+                Object.entries(action.payload).forEach(([key]) => {
+                    newState.delete(key);
+                });
+
+                return newState.size === 0 ? undefined : newState;
+
+            case Action.DATA_SAVED:
+            case Action.EDITION_CANCELED:
+                return undefined;
+        } 
+        return currentState;
+    }
+
+}
+
+export const WaitingChangesReducer = new WaitingCheangesReducerImpl();
+
+export const getWaitingChanges = (stateManager: StateManager): Map<string, WaitingChange>|undefined => {
+    return stateManager.select(WaitingChangesReducer.sliceName, (state: Map<string, WaitingChange>) => state);
+}
+
+export const isWaiting = (stateManager: StateManager, fieldName: string): boolean => {
+    const allWC = getWaitingChanges(stateManager);
+    return allWC ? allWC.has(fieldName) : false;
+}
+
+export const getBlockingWaitingChanges = (stateManager: StateManager): Map<string, WaitingChange>|undefined => {
+    const allWC = getWaitingChanges(stateManager);
+    if(allWC){
+        return new Map(
+            Array.from(allWC.entries())
+                 .filter(entry=>entry[1].blocking)
+                 .map(entry=>[entry[0], entry[1]])
+        );
+    }
+}
+
+export const getWaitingChangePromisses = (stateManager: StateManager): (Promise<any>|undefined)[]|undefined => {
+    const allWC = getWaitingChanges(stateManager);
+    if(allWC){
+        return Array.from(allWC.values())
+            .filter(wc=>!wc.blocking)
+            .map(wc=>wc.promise);
+    }
+}

package/src/exceptions/ErrorException.ts

@@ -0,0 +1,25 @@
+/**
+ * `ErrorException`: Exceção lançada quando ocorre um erro. 
+ */
+export default class ErrorException extends Error {
+    
+    /** Nome da exceção. */
+    public name: string;
+
+    /** Titulo do erro. */
+    public title: string;
+
+    /** Descrição do erro. */
+    public message: string;
+    
+    /** Código do erro, indica o erro disparado pelo backend. */
+    public errorCode: string;
+
+    constructor(title: string, message: string, errorCode: string = "") {
+        super(message);
+        this.name = "";
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}

package/src/exceptions/WaitingChangeException.ts

@@ -0,0 +1,21 @@
+/**
+ * `WaitingChangeException`: Exceção lançada quando um campo está pendente de finalizar a alteração antes de executar uma ação.
+ */
+export default class WaitingChangeException extends Error {
+    
+    /** Nome da exceção. */
+    public name: string;
+
+    /** Titulo do erro. */
+    public title: string;
+
+    /** Descrição do erro. */
+    public message: string;
+
+    constructor(title: string, message: string) {
+        super(message);
+        this.title = title;
+        this.name = "";
+        this.message = message;
+    }
+}

package/src/exceptions/WarningException.ts

@@ -0,0 +1,26 @@
+/**
+ * `WarningException`: Exceção lançada quando o "erro" vindo do backend é caracterizado como warning.
+ */
+export default class WarningException extends Error {
+    
+    /** Nome da exceção. */
+    public name: string;
+
+    /** Titulo do alerta. */
+    public title: string;
+
+    /** Descrição do alerta. */
+    public message: string;
+    
+    /** Código do alerta, indica o alerta disparado pelo backend. */
+    public errorCode: string;
+
+    constructor(title: string, message: string, errorCode: string = "") {
+        super(message);
+        this.title = title;
+        this.name = "";
+        this.message = message;
+        this.errorCode = errorCode;
+        
+    }
+}

package/src/html/HTMLBuilder.ts

@@ -0,0 +1,8 @@
+export class HTMLBuilder{
+    public static parseElement<ElementType extends HTMLElement>(html:string): ElementType{
+        const domFactory = document.createElement("div");
+        domFactory.style.display = "none";
+        domFactory.innerHTML = html;
+        return domFactory.children.item(0) as ElementType;
+    }
+}

package/src/http/AuthorizedServiceCaller.ts

@@ -0,0 +1,58 @@
+export class AuthorizedServiceCaller {
+
+    private serverURL: string = "http://192.168.1.218:8503"; //todo request deve fazer replace de ${serverURL} pelo conteúdo da variável
+    private unauthorizedPath: string = "/";
+
+    constructor(serverURL: string, unauthorizedPath: string) {
+        this.serverURL = serverURL;
+        this.unauthorizedPath = unauthorizedPath;
+
+    }
+
+    async requestService(request: AuthorizedRequest, callback?: Function) {
+
+        const token = localStorage.getItem('token');
+        const body = request?.body;
+        const method = request?.method;
+
+        let headers;
+
+        if (!token) {
+            window.location.pathname = this.unauthorizedPath;
+        } else {
+            headers = {
+                'Authorization': `${token}`,
+                'Content-Type': 'application/json',
+                'Customer-Host': 'http://localhost:8080/sankhyaw'
+            }
+        }
+        const response: void | Response = await await fetch(this.serverURL,
+            {
+                method: method,
+                headers: headers,
+                body: body
+
+            })
+            .catch(e => {
+                console.log(e);
+            });
+
+        if (response instanceof Response && response.status === 401) {
+            localStorage.removeItem('token');
+            window.location.pathname = this.unauthorizedPath;
+        }
+
+        if (callback && response instanceof Response) {
+            callback(response.json().then());
+        } else {
+            return response;
+        }
+
+    }
+}
+
+export interface AuthorizedRequest {
+    url: string,
+    body: string,
+    method: string
+}

package/src/http/HttpProvider.ts

@@ -0,0 +1,94 @@
+import { RequestMetadata, Method, Header } from "./RequestMetadata.js";
+
+/**
+ * Abstração do XMLHttpRequest. Este serviço é responsável por realizar as requisições
+ * ao backend. Todos os métodos são estáticos.
+ */
+export class HttpProvider {
+
+    /**
+     * Faz uma requisição usando o método GET do HTTP para uma URL específica.
+     *
+     * @param {string} url A URL que deve ser chamada.
+     * @param {Array<Header>} headers [Opcional] Cabeçalhos HTTP.
+     * @returns {Promise<Object>} Uma promessa de que a requisição será preenchida.
+     */
+    public static get(url: string, headers?: Array<Header>): Promise<Object> {
+        return this.dispatch(new RequestMetadata(url, Method.GET, headers));
+    }
+
+    /**
+     * Faz uma requisição usando o método POST do HTTP para uma URL específica.
+     *
+     * @param {string} url A URL que deve ser chamada.
+     * @param {Object} payload Informações a serem enviadas.
+     * @param {Array<Header>} headers [Opcional] Cabeçalhos HTTP.
+     * @returns {Promise<Object>} Uma promessa de que a requisição será preenchida.
+     */
+    public static post(url: string, payload:Object, headers?: Array<Header>): Promise<any> {
+        return this.dispatch(new RequestMetadata(url, Method.POST, headers), payload);
+    }
+
+    private static dispatch(requestMetadata: RequestMetadata, payload?: Object): Promise<any> {
+
+        return new Promise<Object>((resolve, reject) => {
+
+            const request = new XMLHttpRequest();            
+
+            request.timeout = requestMetadata.timeout;
+
+            request.onerror = function handleError() {
+                reject({
+                    status: 404,
+                    statusText: 'Not Found'
+                });
+            };
+
+            request.ontimeout = function handleTimeout() {
+                reject({
+                    status: 408,
+                    statusText: 'Request Timeout'
+                });
+            };
+
+            request.onreadystatechange = () => {
+
+                // While readState isn't done, there's nothing to do...
+                if (request.readyState != 4) {
+                    return;
+                }
+
+                const status = request.status;
+
+                // The request has failed so we'll handled by onerror instead
+                if (status === 0) {
+                    return;
+                }
+
+                const response = {
+                    status,
+                    statusText: request.statusText,
+                };
+
+                // Anything out of this range is an error, so we just send the status and statusText.
+                if (status >= 200 && status < 300) {
+                    resolve({
+                        ...response,
+                        data: request.response,
+                        dataAsString: request.responseText
+                    });
+                } else {
+                    reject(response);
+                }
+
+            };
+
+            request.open(requestMetadata.method.toString(), requestMetadata.url, true);
+            requestMetadata.headers.map((h: Header) => request.setRequestHeader(h.name, h.value));
+
+            if(payload != null){
+                request.send(JSON.stringify(payload));
+            }
+        });
+    }
+}

package/src/http/RequestMetadata.ts

@@ -0,0 +1,42 @@
+/**
+ * Representa as propriedades necessárias para se executar uma requisição.
+ */
+export class RequestMetadata {
+
+    /** A URL a ser chamada */
+    public url: string;
+
+    /** O verbo HTTP */
+    public method: Method;
+
+    /** Tempo limite de espera pela resposta */
+    public timeout: number = 30000;
+
+    /** Headers para serem enviados na requisição */
+    public headers: Array<Header>;
+
+    /**
+     * @param {string} url A URL que deve ser chamada.
+     * @param {Method} method O Método da requisição (GET, PUT, POST ou DELETE).
+     */
+    public constructor(url: string, method: Method, headers?:Array<Header>) {
+        this.url = url;
+        this.method = method;
+        this.headers = headers || [];
+    }
+
+}
+
+/** Representa os verbos HTTP suportados */
+export enum Method {
+    GET,
+    PUT,
+    POST,
+    DELETE
+}
+
+/** Headers HTTP */
+export interface Header{
+    name: string;
+    value: string;
+}

package/src/http/SkwHttpProvider.ts

@@ -0,0 +1,78 @@
+import { HttpProvider } from "./HttpProvider.js"
+import { Header } from "./RequestMetadata.js";
+
+export class SkwHttpProvider{
+    static _counter:number = 0;
+    
+    static STATUS_ERROR:number      = 0;
+    static STATUS_OK:number         = 1;
+    static STATUS_INFO:number       = 2;
+    static STATUS_TIMEOUT:number    = 3;
+    static STATUS_CANCELED:number   = 4;    
+    
+    public static callService(serviceName: string, content: Object): Promise<Object>{
+        return new Promise<Object>((resolve, reject) => {
+            let host:string = "http://192.168.1.218:8503/mge/";
+            let appName:string = "ListaTarefa";
+            let module = 'mge';
+            this._counter++;
+
+            if (serviceName.indexOf("@") > -1) {
+                let s = serviceName.split("@");
+                module = s[0];
+                serviceName = s[1];
+            }
+
+            let url = `${host}/${module}/service.sbr?serviceName=${serviceName}&counter=${this._counter}&application=${appName}&outputType=json&preventTransform=false`;
+
+            let requestContent = {
+                serviceName: serviceName,
+                requestBody: content
+            };
+
+            let headers = new Headers();
+
+            headers.append("Content-Type", "application/json")
+            //headers.append("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE");
+            //headers.append("Access-Control-Allow-Origin", "Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers");
+
+            fetch(url, {
+                body: JSON.stringify(requestContent),
+                method: 'POST',
+                headers: headers
+            })
+            .then( res => res.json())
+            .then( (data) => {
+                console.log(data);
+            });
+
+            /*HttpProvider.post(url, requestContent, headers)
+            .then(res => {
+                if (!res.hasOwnProperty('status') ||
+                    res.status == this.STATUS_ERROR ||
+                    res.status == this.STATUS_TIMEOUT) {
+
+                    let statusMessage = res.statusMessage;
+                    
+                    if (!statusMessage) {
+                        statusMessage = 'Erro não identificado.'
+                    }
+                    //TODO: No futuro, exibir mensagens de erro. (MessageUtils.showError)
+                    reject(new Error(statusMessage));
+                }else if (res.status == this.STATUS_CANCELED) {
+                    if (res.statusMessage){
+                        console.warn(res.statusMessage);
+                    }
+                }else{
+                    resolve(res);
+                }
+
+                if (res.status == this.STATUS_INFO) {
+                     //TODO: No futuro, exibir mensagens de erro. (MessageUtils.showAlert)
+                    console.info(res.statusMessage);
+                }
+            })
+            .catch((e)=>{reject(e)});*/
+        })
+    }
+}