Revize 14588cb6

fixed keys and indices

re #9741

frontend/src/features/TrackingTool/trackingToolSlice.ts

@@ -1 +1 @@
 import { createSlice } from '@reduxjs/toolkit'
 import mapConfig from '../../config/mapConfig'
 import { PathDto } from '../../swagger/data-contracts'
+import generateUuid from '../../utils/id/uuidGenerator'
 import buildPathVariants from './Map/mapUtils'
 import TrackingToolState from './trackingToolState'
 import { sendTextForProcessing } from './trackingToolThunks'
-import { calculateMapCenter, MapPoint, PathVariant } from './trackingToolUtils'
+import { calculateMapCenter, MapPoint, PathVariant, setMapPointIds } from './trackingToolUtils'
 
 const initialState: TrackingToolState = {
     isLoading: false,
@@ -18 +19 @@
     initialState,
     reducers: {
         consumeErr: (state: TrackingToolState) => ({ ...state, lastErr: undefined, }),
-        setSelectedPathIdx: (state: TrackingToolState, action: { payload: number }) => ({ ...state, selectedPathIdx: action.payload, }),
-        resetDialogApiCallSuccess: (state: TrackingToolState) => ({ ...state, dialogApiCallSuccess: false, }),
+        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 }) => {
+        updateDisplayedPath: (state: TrackingToolState, action: { payload: PathVariant }) =>
+            ({ ...state, displayedPath: action.payload, }),
+        updateMapPointAtIndex: (state: TrackingToolState, action: { payload: MapPoint }) => {
             const newPath = [...state.displayedPath ?? []]
             if (newPath.length <= action.payload.idx) {
                 return state // do nothing if there is no path
@@ -35 +38 @@
                 displayedPath: newPath,
             }
         },
+        // Updates map marker
+        updateMapPoint: (state: TrackingToolState, action: { payload: MapPoint }) => {
+            const newPath = [...state.displayedPath ?? []]
+            return {
+                ...state,
+                displayedPath: newPath.map((point, _) => point.id === action.payload.id ? {...action.payload, idx: point.idx} : point)
+            }
+        },
         // Removes map marker from currently used path
         removeMapMarker: (state: TrackingToolState, action: { payload: { id: string, idx: number } }) => {
             const newPath = [...state.displayedPath ?? []]
@@ -47 +58 @@
                 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 } }) => {
+        // Changes marker index
+        changeMarkerIdx: (state: TrackingToolState, action: { payload: { destination: number, source: number } }) => {
             const { destination, source } = action.payload
             const newPath = [...state.displayedPath ?? []]
             if (newPath.length <= source
@@ -74 +85 @@
 
             const newPath = [...state.displayedPath ?? []]
             const existingIds = new Set(newPath.map(item => item.id ?? ''))
-
             const newItems: MapPoint[] = []
             jsonPath.forEach(item => {
                 if (!existingIds.has(item.id ?? '')) {
@@ -85 +95 @@
             newItems.forEach(item => {
                 item.addToPath = !state.pathVariants || state.pathVariants.length === 0
                 item.idx = newPath.length
+                const uuid = generateUuid()
+                item.reactId = uuid
+                item.id = item.catalogItem.id ? item.catalogItem.id : uuid
                 newPath.push(item)
             })
 
@@ -106 +119 @@
 
             // We will always have displayedPath defined if this function is called
             pathVariants.splice(previousIdx, 0, [...state.displayedPath ?? []])
-            const newPath = pathVariants.splice(newIdx, 1)[0]
+            const newPath = setMapPointIds(pathVariants.splice(newIdx, 1)[0])
             return {
                 ...state,
                 displayedPath: newPath,
@@ -114 +127 @@
                 pathVariants,
             }
         },
-        moveToNextPathVariant: (state: TrackingToolState) => {
-            const currentPathIdx = state.displayedPathIdx
-            const pathVariants = [...state.pathVariants ?? []]
-
-            // Since we take out the selected path index the displayedPathIdx will serve as
-            // index of the next element
-            if (currentPathIdx >= pathVariants.length) {
-                return state // do nothing if the displayed path is also the last one
-            }
-
-            // Else get the next path variant
-            const newPath = [...pathVariants[currentPathIdx]]
-            const previousPath = [...state.displayedPath ?? []]
-
-            // And replace the displayed path with the new one
-            return {
-                ...state,
-                displayedPath: newPath,
-                displayedPathIdx: currentPathIdx + 1,
-                pathVariants: [
-                    ...pathVariants.slice(0, currentPathIdx),
-                    previousPath,
-                    ...pathVariants.slice(currentPathIdx + 1),
-                ]
-            }
-        },
-        moveToPreviousPathVariant: (state: TrackingToolState) => {
-            const currentPathIdx = state.displayedPathIdx
-            const pathVariants = [...state.pathVariants ?? []]
-
-            const previousPathIdx = currentPathIdx - 1
-            if (previousPathIdx < 0) {
-                return state // do nothing if the displayed path is the first one
-            }
-
-            // Else get the previous path variant
-            const newPath = [...pathVariants[previousPathIdx]]
-            const previousPath = [...state.displayedPath ?? []]
-
-            return {
-                ...state,
-                displayedPath: newPath,
-                displayedPathIdx: previousPathIdx,
-                pathVariants: [
-                    ...pathVariants.slice(0, previousPathIdx),
-                    previousPath,
-                    ...pathVariants.slice(previousPathIdx + 1),
-                ]
-            }
-        }
     },
     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
+            const selectedPath = pathVariants.length > 0 ? setMapPointIds(pathVariants[0]) : undefined
             pathVariants.splice(0, 1) // remove the selected path so that we do not have to update it here
             if (!selectedPath) {
                 return {
@@ -220 +183 @@
     setSelectedPathIdx,
     resetDialogApiCallSuccess,
     updateDisplayedPath,
-    updateMapMarker,
+    updateMapPoint,
     removeMapMarker,
-    moveMarkerToDestination,
+    changeMarkerIdx,
     clear,
     mergeWithCurrentPath,
     setDisplayedPathIdx,
+    updateMapPointAtIndex
 } = trackingToolSlice.actions
 
 const trackingToolReducer = trackingToolSlice.reducer