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

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

@@ -0,0 +1,48 @@
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+import { Record } from "../../DataUnit.js";
+
+class AddedRecordsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "hist::addedRecords";
+
+    public reduce(_stateManager:StateManager, currentState: Array<Record>, action: StateAction): Array<Record>|undefined {
+        switch(action.type){
+            case Action.RECORDS_ADDED:
+            case Action.RECORDS_COPIED:
+                return (currentState||[]).concat(action.payload);
+            case Action.DATA_SAVED:
+            case Action.EDITION_CANCELED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+
+export const AddedRecordsReducer = new AddedRecordsReducerImpl();
+
+export const getAddedRecords = (stateManager: StateManager): Array<Record> => {
+    return stateManager.select(AddedRecordsReducer.sliceName, (state: Array<Record>) => state);
+};
+
+export const prepareAddedRecordId = (stateManager: StateManager, source: Array<any>, parentRecordId?: string): Array<Record> => {
+    let index = (getAddedRecords(stateManager) || []).length;
+    return source.map(item => ({
+        ...item,
+        __record__id__: `NEW_${index++}`,
+        ...(parentRecordId && { __parent__record__id__: parentRecordId }),
+    }));
+};
+
+export const prepareCopiedRecord = (stateManager: StateManager, source: Array<Record>, parentRecordId?: string): Array<Record> => {
+    let index = (getAddedRecords(stateManager)||[]).length;
+    return source.map(item => ({
+        ...item,
+        __record__id__: "NEW_" + (index++),
+        ...(parentRecordId && { __parent__record__id__: parentRecordId }),
+        __record__source__id__: item.__record__id__,
+        __copy__: true})
+    );
+};

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

@@ -0,0 +1,125 @@
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+import { getRecords } from "./RecordsSlice.js";
+import { getRemovedRecords } from "./RemovedRecordsSlice.js";
+import { getAddedRecords } from "./AddedRecordsSlice.js";
+import { Change, ChangeOperation, Record } from "../../DataUnit.js";
+import { getWaitingChanges } from "./WaitingChangesSlice.js";
+import { getSelectionRecords } from './SnapshotSlice.js';
+
+class ChangesReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "hist::changes";
+
+    public reduce(stateManager:StateManager, currentState: Map<string, any>, action: StateAction):  Map<string, any>|undefined {
+        switch(action.type){
+            case Action.RECORDS_COPIED:
+                const records: Array<Record> = action.payload;
+                const changes = new Map(getChanges(stateManager));
+                records.forEach(
+                    r => {
+                        const rChanges = {...changes.get(r.__record__id__), ...r};
+                        delete rChanges.__old__id__;
+                        delete rChanges.__record__id__;
+                        delete rChanges.__parent__record__id__;
+                        delete rChanges.__record__source__id__;
+                        delete rChanges.__record__label__;
+                        delete rChanges.__copy__;
+                        delete rChanges.__owner__dataunit__name__;
+                        changes.set(r.__record__id__, rChanges);
+                    }
+                );
+                return changes;
+            case Action.DATA_CHANGED:
+                const selection: Array<string> = action.payload.records || getSelectionRecords(stateManager)?.map(record => record.__record__id__);
+                if(selection){
+                    const newState = new Map(currentState);
+                    selection.forEach(recordId => {
+                        const newChanges = {...newState.get(recordId), ...action.payload};
+                        delete newChanges.records;
+                        newState.set(recordId, newChanges);
+                    });
+                    return newState;
+                }
+                return currentState;
+
+            case Action.DATA_SAVED:
+            case Action.EDITION_CANCELED:
+                return undefined;
+        } 
+        return currentState;
+    }
+
+}
+
+export const ChangesReducer = new ChangesReducerImpl();
+
+export const getChanges = (stateManager: StateManager): Map<string, any> => {
+    return stateManager.select(ChangesReducer.sliceName, (state: Map<string, any>) => state);
+}
+
+export const isDirty = (stateManager: StateManager): boolean => {
+
+    if (getAddedRecords(stateManager) !== undefined) {
+        return true;
+    }
+
+    if (getRemovedRecords(stateManager) !== undefined) {
+        return true;
+    }
+
+    return hasDirtyRecords(stateManager);
+}
+
+export const hasDirtyRecords = (stateManager: StateManager): boolean => {
+    if(getWaitingChanges(stateManager) !== undefined){
+        return true;
+    }
+
+    return getChanges(stateManager) !== undefined;
+}
+
+export const getChangesToSave = (dataUnit: string, stateManager: StateManager): Array<Change> => {
+    const result: Array<Change> = [];
+
+    const changes = getChanges(stateManager);
+    const records = getSelectionRecords(stateManager);
+
+    records?.forEach(r => {
+        if(changes){
+            const c = changes.get(r.__record__id__);
+            if (c) {
+                result.push(new Change(dataUnit, r, c, ChangeOperation.UPDATE,  r.__record__source__id__));
+            }
+        }
+    });
+
+    const addedRecords = getAddedRecords(stateManager);
+    if (addedRecords) {
+        addedRecords.forEach(r => {
+            const operation: ChangeOperation = r.__copy__ ? ChangeOperation.COPY : ChangeOperation.INSERT;
+            const changedFields = {...changes?.get(r.__record__id__)};
+            if(operation === ChangeOperation.INSERT){
+                Object.keys(r).forEach(fieldName => {
+                    if(!fieldName.startsWith("__") && !Object.keys(changedFields)?.includes(fieldName)){
+                        changedFields[fieldName] = r[fieldName];
+                    }
+                });
+            }
+            result.push(new Change(dataUnit, r, changedFields, operation, r.__record__source__id__));
+        });
+    }
+
+    const removedRecords = getRemovedRecords(stateManager);
+    const recordsById: any = {};
+    records?.forEach(r=>recordsById[r.__record__id__] = r);
+    if (removedRecords) {
+        removedRecords.forEach(id => {
+            result.push(new Change(dataUnit, recordsById[id], undefined, ChangeOperation.DELETE));
+        });
+    }
+
+    return result;
+}

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

@@ -0,0 +1,85 @@
+
+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 InvalidFieldsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "hist::invalidFields";
+        
+    public reduce(_stateManager:StateManager, currentState: Map<string, Map<string, string>>, action: StateAction): Map<string, Map<string, string>>|undefined {
+
+        switch(action.type){
+            case Action.FIELD_INVALIDATED:
+                return makeInvalid(currentState, action.payload);
+            case Action.INVALIDATE_CLEAN:
+                return clearRecord(currentState, action.payload);
+        }
+
+        return currentState;
+    }
+}
+
+export const InvalidFieldsReducer = new InvalidFieldsReducerImpl();
+
+export const getInvalidFields = (stateManager: StateManager):  Map<string, Map<string, string>> => {
+    return stateManager.select(InvalidFieldsReducer.sliceName, (state: Map<string, Map<string, string>>) => state);
+};
+
+export const getInvalidFieldMessage = (stateManager: StateManager, fieldName: string, recordId: string): string | undefined => {
+    const invalidFields = getInvalidFields(stateManager);
+    if(invalidFields){
+        const recordInvalidFields = invalidFields.get(recordId);
+        if(recordInvalidFields){
+            return recordInvalidFields.get(fieldName);
+        }
+    }
+    return undefined;
+}
+
+const clearRecord = (currentState:Map<string, Map<string, string>>, payload: any): Map<string, Map<string, string>>|undefined => {
+
+    const {recordId, fieldName} = payload;
+
+    if(recordId == undefined){
+        return undefined;
+    }
+
+    if(currentState){
+        const recordInvalidFields = currentState.get(recordId);
+        if(recordInvalidFields){
+            const newState: Map<string, Map<string, string>> = new Map(currentState);
+            if(fieldName == undefined){
+                newState.delete(recordId);
+            } else {
+                const newRecorcInvalidFields: Map<string, string> = new Map(recordInvalidFields);
+                newRecorcInvalidFields.delete(fieldName);
+                if(newRecorcInvalidFields.size > 0){
+                    newState.set(recordId, newRecorcInvalidFields);
+                } else {
+                    newState.delete(recordId);
+                }
+                return newState;
+            }
+        }
+
+        return currentState;
+    }
+
+    return undefined;
+}
+
+const makeInvalid = (currentState:Map<string, Map<string, string>>, payload: any): Map<string, Map<string, string>>|undefined => {
+
+    const {recordId, message, fieldName} = payload;
+    
+    const recordInvalidFields = new Map(currentState?.get(recordId));
+    recordInvalidFields.set(fieldName, message);
+
+    const newState = new Map(currentState);
+    newState.set(recordId, recordInvalidFields);
+
+    return newState;
+}

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

