Revize de12c6be

draggable

re #9741

frontend/src/features/TrackingTool/trackingToolSlice.ts

@@ -1 @@
-import { createSlice } from '@reduxjs/toolkit'
-import { LatLngTuple } from 'leaflet'
-import { persistReducer } from 'redux-persist'
-import mapConfig from '../../config/mapConfig'
-import { PathDto } from '../../swagger/data-contracts'
-import buildPathVariants, { PathVariant } from './buildPathVariants'
-import { sendTextForProcessing } from './trackingToolThunks'
-import storage from 'redux-persist/lib/storage'
+import { createSlice } from "@reduxjs/toolkit"
+import { LatLngTuple } from "leaflet"
+import { persistReducer } from "redux-persist"
+import mapConfig from "../../config/mapConfig"
+import { PathDto } from "../../swagger/data-contracts"
+import buildPathVariants, { PathVariant } from "./buildPathVariants"
+import { sendTextForProcessing } from "./trackingToolThunks"
+import storage from "redux-persist/lib/storage"
 
 export interface TrackingToolState {
     isLoading: boolean // whether the data is being loaded
@@ -14 +14 @@
     lastError?: string // consumable for errors during thunks
     mapCenter: LatLngTuple // pair of latitude and longitude
     primaryPathIdx: number // index of the primary path
-    activePaths: Set<number> // indices of the active paths
     // trigger to close the dialog when API call is finished
     dialogApiCallSuccess: boolean
     pathsPerPage: number // max number of paths to show on the map at once
@@ -25 +24 @@
 
 const initialState: TrackingToolState = {
     isLoading: false,
-    mapCenter: [
-        mapConfig.defaultCoordinates[0],
-        mapConfig.defaultCoordinates[1],
-    ],
+    mapCenter: [mapConfig.defaultCoordinates[0], mapConfig.defaultCoordinates[1]],
     primaryPathIdx: 0,
-    activePaths: new Set(),
     dialogApiCallSuccess: true,
     pathsPerPage: defaultPathsPerPage,
     currentPage: 0,
@@ -38 +33 @@
 
 // Returns tuple of average latitude and longitude
 const calculateMapCenter = (pathVariant: PathVariant): LatLngTuple => [
-    pathVariant.map((item) => item.latitude ?? 0).reduce((a, b) => a + b, 0) /
-        pathVariant.length,
-    pathVariant.map((item) => item.longitude ?? 0).reduce((a, b) => a + b, 0) /
-        pathVariant.length,
+    pathVariant
+        .map((item) => item.catalogItem.latitude ?? 0)
+        .reduce((a, b) => a + b, 0) / pathVariant.length,
+    pathVariant
+        .map((item) => item.catalogItem.longitude ?? 0)
+        .reduce((a, b) => a + b, 0) / pathVariant.length,
 ]
 
 const persistConfig = {
-    key: 'auth',
+    key: "auth",
     storage, // localStorage for browsers
 }
 
 export const trackingToolSlice = createSlice({
-    name: 'trackingTool',
+    name: "trackingTool",
     initialState,
     reducers: {
-        consumeErr: (state: TrackingToolState) => ({ ...state, lastErr: undefined }),
+        consumeErr: (state: TrackingToolState) => ({
+            ...state,
+            lastErr: undefined,
+        }),
         setPrimaryIdx: (state: TrackingToolState, action: any) => ({
             ...state,
             primaryPathIdx: action.payload,
@@ -62 +62 @@
             ...state,
             dialogApiCallSuccess: false,
         }),
-        setPage: (state: TrackingToolState, action: any) => ({
+        setPage: (state: TrackingToolState, action: { payload: number }) => ({
             ...state,
             currentPage: action.payload,
         }),
-        clear: () => ({...initialState})
+        updateMapMarkerPosition: (state: TrackingToolState, action: any) => {
+            const { idx, mapPointIdx, position } = action.payload
+            if (!state.pathVariants || state.pathVariants.length <= idx) {
+                return state
+            }
+
+            return {
+                ...state,
+                pathVariants: state.pathVariants.map((pathVariant, i) => {
+                    if (i !== idx) {
+                        return [...pathVariant]
+                    }
+
+                    const mapPoint = pathVariant[mapPointIdx]
+                    mapPoint.catalogItem = {
+                        ...mapPoint.catalogItem,
+                        latitude: position[0],
+                        longitude: position[1]
+                    }
+
+                    return [
+                        ...pathVariant.slice(0, mapPointIdx),
+                        mapPoint,
+                        ...pathVariant.slice(mapPointIdx + 1),
+                    ]
+                })
+            }
+        },
+        clear: () => ({ ...initialState }),
     },
     extraReducers: (builder) => {
         builder.addCase(sendTextForProcessing.fulfilled, (state, action) => {
@@ -76 +104 @@
                 ...state,
                 pathVariants,
                 pathDto,
-                // TODO map this correctly
-                activePaths: new Set(pathVariants.map((_, idx) => idx)),
                 // TODO calculate correctly
                 mapCenter:
                     pathVariants.length > 0
@@ -105 +131 @@
     },
 })
 
-export const { consumeErr, setPrimaryIdx, resetDialogApiCallSuccess, clear } = trackingToolSlice.actions
+export const { consumeErr, setPrimaryIdx, resetDialogApiCallSuccess, clear, updateMapMarkerPosition } =
+    trackingToolSlice.actions
 const trackingToolReducer = trackingToolSlice.reducer
 export default trackingToolReducer