Revize 48690561

smol refactor

re #9741

frontend/src/features/TrackingTool/trackingToolSlice.ts

@@ -1 @@
-import { createSlice } from "@reduxjs/toolkit"
-import { LatLngTuple } from "leaflet"
-import mapConfig from "../../config/mapConfig"
-import { PathDto } from "../../swagger/data-contracts"
-import buildPathVariants from "./Map/pathUtils"
-import { isMapPointDisplayable, MapPoint, PathVariant } from "./trackingToolUtils"
-import { sendTextForProcessing } from "./trackingToolThunks"
-import storage from "redux-persist/lib/storage"
+import { createSlice } from '@reduxjs/toolkit'
+import mapConfig from '../../config/mapConfig'
+import { PathDto } from '../../swagger/data-contracts'
+import buildPathVariants from './Map/mapUtils'
 import TrackingToolState from './trackingToolState'
-
-
-const defaultPathsPerPage = 5
+import { sendTextForProcessing } from './trackingToolThunks'
+import { calculateMapCenter, MapPoint, PathVariant } from './trackingToolUtils'
 
 const initialState: TrackingToolState = {
     isLoading: false,
     mapCenter: [mapConfig.defaultCoordinates[0], mapConfig.defaultCoordinates[1]],
-    primaryPathIdx: 0,
+    displayedPathIdx: 0,
     dialogApiCallSuccess: true,
-    pathsPerPage: defaultPathsPerPage,
-    currentPage: 0,
-}
-
-const calculateMapCenter = (pathVariant: PathVariant): LatLngTuple | undefined => {
-    const displayableItems = pathVariant.filter((item) => isMapPointDisplayable(item))
-    if (displayableItems.length === 0) {
-        return undefined
-    }
-
-    return [
-        displayableItems
-            .map((item) => item.catalogItem.latitude ?? 0)
-            .reduce((a, b) => a + b, 0) / displayableItems.length,
-        displayableItems
-            .map((item) => item.catalogItem.longitude ?? 0)
-            .reduce((a, b) => a + b, 0) / displayableItems.length,
-    ]
-}
-
-const persistConfig = {
-    key: "auth",
-    storage, // localStorage for browsers
 }
 
 export const trackingToolSlice = createSlice({
-    name: "trackingTool",
+    name: 'trackingTool',
     initialState,
     reducers: {
-        consumeErr: (state: TrackingToolState) => ({
-            ...state,
-            lastErr: undefined,
-        }),
-        setPrimaryIdx: (state: TrackingToolState, action: any) => ({
-            ...state,
-            primaryPathIdx: action.payload,
-        }),
-        resetDialogApiCallSuccess: (state: TrackingToolState) => ({
-            ...state,
-            dialogApiCallSuccess: false,
-        }),
-        setPage: (state: TrackingToolState, action: { payload: number }) => ({
-            ...state,
-            currentPage: action.payload,
-        }),
-        updatePrimaryPath: (state: TrackingToolState, action: { payload: PathVariant }) => {
-            const { primaryPathIdx } = state
-            const path = action.payload
-            const paths = [...state.pathVariants ?? []]
-
-            if (paths.length <= primaryPathIdx) {
-                return { ...state }
-            }
-
-            return {
-                ...state,
-                pathVariants: [
-                    ...paths.slice(0, primaryPathIdx),
-                    path,
-                    ...paths.slice(primaryPathIdx + 1),
-                ],
-            }
-        },
-        // Updates map marker while ignoring its idx property
-        updateMapMarkerWithId: (state: TrackingToolState, action: { payload: { id: string, item: MapPoint } }) => {
-            const { item } = action.payload
-            const { primaryPathIdx } = state
-            if (!state.pathVariants || state.pathVariants.length <= primaryPathIdx) {
-                return state
-            }
-
-            const mapMarkerIdx = state.pathVariants[primaryPathIdx].findIndex((item) => item.id === action.payload.id)
-            if (mapMarkerIdx === -1) {
-                return state
-            }
-
-            const newPathVariant = [...state.pathVariants[primaryPathIdx]]
-            newPathVariant[mapMarkerIdx] = item
-            return {
-                ...state,
-                pathVariants: [...state.pathVariants.slice(0, primaryPathIdx), newPathVariant, ...state.pathVariants.slice(primaryPathIdx + 1)],
-            }
-        },
-        // Updates map marker based on its idx property
+        consumeErr: (state: TrackingToolState) => ({ ...state, lastErr: undefined, }),
+        setSelectedPathIdx: (state: TrackingToolState, action: { payload: number }) => ({ ...state, selectedPathIdx: action.payload, }),
+        resetDialogApiCallSuccess: (state: TrackingToolState) => ({ ...state, dialogApiCallSuccess: false, }),
+        // Updates currently displayed path
+        updateDisplayedPath: (state: TrackingToolState, action: { payload: PathVariant }) => ({ ...state, displayedPath: action.payload, }),
+        // Updates map marker
         updateMapMarker: (state: TrackingToolState, action: { payload: MapPoint }) => {
-            const item = action.payload
-            const { primaryPathIdx } = state
-            if (!state.pathVariants || state.pathVariants.length <= primaryPathIdx) {
-                return state
+            const newPath = [...state.displayedPath ?? []]
+            if (newPath.length <= action.payload.idx) {
+                return state // do nothing if there is no path
             }
 
+            newPath[action.payload.idx] = action.payload
             return {
                 ...state,
-                pathVariants: state.pathVariants.map((pathVariant, i) => {
-                    if (i !== primaryPathIdx) {
-                        return [...pathVariant]
-                    }
-
-                    return [
-                        ...pathVariant.slice(0, item.idx),
-                        item,
-                        ...pathVariant.slice(item.idx + 1),
-                    ]
-                })
+                displayedPath: newPath,
             }
         },
-        // Removes map marker based on its idx property
+        // Removes map marker from currently used path
         removeMapMarker: (state: TrackingToolState, action: { payload: { id: string, idx: number } }) => {
-            const item = action.payload
-            const idx = state.primaryPathIdx
-            if (!state.pathVariants || state.pathVariants.length <= idx) {
-                return state
+            const newPath = [...state.displayedPath ?? []]
+            if (newPath.length <= action.payload.idx) {
+                return state // do nothing if there is no path
             }
 
             return {
                 ...state,
-                pathVariants: state.pathVariants.map((pathVariant, i) => {
-                    if (i !== idx) {
-                        return [...pathVariant]
-                    }
-
-                    return [
-                        ...pathVariant.slice(0, item.idx),
-                        ...pathVariant.slice(item.idx + 1),
-                    ]
-                })
+                displayedPath: [...newPath.slice(0, action.payload.idx), ...newPath.slice(action.payload.idx + 1)],
             }
         },
+        // Moves map marker in the path array
         moveMarkerToDestination: (state: TrackingToolState, action: { payload: { destination: number, source: number } }) => {
             const { destination, source } = action.payload
-            if (!state.pathVariants || state.pathVariants.length === 0) {
-                return state
+            const newPath = [...state.displayedPath ?? []]
+            if (newPath.length <= source
+                || newPath.length <= destination
+                || source === destination) {
+                return state // do nothing if there is no path
             }
 
+            // JS array dark magic
+            const [removed] = newPath.splice(action.payload.source, 1)
+            newPath.splice(destination, 0, removed)
             return {
                 ...state,
-                pathVariants: state.pathVariants.map((pathVariant, i) => {
-                    if (state.primaryPathIdx !== i) {
-                        return [...pathVariant]
-                    }
-
-                    if (pathVariant.length <= destination || pathVariant.length <= source) {
-                        return [...pathVariant]
-                    }
-
-                    // JS dark magic splice
-                    const result = [...pathVariant]
-                    const [removed] = result.splice(source, 1)
-                    result.splice(destination, 0, removed)
-                    return result.map((item, idx) => ({ ...item, idx }))
-                })
+                displayedPath: newPath.map((item, idx) => ({ ...item, idx })),
             }
         },
         clear: () => ({ ...initialState }),
         mergeWithCurrentPath: (state: TrackingToolState, action: { payload: PathVariant }) => {
             const { payload: jsonPath } = action
             if (!jsonPath) {
-                return { ...state }
-            }
-
-            const pathVariants = [...state.pathVariants ?? []]
-            let primaryPathIdx = state.primaryPathIdx
-            let currentPage = state.currentPage
-
-            // If there are no path append a new array to the pathVariants array and set primaryIdx to 0
-            if (pathVariants.length === 0) {
-                primaryPathIdx = 0
-                currentPage = 0
-                pathVariants.push([])
+                return state
             }
 
-            // Get the path and create a map to check whether some point with the same id already exists
-            const path = pathVariants[primaryPathIdx]
-            const pathMap = new Map(path.map((item) => [item.catalogItem.id as string, item]))
+            const newPath = [...state.displayedPath ?? []]
+            const existingIds = new Set(newPath.map(item => item.id ?? ''))
 
-            // Create an array of items to be replaced and items to be added to the end
-            // const itemsToReplace: MapPoint[] = []
-            const itemsToAdd: MapPoint[] = []
-            jsonPath.forEach((item) => {
-                if (!pathMap.has(item.catalogItem.id ?? '')) {
-                    itemsToAdd.push(item)
-                    return
+            const newItems: MapPoint[] = []
+            jsonPath.forEach(item => {
+                if (!existingIds.has(item.id ?? '')) {
+                    newItems.push(item)
                 }
-
-                // const idx = pathMap.get(item.catalogItem.id as string)!.idx
-                // item.idx = idx
-                // itemsToReplace.push(item)
             })
 
-            // Iterate over items to replace and replace them
-            const newPath = [...path]
-            // itemsToReplace.forEach((item) => {
-            //     newPath[item.idx] = item
-            // })
-
-            // Add items to the end
-            itemsToAdd.forEach((item) => {
+            newItems.forEach(item => {
                 item.addToPath = !state.pathVariants || state.pathVariants.length === 0
                 item.idx = newPath.length
                 newPath.push(item)
             })
 
-            // Return the new path
             return {
                 ...state,
-                pathVariants: [
-                    ...pathVariants.slice(0, primaryPathIdx),
-                    newPath,
-                    ...pathVariants.slice(primaryPathIdx + 1),
-                ],
-                primaryPathIdx, // in case the list is empty
-                currentPage, // in case the list is empty
+                displayedPath: newPath,
             }
-        }
+        },
     },
     extraReducers: (builder) => {
         builder.addCase(sendTextForProcessing.fulfilled, (state, action) => {
             const pathDto: PathDto = action.payload
             const pathVariants = buildPathVariants(pathDto)
+            const selectedPath = pathVariants.length > 0 ? pathVariants[0] : undefined
+            if (!selectedPath) {
+                return {
+                    ...state,
+                    pathDto,
+                    pathVariants,
+                    displayedPath: undefined,
+                    displayedPathIdx: 0,
+                    dialogApiCallSuccess: true,
+                    isLoading: false,
+                }
+            }
 
-            const mapCenter = calculateMapCenter(pathVariants[state.primaryPathIdx])
+            const mapCenter = calculateMapCenter(selectedPath)
             return {
                 ...state,
                 pathVariants,
@@ -245 +120 @@
                 isLoading: false,
                 dialogApiCallSuccess: true,
                 currentPage: 0,
+                displayedPath: selectedPath,
+                displayedPathIdx: 0,
             }
         })
         builder.addCase(sendTextForProcessing.rejected, (_, action) => ({
@@ -253 +130 @@
             isLoading: false,
             dialogApiCallSuccess: false,
             currentPage: 0,
+            displayedPath: undefined,
+            displayedPathIdx: 0,
+            pathDto: undefined,
+            pathVariants: undefined,
         }))
-        builder.addCase(sendTextForProcessing.pending, (state) => {
-            return {
-                ...state,
-                isLoading: true,
-                dialogApiCallSuccess: false,
-            }
-        })
-    },
+        builder.addCase(sendTextForProcessing.pending, (state) => ({
+            ...state,
+            isLoading: true,
+            dialogApiCallSuccess: false,
+        }))
+    }
 })
 
 export const {
     consumeErr,
-    setPrimaryIdx,
+    setSelectedPathIdx,
     resetDialogApiCallSuccess,
-    clear,
+    updateDisplayedPath,
     updateMapMarker,
-    mergeWithCurrentPath,
-    moveMarkerToDestination,
-    updateMapMarkerWithId,
     removeMapMarker,
-    updatePrimaryPath
+    moveMarkerToDestination,
+    clear,
+    mergeWithCurrentPath,
 } = trackingToolSlice.actions
+
 const trackingToolReducer = trackingToolSlice.reducer
 export default trackingToolReducer