@@ -0,0 +1,60 @@
+
+import { LoadDataRequest } from "../../loading/LoadDataRequest.js";
+import { PaginationInfo } from "../../loading/PaginationInfo.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager, { ActionReducer, StateAction } from "../StateManager.js";
+
+class LoadingControlReducerImpl implements ActionReducer {
+
+    public sliceName: string = "loadingControl";
+
+    public reduce(stateManager: StateManager, currentState: LoadingControlState, action: StateAction): LoadingControlState {
+        switch (action.type) {
+            case Action.LOADING_DATA :
+                return {...currentState, lastRequest: action.payload};
+            case Action.DATA_LOADED:
+                return {...currentState, paginationInfo: action.payload?.paginationInfo};
+        }
+        return currentState;
+    }
+}
+
+export const LoadingControlReducer = new LoadingControlReducerImpl();
+
+export const getPaginationInfo = (stateManager: StateManager): PaginationInfo|undefined => {
+    const state: LoadingControlState = stateManager.select(LoadingControlReducer.sliceName, (state: LoadingControlState) => state);
+    return state ? state.paginationInfo : undefined;
+};
+
+export const getCurrentRequest = (stateManager: StateManager): LoadDataRequest|undefined => {
+    const state: LoadingControlState = stateManager.select(LoadingControlReducer.sliceName, (state: LoadingControlState) => state);
+    return state ? state.lastRequest : undefined;
+};
+
+export const getCurrentPage = (stateManager: StateManager): number => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? paginationInfo.currentPage : 0;
+};
+
+export const getLastPage = (stateManager: StateManager, pageSize: number): number => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? Math.ceil(paginationInfo.total / pageSize) : 0;
+};
+
+export const hasMorePages = (stateManager: StateManager): boolean => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    if(paginationInfo && paginationInfo.hasMore){
+        return true;
+    }
+    return false;
+}
+
+export const hasPreviousPages = (stateManager: StateManager): boolean => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? paginationInfo.currentPage > 0 : false;
+}
+
+interface LoadingControlState{
+    lastRequest: LoadDataRequest;
+    paginationInfo: PaginationInfo;
+}

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

