Use section timeline context for roving map QSO origins

rwjblue · rwjblue · commit c855eb0a056f · 2026-03-01T14:10:44.000-05:00
Map lines and distance calculations were using the operation's final
location, which made roving logs look like every contact came from the
last stop.

Add shared section-context timeline helpers in qsonTools and use them
to derive per-QSO our.location from start/break snapshots before map
rendering. Update map geometry and distance calculations to use each
QSO's derived origin. Also switch ADIF traversal to the same helper so
segment behavior stays aligned across features.
diff --git a/src/screens/OperationBadgeScreen/OperationBadgeScreen.jsx b/src/screens/OperationBadgeScreen/OperationBadgeScreen.jsx
@@ -17,6 +17,7 @@ import { loadQSOs, selectQSOs } from '../../store/qsos'
 import { selectSettings } from '../../store/settings'
 import { useThemedStyles } from '../../styles/tools/useThemedStyles'
 import { fmtDateTimeNiceZulu, fmtTimeBetween } from '../../tools/timeFormats'
+import { mapQSOsWithSectionContext } from '../../tools/qsonTools'
 import Color from 'color'
 import MapWithQSOs from '../OperationScreens/OpMapTab/components/MapWithQSOs'
 import { slashZeros } from '../../tools/stringTools'
@@ -106,7 +107,7 @@ export default function OperationBadgeScreen ({ navigation, route }) {
   }, [route.params.operation.uuid, dispatch])
 
   const qsosSelector = useCallback((state) => selectQSOs(state, route.params.operation.uuid), [route.params.operation.uuid])
