@sankhyalabs/core 1.0.22 → 1.0.23

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

@@ -0,0 +1,54 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import StateManager from "../StateManager";
+import { Record } from "../../DataUnit";
+import { getRecords } from "./RecordsSlice";
+import { getSelection } from "./SelectionSlice";
+import { getChanges } from "./ChangesSlice";
+import { getRemovedRecords } from "./RemovedRecordsSlice";
+import { getAddedRecords } from "./AddedRecordsSlice";
+
+
+class CurrentRecordsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "currentRecords";
+
+    public reduce(stateManager: StateManager, _currentState: Map<string, Record>, _action: StateAction): Map<string, Record> | undefined {
+        let records = getRecords(stateManager);
+        const added = getAddedRecords(stateManager);
+        if(!records && !added){
+            return undefined;
+        }
+        if(added){
+            records = (records||[]).concat(added);
+        }
+        const removedRecords = getRemovedRecords(stateManager);
+        if(removedRecords){
+            records = records.filter(r => !removedRecords.includes(r.__record__id__));
+        }
+        const changes = getChanges(stateManager);
+        return new Map(records.map(r => {
+            const recordId = r.__record__id__;
+            const record = {...r, ...changes?.get(recordId)};
+            return [recordId, record];
+        }));
+    }
+}
+
+export const CurrentRecordsReducer = new CurrentRecordsReducerImpl();
+
+export const getCurrentRecords = (stateManager: StateManager): Map<string, Record> => {
+    return stateManager.select(CurrentRecordsReducer.sliceName, (state: Map<string, Record>) => state);
+};
+
+export const getFieldValue = (stateManager: StateManager, fieldName: string): any => {
+    const selection = getSelection(stateManager);
+    if(selection && selection.length > 0){
+        const currentRecords = getCurrentRecords(stateManager);
+        if(currentRecords){
+            const record = currentRecords.get(selection[0]);
+            return record ? record[fieldName] : undefined;
+        }
+    }
+    return undefined;
+};

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

@@ -0,0 +1,50 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+import { Record, SavedRecord } from "../../DataUnit";
+import { getRemovedRecords } from "./RemovedRecordsSlice";
+
+
+class RecordsReducerImpl implements ActionReducer {
+
+    public sliceName: string = "records";
+
+    public reduce(stateManager: StateManager, currentState: Array<Record>, action: StateAction): Array<Record> {
+        switch (action.type) {
+
+            case Action.DATA_LOADED:
+                return action.payload;
+                
+            case Action.DATA_SAVED:
+
+                const recordsMap: Map<string, Record> = new Map();
+                const currentRecords = getRecords(stateManager);
+
+                if (currentRecords) {
+                    const removed: Array<string> = getRemovedRecords(stateManager) || [];
+                    currentRecords.forEach(r => {
+                        if (!removed.includes(r.__record__id__)) {
+                            recordsMap.set(r.__record__id__, r);
+                        }
+                    });
+                }
+
+                const savedRecords: Array<SavedRecord> = action.payload.records;
+                savedRecords.forEach(sr => {
+                    const recordId = sr.__old__id__ || sr.__record__id__;
+                    const newRecord: Record = { ...sr };
+                    delete newRecord["__old__id__"];
+                    recordsMap.set(recordId, newRecord);
+                });
+                return Array.from(recordsMap.values());
+        }
+        return currentState;
+    }
+}
+
+export const RecordsReducer = new RecordsReducerImpl();
+
+export const getRecords = (stateManager: StateManager): Array<Record> => {
+    return stateManager.select(RecordsReducer.sliceName, (state: Array<Record>) => state);
+};

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

@@ -0,0 +1,26 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+
+class RemovedRecordsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "hist::removedRecords";
+
+    public reduce(_stateManager:StateManager, currentState: Array<string>, action: StateAction): Array<string>|undefined {
+        switch(action.type){
+            case Action.RECORDS_REMOVED:
+                return (currentState||[]).concat(action.payload);
+            case Action.EDITION_CANCELED:
+            case Action.DATA_SAVED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+
+export const RemovedRecordsReducer = new RemovedRecordsReducerImpl();
+
+export const getRemovedRecords = (stateManager: StateManager): Array<string> => {
+    return stateManager.select(RemovedRecordsReducer.sliceName, (state: Array<string>) => state);
+};

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

@@ -0,0 +1,128 @@
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+import { getCurrentRecords } from "./CurrentRecordsSlice";
+import { SavedRecord } from "../../DataUnit";
+
+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.DATA_SAVED:
+                return updateSavedIds(stateManager, action.payload.records);
+            case Action.RECORDS_REMOVED:
+                const removed: Array<string> = action.payload;
+                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

@@ -0,0 +1,30 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { UnitMetadata, FieldMetadata } from "../../metadata/UnitMetadata";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+
+
+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 getFieldMetadata = (stateManager: StateManager, fieldName: string): FieldMetadata|undefined => {
+    const md: UnitMetadata = getMetadata(stateManager);
+    return md ? md.fields.find(fmd => fmd.name === fieldName) : undefined;
+}

package/src/index.ts

@@ -8,6 +8,7 @@ import { HttpProvider } from "./http/HttpProvider";
 import { SkwHttpProvider } from "./http/SkwHttpProvider";
 import { RequestMetadata } from "./http/RequestMetadata";
 import { AuthorizedServiceCaller } from "./http/AuthorizedServiceCaller";
+import DataUnit from "./dataunit/DataUnit";
 
 /*Classes públicas no pacote*/
 export {
@@ -20,5 +21,6 @@ export {
     SkwHttpProvider,
     HttpProvider,
     RequestMetadata,
-    AuthorizedServiceCaller
+    AuthorizedServiceCaller,
+    DataUnit
 };