aswi2023one-team-to-rule-them-all-gitlab/src/stores/reducers/planSlice.ts @ 7652bb26

import { PayloadAction, createSlice } from "@reduxjs/toolkit"
import { PlanViewState } from "../../types/plan";
import { getFloorList, getPlanFloorImage, getPlanInventories, getPlanItems } from "../actions/planThunks";

const initialState: PlanViewState = {
    lastError: "",

    // TODO backend -> retrieve list of floors, not static -> not implemented at the time of coding
    floorList: [
    ],
    floorListLoading: false,

    itemInventories: [],
    itemInventoriesLoading: false,

    // reseting itemList
    itemListLoading: {},
    itemList: {},
    itemListPagination: {},
}

export const planSlice = createSlice({
    name: "plan",
    initialState: initialState,
    reducers: {},
    extraReducers: (builder) => {

        // getFloorList
        builder.addCase(getFloorList.fulfilled, (state, action) => {
            state.floorList = action.payload
            state.floorListLoading = false;
        })
        builder.addCase(getFloorList.pending, (state, action) => {
            state.floorListLoading = true;
        })
        builder.addCase(getFloorList.rejected, (state, action) => {
            state.floorListLoading = false;
            state.lastError = action.error.message
        })

        // getPlanItems
        builder.addCase(getPlanItems.fulfilled, (state, action) => {
            if (!state.itemList) {
                state.itemList = {}
            }

            if (action.meta.arg.inventory in state.itemList) {
                state.itemList[action.meta.arg.inventory] = state.itemList[action.meta.arg.inventory].concat(action.payload.items)
            }
            else {
                state.itemList[action.meta.arg.inventory] = action.payload.items
            }

            if (!state.itemListLoading) {
                state.itemListLoading = {}
            }
            state.itemListLoading[action.meta.arg.inventory] = false;

            if (!state.itemListPagination) {
                state.itemListPagination = {}
            }
            state.itemListPagination[action.meta.arg.inventory] = action.payload.inventoryPagination;
        })

        builder.addCase(getPlanItems.pending, (state, action) => {

            if (!state.itemListLoading) {
                state.itemListLoading = {}
            }
            state.itemListLoading[action.meta.arg.inventory] = true;
        })
        builder.addCase(getPlanItems.rejected, (state, action) => {

            if (!state.itemListLoading) {
                state.itemListLoading = {}
            }
            state.itemListLoading[action.meta.arg.inventory] = false;
            state.lastError = action.error.message
        })

        // getPlanInventories
        builder.addCase(getPlanInventories.fulfilled, (state, action) => {
            state.itemInventories = action.payload.inventories
            state.totalItemsCount = action.payload.allInventoriesRecords
            state.itemInventoriesLoading = false;

            // reseting itemList
            state.itemListLoading = {}
            state.itemList = {}
            state.itemListPagination = {}
        })
        builder.addCase(getPlanInventories.pending, (state, action) => {
            state.itemInventoriesLoading = true;
        })
        builder.addCase(getPlanInventories.rejected, (state, action) => {
            state.itemInventoriesLoading = false;
            state.lastError = action.error.message
        })

        // getPlanFloorImage
        builder.addCase(getPlanFloorImage.fulfilled, (state, action) => {
            state.mapImage = action.payload
            state.mapImageLoading = false
        })
        builder.addCase(getPlanFloorImage.pending, (state, action) => {
            state.mapImageLoading = true
        })
        builder.addCase(getPlanFloorImage.rejected, (state, action) => {
            state.mapImageLoading = false;
            state.lastError = action.error.message
        })
    }
})

export default planSlice.reducer