-  const qsos = useSelector(qsosSelector)
+  const allQsos = useSelector(qsosSelector)
 
   const qth = useMemo(() => {
     try {
@@ -118,6 +119,30 @@ export default function OperationBadgeScreen ({ navigation, route }) {
     }
   }, [operation?.grid])
 
+  const qsos = useMemo(() => {
+    const locationForGrid = (grid) => {
+      if (!grid) return qth
+      try {
+        const [latitude, longitude] = gridToLocation(grid)
+        return { latitude, longitude }
+      } catch (e) {
+        return qth
+      }
+    }
+
+    return mapQSOsWithSectionContext({
+      qsos: allQsos,
+      operation,
+      map: ({ qso, sectionGrid }) => ({
+        ...qso,
+        our: {
+          ...qso.our,
+          location: locationForGrid(sectionGrid)
+        }
+      })
+    })
+  }, [allQsos, operation, qth])
+
   const opDate = useMemo(() => {
     return `${fmtDateTimeNiceZulu(operation.startAtMillisMin)}`
   }, [operation])
diff --git a/src/screens/OperationScreens/OpMapTab/OpMapTab.jsx b/src/screens/OperationScreens/OpMapTab/OpMapTab.jsx
@@ -19,6 +19,7 @@ import { useThemedStyles } from '../../../styles/tools/useThemedStyles'
 import { selectOperation } from '../../../store/operations'
 import { selectQSOs } from '../../../store/qsos'
 import { selectSettings } from '../../../store/settings'
+import { mapQSOsWithSectionContext } from '../../../tools/qsonTools'
 import { useSelectorConditionally, useUIStateConditionally } from '../../components/useConditionally'
 
 import MapWithQSOs from './components/MapWithQSOs'
@@ -56,7 +57,29 @@ export default function OpMapTab ({ navigation, route }) {
   const allQsosSelector = useCallback((state) => selectQSOs(state, route.params.operation.uuid), [route.params.operation.uuid])
   const allQsos = useSelector(allQsosSelector)
 
-  const qsos = useMemo(() => allQsos.filter(qso => !qso.deleted && !qso.event), [allQsos])
+  const qsos = useMemo(() => {
+    const locationForGrid = (grid) => {
+      if (!grid) return qth
+      try {
+        const [latitude, longitude] = gridToLocation(grid)
+        return { latitude, longitude }
+      } catch (e) {
+        return qth
+      }
+    }
+
+    return mapQSOsWithSectionContext({
+      qsos: allQsos,
+      operation,
+      map: ({ qso, sectionGrid }) => ({
+        ...qso,
+        our: {
+          ...qso.our,
+          location: locationForGrid(sectionGrid)
+        }
+      })
+    })
+  }, [allQsos, operation, qth])
 
   const [dismissedWarnings, setDismissedWarnings] = useState({})
 
diff --git a/src/screens/OperationScreens/OpMapTab/components/MapWithQSOs.jsx b/src/screens/OperationScreens/OpMapTab/components/MapWithQSOs.jsx
@@ -17,10 +17,11 @@ export default function MapWithQSOs ({ styles, operation, qth, qsos, settings, s
     return activeQSOs
       .map(qso => {
         const location = locationForQSONInfo(qso?.their)
+        const ourLocation = qso?.our?.location ?? qth
         const strength = strengthForQSO(qso)
-        const distance = location && qth ? distanceOnEarth(location, qth, { units: settings.distanceUnits }) : null
+        const distance = location && ourLocation ? distanceOnEarth(location, ourLocation, { units: settings.distanceUnits }) : null
         const distanceStr = distance ? fmtDistance(distance, { units: settings.distanceUnits }) : ''
-        return { qso, location, strength, distance, distanceStr }
+        return { qso, location, ourLocation, strength, distance, distanceStr }
       })
       .filter(({ location }) => location)
       .sort((a, b) => b.strength - a.strength) // Weakest first
diff --git a/src/screens/OperationScreens/OpMapTab/components/MapboxMapWithQSOs.jsx b/src/screens/OperationScreens/OpMapTab/components/MapboxMapWithQSOs.jsx
@@ -244,20 +244,21 @@ function _geoJSONMarkerForQSO ({ mappableQSO, qth, operation, styles }) {
 }
 
 function _getJSONLinesForQSOs ({ mappableQSOs, qth, operation, styles }) {
-  if (qth?.latitude !== undefined && qth?.longitude !== undefined) {
-    const features = mappableQSOs.map(mappableQSO => _geoJSONLineForQSO({ mappableQSO, qth, operation, styles })).flat().filter(x => x)
+  const features = mappableQSOs.map(mappableQSO => _geoJSONLineForQSO({ mappableQSO, qth, operation, styles })).flat().filter(x => x)
 
-    return {
-      type: 'FeatureCollection',
-      features
-    }
+  return {
+    type: 'FeatureCollection',
+    features
   }
 }
 
 function _geoJSONLineForQSO ({ mappableQSO, qth, operation, styles }) {
   if (mappableQSO?.location?.latitude !== undefined && mappableQSO?.location?.longitude !== undefined) {
+    const ourLocation = mappableQSO?.ourLocation ?? qth
+    if (ourLocation?.latitude === undefined || ourLocation?.longitude === undefined) return null
+
     const start = _coordsFromLatLon(mappableQSO.location)
-    const end = _coordsFromLatLon(qth)
+    const end = _coordsFromLatLon(ourLocation)
 
     if (start[0] === end[0] && start[1] === end[1]) {
       return null
diff --git a/src/tools/qsonToADIF.js b/src/tools/qsonToADIF.js
@@ -11,6 +11,7 @@ import { basePartialTemplates, compileTemplateForOperation, extraDataForTemplate
 import { selectExportSettings } from '../store/settings'
 import { escapeToUnicodeEntities, sanitizeToISO8859 } from './stringTools'
 import { fmtADIFDate, fmtADIFTime, fmtISODateTime } from './timeFormats'
+import { forEachQSOWithSectionContext } from './qsonTools'
 
 import { adifModeAndSubmodeForMode, frequencyForBand, modeForFrequency } from '@ham2k/lib-operation-data'
 
@@ -52,8 +53,6 @@ export function qsonToADIF({ operation, settings, qsos, handler, format, title,
     common.operatorCall = operation.local?.operatorCall || operation.operatorCall
   }
 
-  const eventQSOs = qsos.filter(qso => qso.event && !qso.deleted)
-
   let str = ''
   str += `ADIF for ${title || ([common.stationCall, operation?.title, operation.subTitle].filter(x => x).join(' ')) || 'Operation'} \n`
   str += adifField('ADIF_VER', '3.1.5', { newLine: true })
@@ -69,7 +68,7 @@ export function qsonToADIF({ operation, settings, qsos, handler, format, title,
 
   str += '<EOH>\n'
 
-  qsos.forEach(qso => {
+  forEachQSOWithSectionContext({ qsos, operation, withEvents: true, callback: ({ qso, sectionRefs, sectionGrid }) => {
     if (qso.deleted) return
     if (qso.event) {
       if (privateData) {
@@ -91,14 +90,15 @@ export function qsonToADIF({ operation, settings, qsos, handler, format, title,
       }
 
       if (qso.event.event === 'break' || qso.event.event === 'start') {
+        const segmentOperation = { ...qso.event.operation, refs: sectionRefs, grid: sectionGrid }
         if (combineSegmentRefs) {
-          // Update all operation attributes, including regs
-          operation = { ...operation, ...qso.event.operation }
-          common = { ...common, ...qso.event.operation }
+          // Update all operation attributes, including refs
+          operation = { ...operation, ...segmentOperation }
+          common = { ...common, ...segmentOperation }
         } else {
           // Combine other attributes, but keep refs as initialized
-          operation = { ...operation, ...qso.event.operation, refs: operation.refs }
-          common = { ...common, ...qso.event.operation, refs: common.refs }
+          operation = { ...operation, ...segmentOperation, refs: operation.refs }
+          common = { ...common, ...segmentOperation, refs: common.refs }
         }
         templates.context = templateContextForOneExport({ settings, operation, handler })
       }
@@ -155,7 +155,7 @@ export function qsonToADIF({ operation, settings, qsos, handler, format, title,
 
       str += adifRow(fields)
     })
-  })
+  } })
 
   return str
 }
diff --git a/src/tools/qsonToADIF.spec.js b/src/tools/qsonToADIF.spec.js
@@ -0,0 +1,161 @@
+/*
+ * Copyright ©️ 2026 Robert Jackson <me@rwjblue.com>
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+jest.mock('../extensions/registry', () => ({
+  findBestHook: () => null
+}))
+
+jest.mock('../store/settings', () => ({
+  selectExportSettings: ({ settings }, key, defaults) => settings?.exports?.[key] ?? defaults ?? {}
+}))
+
+jest.mock('../store/operations', () => ({
+  basePartialTemplates: () => ({}),
+  compileTemplateForOperation: () => () => '',
+  extraDataForTemplates: () => ({}),
+  templateContextForOneExport: ({ operation }) => ({ operation })
+}))
+
+jest.mock('@ham2k/lib-operation-data', () => ({
+  adifModeAndSubmodeForMode: (mode) => [mode || 'SSB'],
+  frequencyForBand: () => 14250000,
+  modeForFrequency: () => 'SSB'
+}))
+
+import { qsonToADIF } from './qsonToADIF'
+
+const baseSettings = {
+  operatorCall: 'K1OP',
+  exports: {
+    default: {
+      privateData: true
+    }
+  }
+}
+
+function baseOperation () {
+  return {
+    stationCall: 'K1OP',
+    refs: [{ type: 'pota', ref: 'US-1111' }],
+    grid: 'FN31',
+    state: 'CT'
+  }
+}
+
+function baseQSO ({ uuid, call, startAtMillis }) {
+  return {
+    uuid,
+    startAtMillis,
+    band: '20m',
+    mode: 'SSB',
+    their: { call },
+    our: {}
+  }
+}
+
+function handlerWithContextFields () {
+  return {
+    key: 'test',
+    adifFieldsForOneQSO: ({ operation, common }) => [
+      { X_OP_REF: operation.refs?.[0]?.ref },
+      { X_COMMON_REF: common.refs?.[0]?.ref },
+      { X_COMMON_GRID: common.grid }
+    ]
+  }
+}
+
+describe('qsonToADIF segment context', () => {
+  it('keeps original refs when combineSegmentRefs is false', () => {
+    const adif = qsonToADIF({
+      operation: baseOperation(),
+      settings: baseSettings,
+      qsos: [
+        {
+          uuid: 'start',
+          startAtMillis: 1000,
+          event: {
+            event: 'start',
+            note: 'segment start',
+            operation: {
+              refs: [{ type: 'pota', ref: 'US-2222' }],
+              grid: 'FM18'
+            }
+          }
+        },
+        baseQSO({ uuid: 'q1', call: 'K1AAA', startAtMillis: 2000 })
+      ],
+      handler: handlerWithContextFields(),
+      format: 'adif',
+      combineSegmentRefs: false
+    })
+
+    expect(adif).toMatch(/<X_OP_REF:\d+>US-1111/)
+    expect(adif).toMatch(/<X_COMMON_REF:\d+>US-1111/)
+    expect(adif).toMatch(/<X_COMMON_GRID:\d+>FM18/)
+  })
+
+  it('switches refs when combineSegmentRefs is true', () => {
+    const adif = qsonToADIF({
+      operation: baseOperation(),
+      settings: baseSettings,
+      qsos: [
+        {
+          uuid: 'start',
+          startAtMillis: 1000,
+          event: {
+            event: 'start',
+            note: 'segment start',
+            operation: {
+              refs: [{ type: 'pota', ref: 'US-2222' }],
+              grid: 'FM18'
+            }
+          }
+        },
+        baseQSO({ uuid: 'q1', call: 'K1AAA', startAtMillis: 2000 })
+      ],
+      handler: handlerWithContextFields(),
+      format: 'adif',
+      combineSegmentRefs: true
+    })
+
+    expect(adif).toMatch(/<X_OP_REF:\d+>US-2222/)
+    expect(adif).toMatch(/<X_COMMON_REF:\d+>US-2222/)
+    expect(adif).toMatch(/<X_COMMON_GRID:\d+>FM18/)
+  })
+
+  it('ignores deleted start or break events when updating section context', () => {
+    const adif = qsonToADIF({
+      operation: baseOperation(),
+      settings: baseSettings,
+      qsos: [
+        {
+          uuid: 'deleted-break',
+          deleted: true,
+          startAtMillis: 1000,
+          event: {
+            event: 'break',
+            note: 'deleted segment break',
+            operation: {
+              refs: [{ type: 'pota', ref: 'US-3333' }],
+              grid: 'EM12'
+            }
+          }
+        },
+        baseQSO({ uuid: 'q1', call: 'K1AAA', startAtMillis: 2000 })
+      ],
+      handler: handlerWithContextFields(),
+      format: 'adif',
+      combineSegmentRefs: true
+    })
+
+    expect(adif).toMatch(/<X_OP_REF:\d+>US-1111/)
+    expect(adif).toMatch(/<X_COMMON_REF:\d+>US-1111/)
+    expect(adif).toMatch(/<X_COMMON_GRID:\d+>FN31/)
+    expect(adif).not.toContain('US-3333')
+    expect(adif).not.toContain('EM12')
+  })
+})
diff --git a/src/tools/qsonTools.js b/src/tools/qsonTools.js
diff --git a/src/tools/qsonTools.spec.js b/src/tools/qsonTools.spec.js
