Revize a7ae217f

import export part 1

re #9741

frontend/src/features/TrackingTool/trackingToolSlice.ts

@@ -1 +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, { MapPoint, PathVariant } from "./buildPathVariants"
+import buildPathVariants, { isMapPointDisplayable, MapPoint, PathVariant } from "./pathUtils"
 import { sendTextForProcessing } from "./trackingToolThunks"
 import storage from "redux-persist/lib/storage"
+import TrackingToolState from './TrackingToolState'
 
-export interface TrackingToolState {
-    isLoading: boolean // whether the data is being loaded
-    pathDto?: PathDto // the data
-    pathVariants?: PathVariant[] // undefined signals that no path variants were yet fetched from the API
-    lastError?: string // consumable for errors during thunks
-    mapCenter: LatLngTuple // pair of latitude and longitude
-    primaryPathIdx: number // index of the primary path
-    // 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
-    currentPage: number // current page of paths - starts from 0
-}
 
 const defaultPathsPerPage = 5
 
@@ -32 +20 @@
 }
 
 const calculateMapCenter = (pathVariant: PathVariant): LatLngTuple | undefined => {
-    const displayableItems = pathVariant.filter((item) => item.displayable)
+    const displayableItems = pathVariant.filter((item) => isMapPointDisplayable(item))
     if (displayableItems.length === 0) {
         return undefined
     }
@@ -94 +82 @@
             }
         },
         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([])
+            }
+
+            // 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]))
+
+            // 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 as string)) {
+                    itemsToAdd.push(item)
+                    return
+                }
+                
+                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) => {
+                item.active = false
+                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
+            }
+        }
     },
     extraReducers: (builder) => {
         builder.addCase(sendTextForProcessing.fulfilled, (state, action) => {
@@ -128 +176 @@
     },
 })
 
-export const { consumeErr, setPrimaryIdx, resetDialogApiCallSuccess, clear, updateMapMarker } =
+export const { consumeErr, setPrimaryIdx, resetDialogApiCallSuccess, clear, updateMapMarker, mergeWithCurrentPath } =
     trackingToolSlice.actions
 const trackingToolReducer = trackingToolSlice.reducer
 export default trackingToolReducer