ca-mfe-page-scoring-ui/src/store/parentAndGovernment/parentAndGovernment.reducer.ts

This is a react shell for the SPGI Platform MFE implementation

import { createSlice } from '@reduxjs/toolkit';
import _ from 'lodash';

export const parentAndGovernmentSlice = createSlice({
    name: 'parentAndGovernment',
    initialState: {
        periodDates: [],
        missingFocusFinInputs: [],
        parentGovernment:{
            original: {},
            current: {}
        },
        parentCompany: {},
        parentInfo: {},
        selectedDataInputs: {},
        isLoading: true,
        onlyParentLoad: false
    },
    reducers: {
        fetchInit: state => {
            state.isLoading = true;
        },
        fetchParent: state => {
            state.onlyParentLoad = true;
        },
        fetchparentAndGovernment: (state, action) => {
            state.parentGovernment.original = action.payload;
            state.parentGovernment.current = action.payload;
            state.isLoading = false;
            state.onlyParentLoad = false;
        },
        fetchOnlyparent: (state, action) => {
            const parentSections = (() => {
                const sectionsObj = {};
                state?.parentGovernment?.original?.data?.parent?.forEach((p, i) => (sectionsObj[p.groupItemCode] = i));
                return sectionsObj;
              })();
            const updateParentState = _.cloneDeep(state?.parentGovernment?.original?.data);

            action.payload?.data?.parent.forEach(group => {
                updateParentState.parent.splice(parentSections[group.groupItemCode], 1, group);
            });
            updateParentState.nonFinPgMetrics = action.payload?.data?.nonFinPgMetrics;
            const actionPayload = _.cloneDeep(action?.payload);
            actionPayload.data = updateParentState;
            state.parentGovernment.original = actionPayload;
            state.parentGovernment.current = actionPayload;
            state.onlyParentLoad = false;
            state.isLoading = false;
        },
        updateParentAndGovernment: (state, action) => {
            state.parentGovernment.current = action.payload;
        },
        fetchPeriodDates: (state, action) =>{
            state.periodDates = action.payload;
        },
        fetchParentCompany: (state, action) => {
            state.parentCompany = action.payload;
            state.isLoading = true;
        },
        selectedParentDataInputs: (state, action) => {
            state.selectedDataInputs = action.payload;
        },
        fetchMissingFocusFins: (state, action) => {
            state.missingFocusFinInputs = action.payload;
        },
        clearAllValidationsForGovtSupport: state => {
            state.parentGovernment.current?.data?.government.forEach(group => {
                group?.metrics.forEach(metric => {
                    metric.isNotValidInput = false;
                });
            });
        },
        clearAllValidationsForParentSupport: state => {
            state.parentGovernment.current?.data?.parent.forEach(group => {
                group?.metrics.forEach(metric => {
                    metric.isNotValidInput = false;
                });
            });
        },
        updateParentMetricValidation: (state, action) => {
            const { analyticsName, isNotValidInput = false} = action.payload;
            if(analyticsName){
                state.parentGovernment.current?.data?.parent.forEach(group => {
                    group?.metrics.forEach(metric => {
                        if(metric.analyticsName === analyticsName){
                            metric.isNotValidInput = isNotValidInput;
                        }
                    });
                });
            }
        }
    }
});

export const {fetchparentAndGovernment,
    fetchPeriodDates,
    fetchParentCompany,
    selectedParentDataInputs,
    fetchInit, fetchParent,
    fetchOnlyparent,
    updateParentAndGovernment,
    fetchMissingFocusFins,
    clearAllValidationsForGovtSupport,
    clearAllValidationsForParentSupport,
    updateParentMetricValidation
} = parentAndGovernmentSlice.actions;
export default parentAndGovernmentSlice.reducer;