@sankhyalabs/core 1.0.42 → 1.0.43

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

@@ -1,131 +1,131 @@
-import { ActionReducer, StateAction } from "../StateManager.js";
-import { Action } from "../action/DataUnitAction.js";
-import StateManager from "../StateManager.js";
-import { getCurrentRecords } from "./CurrentRecordsSlice.js";
-import { Record, SavedRecord } from "../../DataUnit.js";
-
-class SelectionReducerImpl implements ActionReducer {
-
-    public sliceName: string = "hist::selection";
-
-    public reduce(stateManager: StateManager, currentState: Array<string>, action: StateAction): Array<string>|undefined {
-
-        switch (action.type) {
-
-            case Action.RECORDS_ADDED:
-            case Action.RECORDS_COPIED:
-                return action.payload.map((r: Record)=>r.__record__id__);
-            case Action.DATA_SAVED:
-                return updateSavedIds(stateManager, action.payload.records);
-            case Action.RECORDS_REMOVED:
-                const removed: Array<string> = action.payload.records;
-                if (currentState && removed) {
-                    return currentState.filter(recordId => !removed.includes(recordId))
-                }
-                return currentState;
-
-            case Action.NEXT_SELECTED:
-            case Action.PREVIOUS_SELECTED:
-                
-                const currentRecords = getCurrentRecords(stateManager);
-                if (currentRecords && currentRecords.size > 0) {
-                    let index: number;
-                    if (!currentState || currentState.length === 0) {
-                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
-                    } else {
-                        index = getItemIndex(currentState[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
-                    }
-                    if (index < currentRecords.size && index >= 0) {
-                        return [Array.from(currentRecords.values())[index].__record__id__];
-                    }
-                }
-
-                return undefined;
-
-            case Action.SELECTION_CHANGED:
-                const { type, selection: selectionSource } = action.payload;
-
-                if (selectionSource && type === "index") {
-                    const currentRecords = getCurrentRecords(stateManager);
-                    if (currentRecords) {
-                        const records = Array.from(currentRecords.values());
-                        const selectionById: Array<string> = [];
-                        selectionSource.forEach((i: number) => {
-                            if (i > 0 && i < currentRecords.size) {
-                                selectionById.push(records[i].__record__id__);
-                            }
-                        });
-                        return selectionById;
-                    }
-                }
-
-                return selectionSource;
-        }
-
-        return currentState;
-    }
-}
-
-export const SelectionReducer = new SelectionReducerImpl();
-
-export const getSelection = (stateManager: StateManager): Array<string> => {
-    let selection: Array<string> = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
-    const currentRecords = Array.from((getCurrentRecords(stateManager)||new Map()).keys());
-
-    if(selection){
-        selection = selection.filter( id => currentRecords.includes(id));
-    }
-
-    if (!selection || selection.length === 0) {
-        if (currentRecords && currentRecords.length > 0) {
-            return [currentRecords[0]];
-        }
-    }
-
-    return selection;
-};
-
-export const hasNext = (stateManager: StateManager): boolean => {
-    const records = getCurrentRecords(stateManager);
-    if (records) {
-        const selection = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
-        if (!selection || selection.length === 0) {
-            return records.size > 0;
-        }
-        return records.size > (getItemIndex(selection[0], records) + 1);
-    }
-    return false;
-};
-
-export const hasPrevious = (stateManager: StateManager): boolean => {
-    const records = getCurrentRecords(stateManager);
-    if (records) {
-        const selection = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
-        if (!selection || selection.length === 0) {
-            return false;
-        }
-        return getItemIndex(selection[0], records) > 0;
-    }
-    return false;
-};
-
-function getItemIndex(key: string, map: Map<string, any>): number {
-    return Array.from(map.keys()).indexOf(key);
-}
-
-function updateSavedIds(stateManager:StateManager, savedRecords:Array<SavedRecord>): Array<string>{
-    const currentSelection: Array<string> = getSelection(stateManager);
-    if(currentSelection){
-        const newSelection: Array<string> = [];
-        currentSelection.forEach( id => {
-            const record = savedRecords.find(r => r.__old__id__ === id);
-            if(record){
-                newSelection.push(record.__record__id__);
-            } else {
-                newSelection.push(id);
-            }
-        });
-        return newSelection;
-    }
-    return currentSelection;
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+import { getCurrentRecords } from "./CurrentRecordsSlice.js";
+import { Record, SavedRecord } from "../../DataUnit.js";
+
+class SelectionReducerImpl implements ActionReducer {
+
+    public sliceName: string = "hist::selection";
+
+    public reduce(stateManager: StateManager, currentState: Array<string>, action: StateAction): Array<string>|undefined {
+
+        switch (action.type) {
+
+            case Action.RECORDS_ADDED:
+            case Action.RECORDS_COPIED:
+                return action.payload.map((r: Record)=>r.__record__id__);
+            case Action.DATA_SAVED:
+                return updateSavedIds(stateManager, action.payload.records);
+            case Action.RECORDS_REMOVED:
+                const removed: Array<string> = action.payload.records;
+                if (currentState && removed) {
+                    return currentState.filter(recordId => !removed.includes(recordId))
+                }
+                return currentState;
+
+            case Action.NEXT_SELECTED:
+            case Action.PREVIOUS_SELECTED:
+                
+                const currentRecords = getCurrentRecords(stateManager);
+                if (currentRecords && currentRecords.size > 0) {
+                    let index: number;
+                    if (!currentState || currentState.length === 0) {
+                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                    } else {
+                        index = getItemIndex(currentState[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
+                    }
+                    if (index < currentRecords.size && index >= 0) {
+                        return [Array.from(currentRecords.values())[index].__record__id__];
+                    }
+                }
+
+                return undefined;
+
+            case Action.SELECTION_CHANGED:
+                const { type, selection: selectionSource } = action.payload;
+
+                if (selectionSource && type === "index") {
+                    const currentRecords = getCurrentRecords(stateManager);
+                    if (currentRecords) {
+                        const records = Array.from(currentRecords.values());
+                        const selectionById: Array<string> = [];
+                        selectionSource.forEach((i: number) => {
+                            if (i > 0 && i < currentRecords.size) {
+                                selectionById.push(records[i].__record__id__);
+                            }
+                        });
+                        return selectionById;
+                    }
+                }
+
+                return selectionSource;
+        }
+
+        return currentState;
+    }
+}
+
+export const SelectionReducer = new SelectionReducerImpl();
+
+export const getSelection = (stateManager: StateManager): Array<string> => {
+    let selection: Array<string> = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
+    const currentRecords = Array.from((getCurrentRecords(stateManager)||new Map()).keys());
+
+    if(selection){
+        selection = selection.filter( id => currentRecords.includes(id));
+    }
+
+    if (!selection || selection.length === 0) {
+        if (currentRecords && currentRecords.length > 0) {
+            return [currentRecords[0]];
+        }
+    }
+
+    return selection;
+};
+
+export const hasNext = (stateManager: StateManager): boolean => {
+    const records = getCurrentRecords(stateManager);
+    if (records) {
+        const selection = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
+        if (!selection || selection.length === 0) {
+            return records.size > 0;
+        }
+        return records.size > (getItemIndex(selection[0], records) + 1);
+    }
+    return false;
+};
+
+export const hasPrevious = (stateManager: StateManager): boolean => {
+    const records = getCurrentRecords(stateManager);
+    if (records) {
+        const selection = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
+        if (!selection || selection.length === 0) {
+            return false;
+        }
+        return getItemIndex(selection[0], records) > 0;
+    }
+    return false;
+};
+
+function getItemIndex(key: string, map: Map<string, any>): number {
+    return Array.from(map.keys()).indexOf(key);
+}
+
+function updateSavedIds(stateManager:StateManager, savedRecords:Array<SavedRecord>): Array<string>{
+    const currentSelection: Array<string> = getSelection(stateManager);
+    if(currentSelection){
+        const newSelection: Array<string> = [];
+        currentSelection.forEach( id => {
+            const record = savedRecords.find(r => r.__old__id__ === id);
+            if(record){
+                newSelection.push(record.__record__id__);
+            } else {
+                newSelection.push(id);
+            }
+        });
+        return newSelection;
+    }
+    return currentSelection;
 }

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

@@ -1,30 +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;
+
+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/http/AuthorizedServiceCaller.ts

@@ -1,58 +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
-}
+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

@@ -1,94 +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));
-            }
-        });
-    }
+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));
+            }
+        });
+    }
 }