src/contexts/SpeedLimitStoreContext.tsx
unknown
typescript
6 months ago
37 kB
7
Indexable
import {
mutationAddNewTSOSpeedLimit,
mutationDeleteTSOSpeedLimitById,
mutationEditTSOSpeedLimitById
} from '@Redux/slices/portalActionSlice'
import { fetchSpeedLimitsDataByRouteId } from '@Redux/slices/portalDataSlice'
import { store } from '@Redux/store'
import { getTranslation } from '@Translations'
import { createSelectors } from '@Utils'
import { produce } from 'immer'
import { v4 as uuidv4 } from 'uuid'
import { create } from 'zustand'
import {
DiffTagType,
Direction,
speedLimitItemType,
SpeedLimitType,
StatusTypes,
StatusUpdate,
TSODiffReportStatus,
TSODiffReportType
} from '../ui/components/widgets/SpeedLimitSection/types'
import {
checkInvalidMileposts,
findMaxTSOLimit,
findOverlappingMileposts,
findOverlappingMilepostsForCompare
} from '../ui/components/widgets/SpeedLimitSection/utils/milepostsUtil'
type NestedField = string | (keyof TSODiffReportType)[]
type TSpeedLimitState = {
speedLimits: speedLimitItemType[] | null
tempSpeedLimits: speedLimitItemType[] | null
updateSpeedLimits: speedLimitItemType[] | null
zoneSpeedLimits: speedLimitItemType[] | null
compareData: TSODiffReportType[] | null
updateCompareList: TSODiffReportType[] | null
documentS3Uri: string | null
getTSODiffReportError: string | null
setGetTSODiffReportError: (error: any) => void
cleanGetTSODiffReportError: () => void
fetchData: ({
routeId,
railroadId,
startDestinationId,
endDestinationId
}: {
routeId?: string
railroadId: string
startDestinationId: string
endDestinationId: string
}) => Promise<void>
initializeTempData: () => void
initializeNewSpeedLimit: (payload: speedLimitItemType) => void
updateTempSpeedLimits: (
id: string,
field: keyof speedLimitItemType,
value: string | number | null
) => void
updateCompareData: (id: string, field: NestedField, value: any) => void
addNewTSOSpeedLimit: (payload: any, type?: 'compare' | 'update') => void
editTSOSpeedLimit: (payload: any, type?: 'compare' | 'update') => void
deleteTSOSpeedLimit: (payload: any, type?: 'compare' | 'update') => void
// sortSpeedLimit: () => void
removeFirstSpeedLimit: () => void
// editSpeedLimitItem: (item: speedLimitItemType, index: number) => void
changeStatusSpeedLimit: (payload: { id: string; status: StatusTypes }) => void
changeIsEditCompareSpeedLimit: (payload: {
id: string
isEdit: StatusTypes | null
}) => void
changeStatusCompareSpeedLimit: (payload: {
id: string
status: TSODiffReportStatus
}) => void
removeProperty: (prop: keyof speedLimitItemType) => void
removePropertyById: (prop: keyof speedLimitItemType, id: string) => void
checkValidLimit: (id: string, type: StatusTypes) => void
checkValidCompareLimit: (id: string) => void
checkValidMp: (
id: string,
name: keyof {
start_mile?: number
new_start_mile?: number | null
end_mile?: number
new_end_mile?: number | null
},
value: string
) => void
checkCompareValidMp: (
id: string,
name: keyof {
temp_start_milepost?: number | string | null
temp_end_milepost?: number | string | null
},
value: string
) => void
checkRangeMps: (id: string, startLimit: number, endLimit: number) => void
checkCompareRangeMps: (
id: string,
startLimit: number,
endLimit: number
) => void
findOverlapMileposts: (
id: string,
statusTypes: StatusTypes,
speedLimitType: SpeedLimitType
) => void
findOverlapCompareMileposts: (
id: string,
speedLimitType: SpeedLimitType
) => void
createUpdateList: () => void
createCompareList: () => void
deleteTempTSOSpeedLimitById: (id: string) => void
deleteCompareTSOSpeedLimitById: (id: string) => void
callApiForUpdate: () => void
callApiForCompareUpdate: () => void
}
const generateId = (): string => {
return uuidv4()
}
const setNestedProperty = (obj: any, path: NestedField, value: any) => {
const pathArray = Array.isArray(path) ? path : path.split('.')
const lastKey = pathArray.pop() as string
const nestedObj = pathArray.reduce((o, key) => (o[key] = o[key] || {}), obj)
nestedObj[lastKey] = value
}
export const useSpeedLimitStore = createSelectors(
create<TSpeedLimitState>()((set, get) => ({
speedLimits: null,
tempSpeedLimits: null,
updateSpeedLimits: null,
zoneSpeedLimits: null,
compareData: null,
updateCompareList: null,
documentS3Uri: null,
getTSODiffReportError: null,
cleanGetTSODiffReportError: () => set({ getTSODiffReportError: null }),
setGetTSODiffReportError: error => set({ getTSODiffReportError: error }),
fetchData: async ({
routeId,
railroadId,
startDestinationId,
endDestinationId
}) => {
const dispatch = store.dispatch
const res: any = await dispatch(
fetchSpeedLimitsDataByRouteId({
routeId: routeId,
railroadId: railroadId,
startDestinationId: startDestinationId,
endDestinationId: endDestinationId
})
)
},
initializeTempData: () =>
set(state =>
produce(state, draft => {
draft.tempSpeedLimits = [...(state?.speedLimits || [])]
})
),
initializeNewSpeedLimit: payload => {
set(
produce((state: TSpeedLimitState) => {
const newSpeedLimit: speedLimitItemType = {
newId: generateId(),
status: StatusTypes.New,
direction: Direction.ASC,
route_id: payload.route_id,
subdivision: payload.subdivision,
subdivision_data: payload.subdivision_data,
speed_limit_mph: undefined,
start_mile: undefined,
end_mile: undefined,
type: SpeedLimitType.TSO,
start_limit: payload.start_limit,
end_limit: payload.end_limit
}
const existNew = state?.tempSpeedLimits?.find(
item => item.status === StatusTypes.New
)
!existNew && state?.tempSpeedLimits?.unshift(newSpeedLimit)
})
)
},
updateTempSpeedLimits: (id, field, value) => {
set(
produce(state => {
const row = state?.tempSpeedLimits?.find(
(row: speedLimitItemType) =>
row.temporary_speed_limit_id === id || row?.newId === id
)
if (row) {
row[field] = value
}
})
)
},
updateCompareData: (id, fieldPath, value) => {
set(
produce((state: TSpeedLimitState) => {
const row = state?.compareData?.find(
(row: TSODiffReportType) => row.temporary_speed_limit_id === id
)
if (row) {
setNestedProperty(row, fieldPath, value)
}
})
)
},
addNewTSOSpeedLimit: async (payload, type) => {
const dispatch = store.dispatch
// if (
// !payload?.subdivision ||
// !payload?.routeId ||
// !payload?.startMilepost ||
// !payload?.endMilepost ||
// !payload?.
// ) {
// console.error('Missing necessary payload fields:', payload)
// return
// }
const res: any = await dispatch(
mutationAddNewTSOSpeedLimit({
subdivision: payload?.subdivision,
speedLimitType: payload?.speedLimitType,
speedLimitMph: payload?.limit,
routeId: payload?.routeId,
startMilepost: payload?.startMilepost,
endMilepost: payload?.endMilepost,
direction: payload?.direction,
parsedFromS3Uri: payload?.parsedFromS3Uri
})
)
set(
produce((state: TSpeedLimitState) => {
if (type === 'update') {
const speedLimit = state.updateSpeedLimits?.find(
item => item?.newId === payload?.id
)
console.log('🚀 ~ produce ~ speedLimit:', speedLimit)
if (speedLimit) {
if (!res?.error) {
speedLimit.statusUpdate = StatusUpdate.Success
} else {
speedLimit.statusUpdate = StatusUpdate.Failure
console.error('Error during mutation:', res?.error)
}
} else {
console.warn(
'SpeedLimit item not found for update:',
payload?.newId
)
}
} else if (type === 'compare') {
const speedLimit = state.updateCompareList?.find(
item => item?.temporary_speed_limit_id === payload?.id
)
console.log('🚀 ~ produce ~ speedLimit:', speedLimit)
if (speedLimit) {
if (!res?.error) {
speedLimit.statusUpdate = StatusUpdate.Success
} else {
speedLimit.statusUpdate = StatusUpdate.Failure
console.error('Error during mutation:', res?.error)
}
} else {
console.warn(
'SpeedLimit item not found for update:',
payload?.newId
)
}
}
})
)
},
editTSOSpeedLimit: async (payload, type) => {
const dispatch = store.dispatch
const res: any = await dispatch(
mutationEditTSOSpeedLimitById({
temporarySpeedLimitId: payload.temporarySpeedLimitId,
subdivision: payload?.subdivision,
speedLimitType: payload?.speedLimitType,
speedLimitMph: payload?.limit,
routeId: payload?.routeId,
startMilepost: payload?.startMilepost,
endMilepost: payload?.endMilepost,
direction: payload?.direction
})
)
console.log('🚀 ~ editTSOSpeedLimit: ~ res:', res)
set(
produce((state: TSpeedLimitState) => {
if (type === 'update') {
const speedLimit = state.updateSpeedLimits?.find(
item =>
item?.temporary_speed_limit_id ===
payload?.temporarySpeedLimitId
)
console.log('🚀 ~ produce ~ speedLimit:', speedLimit)
if (speedLimit) {
console.log('🚀 ~ produce ~ speedLimit:', speedLimit)
if (!res?.error) {
speedLimit.statusUpdate = StatusUpdate.Success
} else {
speedLimit.statusUpdate = StatusUpdate.Failure
console.error('Error during mutation:', res?.error)
}
} else {
console.warn(
'SpeedLimit item not found for update:',
payload?.temporarySpeedLimitId
)
}
} else if (type === 'compare') {
const speedLimit = state.updateCompareList?.find(
item =>
item?.temporary_speed_limit_id ===
payload?.temporarySpeedLimitId
)
if (speedLimit) {
if (!res?.error) {
speedLimit.statusUpdate = StatusUpdate.Success
} else {
speedLimit.statusUpdate = StatusUpdate.Failure
console.error('Error during mutation:', res?.error)
}
} else {
console.warn(
'SpeedLimit item not found for update:',
payload?.temporarySpeedLimitId
)
}
}
})
)
},
deleteTSOSpeedLimit: async (payload, type) => {
console.log('🚀 ~ payload:', payload)
const dispatch = store.dispatch
const res: any = await dispatch(
mutationDeleteTSOSpeedLimitById({
temporarySpeedLimitId: payload?.temporary_speed_limit_id
})
)
set(
produce((state: TSpeedLimitState) => {
if (type === 'update') {
const speedLimit = state.updateSpeedLimits?.find(
item =>
item?.temporary_speed_limit_id ===
payload?.temporary_speed_limit_id
)
console.log('🚀 ~ produce ~ speedLimit:', speedLimit)
if (speedLimit) {
if (!res?.error) {
speedLimit.statusUpdate = StatusUpdate.Success
} else {
speedLimit.statusUpdate = StatusUpdate.Failure
console.error('Error during mutation:', res?.error)
}
} else {
console.warn(
'SpeedLimit item not found for update:',
payload?.temporary_speed_limit_id
)
}
} else if (type === 'compare') {
const speedLimit = state.updateCompareList?.find(
item =>
item?.temporary_speed_limit_id ===
payload?.temporary_speed_limit_id
)
console.log('🚀 ~ produce ~ speedLimit:', speedLimit)
if (speedLimit) {
if (!res?.error) {
speedLimit.statusUpdate = StatusUpdate.Success
} else {
speedLimit.statusUpdate = StatusUpdate.Failure
console.error('Error during mutation:', res?.error)
}
} else {
console.warn(
'SpeedLimit item not found for update:',
payload?.temporary_speed_limit_id
)
}
}
})
)
},
// sortSpeedLimit: () =>
// set(
// produce((state: TSpeedLimitState) => {
// state.speedLimits?.sort(
// (a, b) => a?.start_distance_miles - b?.start_distance_miles
// )
// })
// ),
removeFirstSpeedLimit: () =>
set(
produce((state: TSpeedLimitState) => {
state.speedLimits?.shift()
})
),
changeStatusSpeedLimit: async payload => {
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.tempSpeedLimits?.find(
item =>
item?.temporary_speed_limit_id === payload?.id ||
item?.newId === payload?.id
)
if (speedLimit) {
speedLimit.status = payload.status
}
})
)
},
changeIsEditCompareSpeedLimit: async payload => {
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.compareData?.find(
item => item?.temporary_speed_limit_id === payload?.id
)
if (speedLimit) {
speedLimit.type = payload.isEdit
}
})
)
},
changeStatusCompareSpeedLimit: async payload => {
set(
produce((state: TSpeedLimitState) => {
const compareSpeedLimit = state.compareData?.find(
item => item?.temporary_speed_limit_id === payload?.id
)
if (compareSpeedLimit) {
compareSpeedLimit.status = payload.status
}
})
)
},
removeProperty: prop => {
set(
produce((state: TSpeedLimitState) => {
const propName: keyof speedLimitItemType = prop
if (state.speedLimits && typeof state.speedLimits === 'object') {
state.speedLimits.forEach(obj => {
if (obj.hasOwnProperty(prop)) {
delete obj[propName]
}
})
}
})
)
},
removePropertyById: (prop, id) => {
set(
produce((state: TSpeedLimitState) => {
const propName: keyof speedLimitItemType = prop
if (
state?.tempSpeedLimits &&
typeof state?.tempSpeedLimits === 'object'
) {
state?.tempSpeedLimits.forEach(obj => {
if (obj.temporary_speed_limit_id === id) {
if (obj.hasOwnProperty(prop)) {
delete obj[propName]
}
}
})
}
})
)
},
checkValidLimit: (id, type) => {
set(
produce((state: TSpeedLimitState) => {
const { zoneSpeedLimits } = get()
const speedLimit = state?.tempSpeedLimits?.find(
item => item?.temporary_speed_limit_id === id || item?.newId === id
)
if (speedLimit) {
const {
speed_limit_mph,
new_speed_limit_mph,
start_mile,
new_start_mile,
end_mile,
new_end_mile,
subdivision,
new_subdivision
} = speedLimit
switch (type) {
case StatusTypes.New:
if (start_mile && end_mile && speed_limit_mph) {
const TSOLimit = findMaxTSOLimit(
zoneSpeedLimits || [],
{
start: Number(start_mile),
end: Number(end_mile)
},
subdivision || ''
)
console.log(TSOLimit)
speedLimit.speed_limit_message =
speed_limit_mph > TSOLimit
? `${getTranslation(
'SpeedLimit.exceedZoneLimitError'
)} ${TSOLimit} mph`
: ''
} else {
speedLimit.speed_limit_message = ''
}
break
case StatusTypes.Edit:
if (new_start_mile && new_end_mile && new_speed_limit_mph) {
const TSOLimit = findMaxTSOLimit(
zoneSpeedLimits || [],
{
start: Number(new_start_mile),
end: Number(new_end_mile)
},
new_subdivision || ''
)
console.log(TSOLimit)
speedLimit.speed_limit_message =
parseFloat(new_speed_limit_mph) > TSOLimit
? `${getTranslation(
'SpeedLimit.exceedZoneLimitError'
)} ${TSOLimit} mph`
: ''
} else {
speedLimit.speed_limit_message = ''
}
}
}
})
)
},
checkValidCompareLimit: id => {
set(
produce((state: TSpeedLimitState) => {
const { zoneSpeedLimits } = get()
const speedLimit = state?.compareData?.find(
item => item?.temporary_speed_limit_id === id
)
if (speedLimit) {
const {
temp_start_milepost,
temp_end_milepost,
temp_subdivision,
temp_speed_limit_mph
} = speedLimit
if (
temp_start_milepost &&
temp_end_milepost &&
temp_speed_limit_mph
) {
const TSOLimit = findMaxTSOLimit(
zoneSpeedLimits || [],
{
start: Number(temp_start_milepost),
end: Number(temp_end_milepost)
},
temp_subdivision || ''
)
console.log(TSOLimit)
speedLimit.speed_limit_message =
temp_speed_limit_mph > TSOLimit
? `${getTranslation(
'SpeedLimit.exceedZoneLimitError'
)} ${TSOLimit} mph`
: ''
} else {
speedLimit.speed_limit_message = ''
}
}
})
)
},
checkValidMp: (id, name, value) => {
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.tempSpeedLimits?.find(
item => item?.temporary_speed_limit_id === id || item?.newId === id
)
if (speedLimit) {
const regex = /^\d{1,3}(\.\d{0,2})?$/
let newValue = value
if (value.length > 3 && value.indexOf('.') === -1) {
newValue = value.slice(0, 3)
}
if (!regex.test(newValue)) {
let roundedValue = parseFloat(newValue).toFixed(2)
if (!isNaN(parseFloat(roundedValue))) {
newValue = roundedValue.toString()
} else {
newValue = ''
}
}
speedLimit[name] = newValue
}
})
)
},
checkCompareValidMp: (id, name, value) => {
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.compareData?.find(
item => item?.temporary_speed_limit_id === id
)
if (speedLimit) {
const regex = /^\d{1,3}(\.\d{0,2})?$/
let newValue = value
if (value.length > 3 && value.indexOf('.') === -1) {
newValue = value.slice(0, 3)
}
if (!regex.test(newValue)) {
let roundedValue = parseFloat(newValue).toFixed(2)
if (!isNaN(parseFloat(roundedValue))) {
newValue = roundedValue.toString()
} else {
newValue = ''
}
}
speedLimit[name] = newValue
}
})
)
},
checkRangeMps: (id, startLimit, endLimit) => {
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.tempSpeedLimits?.find(
item => item?.temporary_speed_limit_id === id || item?.newId === id
)
if (speedLimit) {
const { start_mile, end_mile, new_start_mile, new_end_mile } =
speedLimit
if (new_start_mile || new_end_mile) {
if (new_start_mile && new_end_mile) {
const isOutRange = checkInvalidMileposts(
{
startMile: Number(new_start_mile),
endMile: Number(new_end_mile)
},
startLimit?.toString() || '',
endLimit?.toString() || ''
)
if (isOutRange) {
speedLimit.milepost_range_message = `${getTranslation(
'SpeedLimit.validMilepostsMessage'
)} ${startLimit} ${getTranslation(
'SpeedLimit.to'
)} ${endLimit}`
} else {
speedLimit.milepost_range_message = ''
}
}
} else if (start_mile && end_mile) {
const isOutRange = checkInvalidMileposts(
{
startMile: Number(start_mile),
endMile: Number(end_mile)
},
startLimit?.toString() || '',
endLimit?.toString() || ''
)
if (isOutRange) {
speedLimit.milepost_range_message = `${getTranslation(
'SpeedLimit.validMilepostsMessage'
)} ${startLimit} ${getTranslation('SpeedLimit.to')} ${endLimit}`
} else {
speedLimit.milepost_range_message = ''
}
}
}
})
)
},
checkCompareRangeMps: (id, startLimit, endLimit) => {
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.compareData?.find(
item => item?.temporary_speed_limit_id === id
)
if (speedLimit) {
const { temp_start_milepost, temp_end_milepost } = speedLimit
if (temp_start_milepost && temp_end_milepost) {
const isOutRange = checkInvalidMileposts(
{
startMile: Number(temp_start_milepost),
endMile: Number(temp_end_milepost)
},
startLimit?.toString() || '',
endLimit?.toString() || ''
)
if (isOutRange) {
speedLimit.milepost_range_message = `${getTranslation(
'SpeedLimit.validMilepostsMessage'
)} ${startLimit} ${getTranslation('SpeedLimit.to')} ${endLimit}`
} else {
speedLimit.milepost_range_message = ''
}
}
}
})
)
},
findOverlapMileposts: (id, statusTypes, speedLimitType) => {
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.tempSpeedLimits?.find(
item => item?.temporary_speed_limit_id === id || item?.newId === id
)
if (speedLimit) {
const {
start_mile,
new_start_mile,
end_mile,
new_end_mile,
subdivision,
new_subdivision
} = speedLimit
switch (statusTypes) {
case StatusTypes.New:
if (start_mile && end_mile) {
const overlapMpList = findOverlappingMileposts(
{
startMile: parseFloat(start_mile!),
endMile: parseFloat(end_mile!)
},
state.tempSpeedLimits!,
subdivision!,
speedLimitType,
id
)
speedLimit.overlap_milepost_list =
overlapMpList?.length !== 0 ? overlapMpList : null
}
break
case StatusTypes.Edit:
if (new_start_mile && new_end_mile) {
const overlapMpList = findOverlappingMileposts(
{
startMile: parseFloat(new_start_mile!),
endMile: parseFloat(new_end_mile!)
},
state.tempSpeedLimits!,
new_subdivision!,
speedLimitType,
id
)
speedLimit.overlap_milepost_list =
overlapMpList?.length !== 0 ? overlapMpList : null
}
}
}
})
)
},
findOverlapCompareMileposts: (id, speedLimitType) => {
const compareData = get().compareData
set(
produce((state: TSpeedLimitState) => {
const speedLimit = state.compareData?.find(
item => item?.temporary_speed_limit_id === id
)
if (speedLimit) {
const { temp_end_milepost, temp_start_milepost, temp_subdivision } =
speedLimit
if (temp_start_milepost && temp_end_milepost) {
const overlapMpList = findOverlappingMilepostsForCompare(
{
startMile: parseFloat(temp_start_milepost!),
endMile: parseFloat(temp_end_milepost!)
},
compareData!,
temp_subdivision!,
// speedLimitType,
id
)
speedLimit.overlap_milepost_list =
overlapMpList?.length !== 0 ? overlapMpList : null
}
}
})
)
},
createUpdateList: () => {
set(
produce((state: TSpeedLimitState) => {
// const indexOfEdit = state.tempSpeedLimits?.findIndex(item => {
// return item?.status === StatusTypes.Edit
// })
// console.log('🚀 ~ indexOfEdit ~ indexOfEdit:', indexOfEdit)
// if (indexOfEdit === -1) {
state.updateSpeedLimits =
state?.tempSpeedLimits?.filter(item => {
return (
item?.status &&
item?.status !== StatusTypes.New &&
item?.status !== StatusTypes.Edit
)
}) || []
// }
})
)
},
createCompareList: () => {
set(
produce((state: TSpeedLimitState) => {
state.updateCompareList =
state?.compareData?.filter(item => {
return item?.status === TSODiffReportStatus.Approve
}) || []
// }
})
)
},
deleteTempTSOSpeedLimitById: id => {
set(
produce((state: TSpeedLimitState) => {
const index = state?.tempSpeedLimits?.findIndex(
(speedLimit: speedLimitItemType) => speedLimit?.newId === id
)
if (index !== -1 && index) {
state?.tempSpeedLimits?.splice(index, 1)
}
})
)
},
deleteCompareTSOSpeedLimitById: id => {
console.log('🚀 ~ id:', id)
set(
produce((state: TSpeedLimitState) => {
const index = state?.compareData?.findIndex(
(speedLimit: TSODiffReportType) =>
speedLimit?.temporary_speed_limit_id === id
)
if ((index !== -1 && index) || index === 0) {
state?.compareData?.splice(index, 1)
}
})
)
},
callApiForUpdate: async () => {
set(
produce((state: TSpeedLimitState) => {
state.updateSpeedLimits =
state.updateSpeedLimits?.map((item: speedLimitItemType) => ({
...item,
statusUpdate: StatusUpdate.Loading
})) || []
})
)
const addSpeedLimit = get().addNewTSOSpeedLimit
const editSpeedLimit = get().editTSOSpeedLimit
const deleteSpeedLimit = get().deleteTSOSpeedLimit
const processSpeedLimitItem = async (item: speedLimitItemType) => {
if (!item) return
switch (item.status) {
case StatusTypes.NewAdded:
await addSpeedLimit(
{
id: item?.newId,
subdivision: item?.subdivision || '',
speedLimitType: item?.type || '',
limit: item?.speed_limit_mph || 0,
routeId: item?.route_id || '',
startMilepost: parseFloat(item?.start_mile!) || 0,
endMilepost: parseFloat(item?.end_mile!) || 0,
direction: Direction.ASC,
parsedFromS3Uri: ''
},
'update'
)
break
case StatusTypes.Edited:
const payload = {
temporarySpeedLimitId: item.temporary_speed_limit_id,
subdivision: item?.new_subdivision || item?.subdivision || '',
speedLimitType: item?.type || '',
speedLimitMph: item?.new_speed_limit_mph
? parseFloat(item?.new_speed_limit_mph)
: item?.speed_limit_mph || 0,
routeId: item?.route_id || '',
startMilepost: item?.new_start_mile || item?.start_mile || '0',
endMilepost: item?.new_end_mile || item?.end_mile || '0',
direction: item?.direction || Direction.ASC
}
await editSpeedLimit(
{
temporarySpeedLimitId: payload?.temporarySpeedLimitId!,
subdivision: payload?.subdivision!,
speedLimitType: payload?.speedLimitType!,
limit: payload?.speedLimitMph!,
routeId: payload?.routeId!,
startMilepost: parseFloat(payload?.startMilepost!) || 0,
endMilepost: parseFloat(payload?.endMilepost!) || 0,
direction: payload.direction!
},
'update'
)
break
case StatusTypes.Delete:
await deleteSpeedLimit(item, 'update')
break
default:
console.warn('Unknown status type:', item.status)
}
}
const updateData = get().updateSpeedLimits
const deleteItems =
updateData?.filter(item => item.status === StatusTypes.Delete) || []
const addItems =
updateData?.filter(item => item.status === StatusTypes.NewAdded) || []
const editItems =
updateData?.filter(item => item.status === StatusTypes.Edited) || []
for (const item of deleteItems) {
await processSpeedLimitItem(item)
}
for (const item of editItems) {
await processSpeedLimitItem(item)
}
for (const item of addItems) {
await processSpeedLimitItem(item)
}
},
callApiForCompareUpdate: async () => {
set(
produce((state: TSpeedLimitState) => {
state.updateCompareList =
state.updateCompareList?.map((item: TSODiffReportType) => ({
...item,
statusUpdate: StatusUpdate.Loading
})) || []
})
)
const addSpeedLimit = get().addNewTSOSpeedLimit
const editSpeedLimit = get().editTSOSpeedLimit
const deleteSpeedLimit = get().deleteTSOSpeedLimit
const parsedFromS3Uri = get().documentS3Uri
const processSpeedLimitItem = async (item: TSODiffReportType) => {
if (!item) return
switch (item.diff_tag?.type) {
case DiffTagType.ADDED:
await addSpeedLimit(
{
id: item?.temporary_speed_limit_id,
subdivision: item?.subdivision,
speedLimitType: 'TSO',
limit: item?.speed_limit_mph,
routeId: item?.routeId,
startMilepost: item?.start_milepost,
endMilepost: item?.end_milepost,
direction: Direction.ASC,
parsedFromS3Uri: parsedFromS3Uri
},
'compare'
)
break
case DiffTagType.MODIFIED:
const payload = {
temporarySpeedLimitId: item.temporary_speed_limit_id,
subdivision: item?.subdivision,
speedLimitType: 'TSO',
speedLimitMph: item?.speed_limit_mph,
routeId: item?.routeId,
startMilepost: item?.start_milepost,
endMilepost: item?.end_milepost,
direction: Direction.ASC
}
await editSpeedLimit(
{
temporarySpeedLimitId: payload?.temporarySpeedLimitId!,
subdivision: payload?.subdivision!,
speedLimitType: payload?.speedLimitType!,
limit: payload?.speedLimitMph!,
routeId: payload?.routeId!,
startMilepost: payload?.startMilepost!,
endMilepost: payload?.endMilepost!,
direction: payload.direction!
},
'compare'
)
break
case DiffTagType.DELETED:
await deleteSpeedLimit(item, 'compare')
break
case DiffTagType.UNCHANGED:
break
default:
console.warn('Unknown status type:', item.status)
}
}
const updateCompareList = get().updateCompareList
const deleteItems =
updateCompareList?.filter(
item => item.diff_tag?.type === DiffTagType.DELETED
) || []
const addItems =
updateCompareList?.filter(
item => item.diff_tag?.type === DiffTagType.ADDED
) || []
const editItems =
updateCompareList?.filter(
item => item.diff_tag?.type === DiffTagType.MODIFIED
) || []
for (const item of deleteItems) {
await processSpeedLimitItem(item)
}
for (const item of editItems) {
await processSpeedLimitItem(item)
}
for (const item of addItems) {
await processSpeedLimitItem(item)
}
}
}))
)
Editor is loading...
Leave a Comment