@@ -0,0 +1,74 @@
+import { ActionReducer, StateAction } from "../StateManager.js";
+import StateManager from "../StateManager.js";
+import { getRemovedRecords } from "./RemovedRecordsSlice.js";
+import { Action } from "../action/DataUnitAction.js";
+import { Record, SavedRecord } from "../../DataUnit.js";
+
+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 ? action.payload.records : undefined;
+            case Action.RECORDS_REMOVED:
+                
+                const {records, buffered} = action.payload;
+                if(!buffered){
+                    return currentState.filter(r=>!records.includes(r.__record__id__));
+                }
+                return currentState;
+                
+            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 newRecords: Array<Record> = [];
+                const savedRecords: Array<SavedRecord> = action.payload.records;
+                savedRecords.forEach(sr => {
+                    const recordId = sr.__old__id__ || sr.__record__id__;
+                    const newRecord: Record = { ...sr };
+                    if(recordsMap.has(recordId)){
+                        recordsMap.set(recordId, newRecord);
+                    } else if(this.isNewRecord(newRecord)){
+                        newRecords.push(newRecord);
+                    }
+                    delete newRecord["__old__id__"];
+                });
+                return newRecords.concat(Array.from(recordsMap.values()));
+
+            case Action.RECORD_LOADED:
+                action.payload.forEach((record: any) => {
+                    for(let i = 0; i < currentState.length; i++){
+                        if(currentState[i].__record__id__ === record.__record__id__){
+                            currentState[i] = record;
+                        }
+                    }
+                });
+        }
+        return currentState;
+    }
+
+    private isNewRecord(record: Record){
+        return (!Object.prototype.hasOwnProperty.call(record,"__old__id__")
+          || record["__old__id__"] !== record["__record__id__"]);
+    }
+}
+
+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,30 @@
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+
+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:
+                const {records, buffered} = action.payload;
+                if(buffered){
+                    return (currentState||[]).concat(records);
+                }
+                return currentState;
+            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,193 @@
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+import { getCurrentRecords, getSelectionRecords } from "./SnapshotSlice.js";
+import { Record, SavedRecord, SelectionInfo, SelectionMode } from "../../DataUnit.js";
+import { getCurrentRequest, getPaginationInfo } from "./LoadingControlSlice.js";
+import { PaginationInfo } from "../../loading/PaginationInfo.js";
+
+class SelectionReducerImpl implements ActionReducer {
+
+    public sliceName: string = "hist::selection";
+
+    public reduce(stateManager: StateManager, currentState: SelectionState, action: StateAction): SelectionState|undefined {
+
+        switch (action.type) {
+            case Action.DATA_LOADED:
+                return !action.payload?.keepSelection ? undefined : currentState;
+            case Action.RECORDS_ADDED:
+            case Action.RECORDS_COPIED:
+                return {currentSelection: action.payload.map((r: Record)=>r.__record__id__), lastSelection: currentState?.currentSelection};
+            case Action.DATA_SAVED:
+                return {currentSelection: updateSavedIds(stateManager, action.payload.records)};
+            case Action.RECORDS_REMOVED:
+                const removed: Array<string> = action.payload.records;
+
+                if (currentState && removed) {
+                    const currentSelection = currentState.currentSelection;
+                    const record = currentSelection.filter(recordId => !removed.includes(recordId));
+
+                    if(record.length === 0) {
+                        const currentRecords = getCurrentRecords(stateManager);
+                        let removedIndex = action.payload.removedIndex.slice(-1)[0];
+                        let currentIndex = 0;
+
+                        if(removedIndex >= currentRecords.size - 1) {
+                            removedIndex--;
+                        } else {
+                            removedIndex++
+                        }
+
+                        currentRecords.forEach((value, key) => {
+                            if(currentIndex === removedIndex) {
+                                record.push(key);
+                            }
+                            currentIndex++;
+                        })
+                        
+                    }
+                    return {currentSelection: record};
+                }
+                return currentState;
+
+            case Action.NEXT_SELECTED:
+            case Action.PREVIOUS_SELECTED:
+                
+                const currentRecords = getCurrentRecords(stateManager);
+                const currentSelection = currentState?.currentSelection;
+                if (currentRecords && currentRecords.size > 0) {
+                    let index: number;
+                    if (!currentState || currentSelection.length === 0) {
+                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                    } else {
+                        index = getItemIndex(currentSelection[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
+                    }
+                    if (index < currentRecords.size && index >= 0) {
+                        return { currentSelection: [Array.from(currentRecords.values())[index].__record__id__] };
+                    }
+                }
+
+                return undefined;
+
+            case Action.SELECTION_CHANGED:
+                const { type, selection: selectionSource } = action.payload;
+
+                if(selectionSource === SelectionMode.ALL_RECORDS){
+                    return {currentSelection: [], mode: SelectionMode.ALL_RECORDS};
+                }
+
+                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 {currentSelection: selectionById};
+                    }
+                }
+
+                return {currentSelection: selectionSource };
+            case Action.EDITION_CANCELED:
+                if(currentState?.lastSelection){
+                    return { currentSelection: currentState.lastSelection };
+                }
+                break;
+        }
+
+        return currentState;
+    }
+}
+
+export const SelectionReducer = new SelectionReducerImpl();
+
+export const getSelectionState = (stateManager: StateManager): SelectionState => {
+    return stateManager.select(SelectionReducer.sliceName, (state: SelectionState) => state);
+}
+
+export const getSelection = (stateManager: StateManager): Array<string> => {
+    let selection: Array<string> | undefined = getCurrentSelection(stateManager);
+
+    if (!selection || selection.length === 0) {
+        return [];
+    }
+
+    return selection;
+};
+
+export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
+
+    const selection = getSelectionState(stateManager);
+    if(selection && selection.mode === SelectionMode.ALL_RECORDS){
+        const currentRequest = getCurrentRequest(stateManager);
+        const paginationInfo: PaginationInfo | undefined = getPaginationInfo(stateManager);
+        return new SelectionInfo(
+            [],
+            SelectionMode.ALL_RECORDS,
+            paginationInfo?.total || 0,
+            currentRequest?.filters, 
+            currentRequest?.sort
+        );
+    }
+   
+    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined);
+}
+
+export const hasNext = (stateManager: StateManager): boolean => {
+    const records = getCurrentRecords(stateManager);
+    if (records) {
+        const selection = getCurrentSelection(stateManager);
+        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 = getCurrentSelection(stateManager);
+        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;
+}
+
+function getCurrentSelection(stateManager: StateManager):Array<string> | undefined{
+    const selectionState = getSelectionState(stateManager);
+    return selectionState ? selectionState.currentSelection : undefined;
+}
+
+interface SelectionState{
+    currentSelection: Array<string>;
+    mode?: SelectionMode;
+    lastSelection?: Array<string>;
+}