feat(logbook): LoTW 日志本官方名统一、上传候选集、编辑已传记录新建、记录分钟/kHz 规范化

2026-10-04 03:37:21 +00:00 · 2026-09-28 23:46:47 +08:00
1 parent 1871c05002
commit 5acf71b2a6
@@ -1,6 +1,25 @@
+/*
+ * Look4Sat-BA7OPF. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2026 BA7OPF.
+ * Based on Look4Sat by Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.data.lotw

 import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.LoTWSatelliteAliases
 import com.rtbishop.look4sat.core.domain.logbook.displayMode
 import com.rtbishop.look4sat.core.domain.repository.LoTWProblem
 import com.rtbishop.look4sat.core.domain.repository.LoTWRegionField
@@ -58,18 +77,23 @@ internal class LoTWConfig(input: InputStream) {
        return value
    }

+    /** Every satellite name ARRL's config.tq6 knows, sorted: the only names LoTW accepts. */
+    fun satelliteNames(): List<String> = satellites.keys.sorted()
+
+    /**
+     * Resolve a tracker name to the ARRL name, or null when it is not an ARRL satellite.
+     * Exact official name first, then the alias table ("SAUDISAT 1C" -> "SO-50",
+     * "ISS (ZARYA)" -> "ARISS"), then an official name contained in the tracker name.
+     */
+    fun resolveSatellite(name: String): String? = LoTWSatelliteAliases.resolve(name, satellites.keys)
+
    fun satellite(name: String, date: String): String {
        val normalized = name.trim().uppercase(Locale.US)
-        // Look4Sat satellite names come from SatNOGS (e.g. "SO-50 (SaudiOSCAR 50)");
-        // the bundled config only knows the official LoTW name ("SO-50"). Exact match
-        // first, then accept any satellite whose official name is a substring of the
-        // Look4Sat name (covers SO-50, AO-91, IO-86, CAS-7B …). Failing that the
-        // contact is unavailable for upload.
-        val sat = satellites[normalized]
-            ?: satellites.entries.firstOrNull { (official, _) ->
-                official.length > 1 && normalized.contains(official)
-            }?.value
-            ?: fail(LoTWProblem.SATELLITE, normalized)
+        // Tracker names differ from ARRL's: SatNOGS stores "SAUDISAT 1C" for "SO-50" and
+        // "ISS (ZARYA)" for "ARISS". resolveSatellite() checks the exact name, the alias
+        // table and finally substring containment; anything else is not uploadable.
+        val official = resolveSatellite(name) ?: fail(LoTWProblem.SATELLITE, normalized)
+        val sat = satellites.getValue(official)
        val first = sat.getAttribute("startDate")
        val last = sat.getAttribute("endDate")
        if ((first.isNotBlank() && date < first) || (last.isNotBlank() && date > last)) fail(LoTWProblem.SATELLITE, normalized)
@@ -1,3 +1,21 @@
+/*
+ * Look4Sat-BA7OPF. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2026 BA7OPF.
+ * Based on Look4Sat by Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.data.lotw

 import com.rtbishop.look4sat.core.domain.repository.LoTWCertificate
@@ -1,3 +1,21 @@
+/*
+ * Look4Sat-BA7OPF. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2026 BA7OPF.
+ * Based on Look4Sat by Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.data.lotw

 import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
@@ -1,3 +1,21 @@
+/*
+ * Look4Sat-BA7OPF. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2026 BA7OPF.
+ * Based on Look4Sat by Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.data.lotw

 import android.content.Context
@@ -1,7 +1,26 @@
+/*
+ * Look4Sat-BA7OPF. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2026 BA7OPF.
+ * Based on Look4Sat by Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.data.lotw

 import android.content.Context
 import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.satelliteIdentity
 import com.rtbishop.look4sat.core.domain.logbook.QsoStatus
 import com.rtbishop.look4sat.core.domain.repository.ILoTWUploadRepository
 import com.rtbishop.look4sat.core.domain.repository.LoTWCertificate
@@ -154,6 +173,24 @@ class LoTWUploadRepository internal constructor(
        config().stationMeta(dxcc)
    }

+    /** The ARRL satellite catalogue is static for the lifetime of the bundled config.tq6. */
+    private val satelliteNames: List<String> by lazy { config().satelliteNames() }
+
+    override suspend fun satelliteCatalog(): List<String> = withContext(Dispatchers.IO) { satelliteNames }
+
+    /**
+     * What makes two records the same contact for batch de-duplication: the opposite station,
+     * the satellite (resolved to its ARRL identity, so the tracker spelling and the official
+     * name are one) and the minute the QSO started. Frequency and mode are deliberately not
+     * part of the key — the same contact logged twice with slightly different tuning (or with
+     * the frequency fields empty) must still be caught before LoTW rejects the duplicate.
+     */
+    private fun duplicateKey(record: QsoRecord): String = listOf(
+        record.theirCallsign.trim().uppercase(Locale.US),
+        satelliteIdentity(record.satelliteName),
+        (record.startUtcMillis / 60_000L).toString()
+    ).joinToString("|")
+
    override suspend fun audit(records: List<QsoRecord>): LoTWUploadAudit = withContext(Dispatchers.IO) {
        mutex.withLock {
            val signing = signingContext()
@@ -163,20 +200,34 @@ class LoTWUploadRepository internal constructor(
            var uploaded = 0
            var unknown = 0
            var unavailable = 0
+            var duplicates = 0
+            var incomplete = 0
+            val reasons = mutableMapOf<LoTWProblem, Int>()
+            val details = mutableMapOf<LoTWProblem, String>()
            records.sortedBy { it.startUtcMillis }.forEach { record ->
                coroutineContext.ensureActive()
                when {
-                    record.status != QsoStatus.COMPLETE -> unavailable++
+                    record.status != QsoStatus.COMPLETE -> {
+                        unavailable++
+                        incomplete++
+                    }
+
                    record.lotwReceived || record.lotwUploaded -> uploaded++
                    else -> {
                        val contact = try {
                            signing.signer.contact(record, signing.key, signing.location, now())
-                        } catch (_: LoTWOperationException) {
+                        } catch (e: LoTWOperationException) {
                            unavailable++
+                            reasons[e.reason] = (reasons[e.reason] ?: 0) + 1
+                            if (e.detail.isNotBlank()) details.putIfAbsent(e.reason, e.detail)
                            null
                        }
                        if (contact != null) when {
-                            !unique.add(contact.fingerprint) -> unavailable++
+                            !unique.add(duplicateKey(contact.record)) -> {
+                                unavailable++
+                                duplicates++
+                            }
+
                            ledger[contact.fingerprint] == "accepted" -> uploaded++
                            ledger[contact.fingerprint] == "unknown" -> unknown++
                            else -> pendingCount++
@@ -184,7 +235,10 @@ class LoTWUploadRepository internal constructor(
                    }
                }
            }
-            LoTWUploadAudit(records.size, pendingCount, uploaded, unknown, unavailable)
+            LoTWUploadAudit(
+                records.size, pendingCount, uploaded, unknown, unavailable,
+                reasons, details, duplicates, incomplete
+            )
        }
    }

@@ -197,21 +251,30 @@ class LoTWUploadRepository internal constructor(
            var skipped = 0
            var unknown = 0
            var unavailable = 0
+            var duplicates = 0
            val unique = hashSetOf<String>()
+            val reasons = mutableMapOf<LoTWProblem, Int>()
            val contacts = records.sortedBy { it.startUtcMillis }.mapNotNull { record ->
                coroutineContext.ensureActive()
                if (record.status != QsoStatus.COMPLETE || ((record.lotwReceived || record.lotwUploaded) && !resubmit)) { skipped++; return@mapNotNull null }
                val contact = try {
                    signing.signer.contact(record, signing.key, signing.location, now())
-                } catch (_: LoTWOperationException) {
+                } catch (e: LoTWOperationException) {
                    // One un-signable record must not abort the whole batch:
-                    // skip it, count it, and let the rest upload.
+                    // skip it, count the real reason, and let the rest upload.
                    unavailable++
+                    reasons[e.reason] = (reasons[e.reason] ?: 0) + 1
                    return@mapNotNull null
                }
                val previous = ledger[contact.fingerprint]
                when {
-                    (previous == "accepted" && !resubmit) || !unique.add(contact.fingerprint) -> { skipped++; null }
+                    (previous == "accepted" && !resubmit) -> { skipped++; null }
+                    !unique.add(duplicateKey(contact.record)) -> {
+                        skipped++
+                        duplicates++
+                        null
+                    }
+
                    previous == "unknown" && !resubmit -> { skipped++; unknown++; null }
                    else -> contact
                }
@@ -224,6 +287,8 @@ class LoTWUploadRepository internal constructor(
                contacts.map { "${utc(it.record.startUtcMillis, "MM-dd HH:mm")} ${it.record.theirCallsign} ${it.fields["MODE"]} ${it.fields["SAT_NAME"].orEmpty()}" },
                unknown,
                unavailable,
+                reasons.toMap(),
+                duplicates,
                contacts.map { it.record.id }
            )
            if (contacts.isNotEmpty()) pending = Pending(
@@ -322,9 +322,9 @@ class LoTWRepository : ILoTWRepository {
                line.startsWith("<MODE:") ->
                    mode = adifValue(line)
                line.startsWith("<BAND_RX:") ->
-                    bandUp = adifValue(line).uppercase()
-                line.startsWith("<BAND:") && !line.startsWith("<BAND_RX:") ->
                    bandDown = adifValue(line).uppercase()
+                line.startsWith("<BAND:") && !line.startsWith("<BAND_RX:") ->
+                    bandUp = adifValue(line).uppercase()
                line.startsWith("<DXCC:") ->
                    dxcc = adifValue(line).toIntOrNull()
                line.startsWith("<COUNTRY:") ->
@@ -16,9 +16,13 @@ import com.rtbishop.look4sat.core.domain.logbook.AdifImportResult
 import com.rtbishop.look4sat.core.domain.logbook.IQsoRepository
 import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
 import com.rtbishop.look4sat.core.domain.logbook.QsoStatus
+import com.rtbishop.look4sat.core.domain.logbook.displayMode
 import com.rtbishop.look4sat.core.domain.logbook.sameConfirmedContact
+import com.rtbishop.look4sat.core.domain.logbook.satelliteIdentity
+import com.rtbishop.look4sat.core.domain.logbook.splitConfirmationPairs
 import com.rtbishop.look4sat.core.domain.logbook.withConfirmation
 import com.rtbishop.look4sat.core.domain.logbook.confirmationLookupKey
+import com.rtbishop.look4sat.core.domain.logbook.officialSatelliteName
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
@@ -40,18 +44,33 @@ class QsoRepository(
    override suspend fun save(record: QsoRecord): Long = withContext(dispatcher) {
        importMutex.withLock {
            val previous = if (record.id != 0L) dao.find(record.id)?.toDomain() else null
-            val saved = if (previous?.lotwConfirmed == true && sameConfirmedContact(record, previous)) {
-                record.withConfirmation(previous)
-            } else if (previous?.lotwConfirmed == true) record.copy(
-                lotwConfirmed = false, lotwQslDate = "", vuccGrids = emptyList(),
-                dxcc = null, country = "", cqZone = null, region = ""
-            ) else record
-            val received = if (previous != null && (
-                stableQsoKey(record) != stableQsoKey(previous) || record.myGrid != previous.myGrid ||
-                    record.rxFrequencyHz != previous.rxFrequencyHz || record.band != previous.band ||
-                    record.rxBand != previous.rxBand || record.propagationMode != previous.propagationMode
-                )) false else saved.lotwReceived
-            dao.save(saved.copy(lotwReceived = received).toEntity())
+            // Editing a record that was already uploaded or confirmed must not rewrite it in
+            // place: that contact already exists on LoTW under the old values. The original row
+            // keeps its upload/confirmation state, and the edited content is saved as a NEW
+            // record (without any LoTW state, so it can be uploaded again).
+            if (previous != null && (previous.lotwUploaded || previous.lotwConfirmed) &&
+                !record.sameEditableContentAs(previous)
+            ) {
+                dao.save(record.copy(
+                    id = 0L,
+                    lotwUploaded = false, lotwConfirmed = false, lotwReceived = false,
+                    lotwQslDate = "", vuccGrids = emptyList(),
+                    dxcc = null, country = "", cqZone = null, region = ""
+                ).toEntity())
+            } else {
+                val saved = if (previous?.lotwConfirmed == true && sameConfirmedContact(record, previous)) {
+                    record.withConfirmation(previous)
+                } else if (previous?.lotwConfirmed == true) record.copy(
+                    lotwConfirmed = false, lotwQslDate = "", vuccGrids = emptyList(),
+                    dxcc = null, country = "", cqZone = null, region = ""
+                ) else record
+                val received = if (previous != null && (
+                    stableQsoKey(record) != stableQsoKey(previous) || record.myGrid != previous.myGrid ||
+                        record.rxFrequencyHz != previous.rxFrequencyHz || record.band != previous.band ||
+                        record.rxBand != previous.rxBand || record.propagationMode != previous.propagationMode
+                    )) false else saved.lotwReceived
+                dao.save(saved.copy(lotwReceived = received).toEntity())
+            }
        }
    }

@@ -86,14 +105,42 @@ class QsoRepository(
        importMutex.withLock { mergeRecords(records, fromLoTW = true) }
    }

+    override suspend fun consolidateConfirmations(): Int = withContext(dispatcher) {
+        importMutex.withLock {
+            val working = dao.getAll().map(QsoEntity::toDomain).toMutableList()
+            val consolidation = consolidateSplitRows(working)
+            val renames = rewriteOfficialNames(working)
+            if (consolidation.merged.isEmpty() && consolidation.redundant.isEmpty() && renames.isEmpty()) {
+                return@withLock 0
+            }
+            val toSave = LinkedHashMap(consolidation.merged).apply { putAll(renames) }
+            dao.saveBatch(toSave.values.map(QsoRecord::toEntity))
+            consolidation.redundant.forEach { dao.delete(it.id) }
+            consolidation.redundant.size
+        }
+    }
+
    private suspend fun mergeRecords(records: List<QsoRecord>, fromLoTW: Boolean = false): AdifImportResult {
        val working = dao.getAll().map(QsoEntity::toDomain).toMutableList()
+        // Consolidate first: confirmations synced before the identity fix sit as their own
+        // rows (the tracker name and a mirrored band direction both failed the comparison),
+        // and left in place they would make the lookup below ambiguous between the operator's
+        // own row and the stale duplicate.
+        val consolidation = consolidateSplitRows(working)
+        // Rows imported under a tracking-source name join the ARRL name here, so what is stored
+        // is the identity both sides of a match resolve to (the lookup below is built on it).
+        val renames = rewriteOfficialNames(working)
        val lookup = working.indices.groupBy { working[it].confirmationLookupKey() }
            .mapValues { it.value.toMutableList() }.toMutableMap()
-        val knownKeys = working.mapTo(mutableSetOf(), ::stableQsoKey)
-        val changes = linkedMapOf<Int, QsoRecord>()
+        val keyIndex = working.indices.groupBy { stableQsoKey(working[it]) }
+            .mapValues { it.value.toMutableList() }.toMutableMap()
+        val knownKeys = keyIndex.keys.toMutableSet()
+        val changes = linkedMapOf<Int, QsoRecord>().apply {
+            putAll(consolidation.merged)
+            putAll(renames)
+        }
        var imported = 0
-        var updated = 0
+        var updated = consolidation.merged.size
        var skipped = 0
        records.forEach { remote ->
            if (!fromLoTW && !remote.lotwConfirmed && stableQsoKey(remote) in knownKeys) { skipped++; return@forEach }
@@ -102,10 +149,27 @@ class QsoRepository(
            val exact = candidates.filter { working[it].startUtcMillis == remote.startUtcMillis }
            val match = exact.singleOrNull() ?: candidates.singleOrNull()
            if (match == null) {
+                // A confirmation downloaded by the pre-fix parser sits as its own row with the
+                // band direction read mirrored (the downlink was stored as the uplink). It has no
+                // local partner (so nothing folds it) and its dedupe key equals the fresh report,
+                // so it would otherwise be skipped forever, keeping the wrong band on display.
+                // When the bands are exactly mirrored, adopt the report's direction instead.
+                val stale = if (fromLoTW) keyIndex[stableQsoKey(remote)]?.firstOrNull()
+                    ?.takeIf { index -> working[index].lotwConfirmed &&
+                        working[index].band.equals(remote.rxBand, true) &&
+                        working[index].rxBand.equals(remote.band, true) } else null
+                if (stale != null) {
+                    val fixed = working[stale].copy(band = remote.band, rxBand = remote.rxBand)
+                    working[stale] = fixed
+                    changes[stale] = fixed
+                    updated++
+                    return@forEach
+                }
                if (stableQsoKey(remote) in knownKeys) { skipped++; return@forEach }
-                val added = remote.copy(id = 0L)
+                val added = remote.copy(id = 0L, satelliteName = officialSatelliteName(remote.satelliteName))
                changes[working.size] = added
                lookup.getOrPut(added.confirmationLookupKey()) { mutableListOf() }.add(working.size)
+                keyIndex.getOrPut(stableQsoKey(added)) { mutableListOf() }.add(working.size)
                knownKeys += stableQsoKey(added)
                working += added
                imported++
@@ -120,8 +184,60 @@ class QsoRepository(
            }
        }
        dao.saveBatch(changes.values.map(QsoRecord::toEntity))
+        consolidation.redundant.forEach { dao.delete(it.id) }
        return AdifImportResult(imported, skipped, updated)
    }
+
+    /** Result of folding already-split rows back together. */
+    private data class Consolidation(
+        /** index in the stored list -> the record to save (local row + its confirmation). */
+        val merged: Map<Int, QsoRecord>,
+        /** imported confirmation rows that are now part of a local record. */
+        val redundant: List<QsoRecord>
+    )
+
+    /**
+     * Rewrites the names records were imported under into their ARRL names ("SAUDISAT 1C" ->
+     * "SO-50"), so the logbook, the ADIF export and the signed record all carry one name.
+     * Names the alias table does not know (recycled placeholders, satellites ARRL does not
+     * list) are kept exactly as they are. [working] is updated in place; the rewritten records
+     * are returned for the caller to save.
+     */
+    private fun rewriteOfficialNames(working: MutableList<QsoRecord>): Map<Int, QsoRecord> {
+        val renamed = mutableMapOf<Int, QsoRecord>()
+        working.indices.forEach { index ->
+            val record = working[index]
+            val official = officialSatelliteName(record.satelliteName)
+            if (official != record.satelliteName) {
+                val updated = record.copy(satelliteName = official)
+                working[index] = updated
+                renamed[index] = updated
+            }
+        }
+        return renamed
+    }
+
+    /**
+     * Folds confirmation rows that were imported as separate QSOs back into the local
+     * record they belong to (see [splitConfirmationPairs]). [working] is updated in
+     * place; the redundant rows are returned for the caller to delete.
+     */
+    private fun consolidateSplitRows(working: MutableList<QsoRecord>): Consolidation {
+        val merged = mutableMapOf<Int, QsoRecord>()
+        val redundant = mutableListOf<QsoRecord>()
+        // Snapshot the pairs first: the list is rewritten as pairs are applied.
+        splitConfirmationPairs(working.toList()).forEach { pair ->
+            val local = working[pair.localIndex]
+            val confirmation = working[pair.confirmationIndex]
+            val folded = local.withConfirmation(confirmation)
+            if (folded != local) {
+                working[pair.localIndex] = folded
+                merged[pair.localIndex] = folded
+            }
+            redundant += confirmation
+        }
+        return Consolidation(merged, redundant)
+    }
 }

 private fun QsoEntity.toDomain() = QsoRecord(
@@ -202,5 +318,29 @@ internal fun stableQsoKey(record: QsoRecord): String = listOf(
    record.txFrequencyHz?.toString().orEmpty(),
    record.mode.trim().uppercase(Locale.US),
    record.submode.trim().uppercase(Locale.US),
-    record.satelliteName.trim().uppercase(Locale.US)
+    // The identity, not the spelling: a row stored as "SO-50" is the same QSO as one imported
+    // as "SAUDISAT 1C", so re-importing an older export does not duplicate it.
+    satelliteIdentity(record.satelliteName)
 ).joinToString("|")
+
+/**
+ * Whether two rows carry the same operator-editable content.
+ *
+ * Minutes are the granularity for time: the edit dialog edits whole minutes (and rounds the
+ * stored seconds away when saving), so a seconds-only difference must not count as an edit.
+ * The satellite is compared by its ARRL identity, the mode by its display label — both sides
+ * of the same contact written differently (tracker vs official name, MFSK vs FT4) are the same
+ * content. Used to decide whether saving an already-uploaded/confirmed row should create a new
+ * record or leave the row alone.
+ */
+private fun QsoRecord.sameEditableContentAs(other: QsoRecord): Boolean =
+    theirCallsign.trim().equals(other.theirCallsign.trim(), true) &&
+        startUtcMillis / 60_000L == other.startUtcMillis / 60_000L &&
+        txFrequencyHz == other.txFrequencyHz &&
+        rxFrequencyHz == other.rxFrequencyHz &&
+        displayMode == other.displayMode &&
+        satelliteIdentity(satelliteName) == satelliteIdentity(other.satelliteName) &&
+        sentReport.trim() == other.sentReport.trim() &&
+        receivedReport.trim() == other.receivedReport.trim() &&
+        theirGrid.trim().uppercase(Locale.US) == other.theirGrid.trim().uppercase(Locale.US) &&
+        comment == other.comment
@@ -9,6 +9,8 @@
 */
 package com.rtbishop.look4sat.core.data.lotw

+import com.rtbishop.look4sat.core.domain.logbook.LoTWSatelliteAliases
+import com.rtbishop.look4sat.core.domain.repository.LoTWOperationException
 import com.rtbishop.look4sat.core.domain.repository.LoTWZonePair
 import java.io.File
 import org.junit.Assert.assertEquals
@@ -75,4 +77,50 @@ class LoTWConfigTest {
        assertNull(meta.regionField)
        assertTrue(meta.countryZones.isEmpty())
    }
+
+    @Test
+    fun `tracker catalogue names resolve to the ARRL satellite`() {
+        // The names the TLE sources store vs the single name ARRL knows for that satellite.
+        assertEquals("SO-50", config.resolveSatellite("SAUDISAT 1C"))
+        assertEquals("ARISS", config.resolveSatellite("ISS (ZARYA)"))
+        assertEquals("PO-101", config.resolveSatellite("DIWATA 2B"))
+        assertEquals("AO-91", config.resolveSatellite("FOX-1B"))
+        assertEquals("IO-86", config.resolveSatellite("LAPAN-A2"))
+        assertEquals("RS-44", config.resolveSatellite("DOSAAF-85"))
+        assertEquals("BO-102", config.resolveSatellite("CAS-7B"))
+        assertEquals("SO-50", config.resolveSatellite("SO-50"))
+    }
+
+    @Test
+    fun `satellite signing accepts tracker names and keeps ARRL spelling`() {
+        assertEquals("SO-50", config.satellite("SAUDISAT 1C", "2026-09-27"))
+        assertEquals("ARISS", config.satellite("ISS (ZARYA)", "2026-09-27"))
+        assertEquals("SO-50", config.satellite("SO-50 (SaudiOSCAR 50)", "2026-09-27"))
+    }
+
+    @Test
+    fun `satellite signing rejects names ARRL does not know`() {
+        // Placeholder designations are deliberately unmapped: signing them would name the
+        // wrong object, so the record must stay un-uploadable.
+        listOf("OBJECT AY", "MARINA", "NOT A SATELLITE").forEach { name ->
+            val error = runCatching { config.satellite(name, "2026-09-27") }.exceptionOrNull()
+            assertTrue("$name should be rejected", error is LoTWOperationException)
+        }
+    }
+
+    @Test
+    fun `satellite signing enforces the ARRL service dates`() {
+        // SO-50 is listed from 2002-12-20: a QSO before that cannot be signed.
+        val error = runCatching { config.satellite("SAUDISAT 1C", "2002-01-01") }.exceptionOrNull()
+        assertTrue(error is LoTWOperationException)
+        assertEquals("SO-50", config.satellite("SAUDISAT 1C", "2003-01-01"))
+    }
+
+    @Test
+    fun `every alias target is a real ARRL satellite name`() {
+        val catalogue = config.satelliteNames().toSet()
+        assertTrue("ARRL catalogue is unexpectedly small", catalogue.size > 100)
+        val unknown = LoTWSatelliteAliases.table.filterValues { it !in catalogue }
+        assertEquals("alias targets missing from config.tq6: $unknown", emptyMap<String, String>(), unknown)
+    }
 }
@@ -1,3 +1,21 @@
+/*
+ * Look4Sat-BA7OPF. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2026 BA7OPF.
+ * Based on Look4Sat by Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.data.repository

 import com.rtbishop.look4sat.core.domain.repository.LoTWResult
@@ -112,9 +130,12 @@ class LoTWRepositoryTest {
        assertEquals("A50QO", qso.call)
        assertEquals("FO-29", qso.satName)
        assertEquals("CW", qso.mode)
-        assertEquals("2M", qso.bandUp)
-        assertEquals("70CM", qso.bandDown)
-        assertEquals("V/U", qso.bandLabel)
+        // ADIF BAND is the transmitted (uplink) band, BAND_RX the received (downlink) one.
+        // Confirmed against the live report of the own uploads: SO-50 QSOs arrive as
+        // BAND=2M/FREQ=145.85000 + BAND_RX=70CM/FREQ_RX=436.80500, i.e. BAND=uplink.
+        assertEquals("70CM", qso.bandUp)
+        assertEquals("2M", qso.bandDown)
+        assertEquals("U/V", qso.bandLabel)
        assertEquals(2026, java.time.Instant.ofEpochMilli(qso.epochMs).atZone(java.time.ZoneOffset.UTC).year)
    }

@@ -0,0 +1,292 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.data.database.QsoDao
+import com.rtbishop.look4sat.core.data.database.entity.QsoEntity
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.QsoStatus
+import com.rtbishop.look4sat.core.domain.logbook.toConfirmedRecord
+import com.rtbishop.look4sat.core.domain.model.GridQso
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The logbook split reported 2026-09-28: a QSO uploaded from the app and the confirmation LoTW
+ * reported for it ended up as two rows, because the record keeps the tracking-source name
+ * ("SAUDISAT 1C") and the uplink band while the report carries the ARRL name ("SO-50") — and,
+ * before the direction fix, the mirrored band pair.
+ */
+class QsoRepositoryTest {
+
+    private val dao = FakeQsoDao()
+    private val repository = QsoRepository(dao, Dispatchers.Unconfined)
+
+    /** 2026-09-16 07:45Z, an SO-50 contact of the user's own report. */
+    private val qsoStart = 1_789_544_700_000L
+
+    @Test
+    fun mergeLoTW_confirmsTheUploadedRecordInsteadOfAddingASecondRow() = runBlocking {
+        val uploadedId = dao.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true).toEntity()) // 145.850 -> 2M
+
+        repository.mergeLoTW(listOf(reportConfirmation(satName = "SO-50")))
+
+        val rows = dao.getAll()
+        assertEquals(1, rows.size)
+        assertEquals(uploadedId, rows.first().id)
+        assertTrue(rows.first().lotwConfirmed)
+        // The row is also renamed to the ARRL spelling while it is merged.
+        assertEquals("SO-50", rows.first().satelliteName)
+        assertEquals(145_850_000L, rows.first().txFrequencyHz)
+    }
+
+    @Test
+    fun mergeLoTW_foldsRowsSplitByTheOldNameAndBandMismatch() = runBlocking {
+        val uploadedId = dao.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true).toEntity())
+        // Row imported before the fix: ARRL name and the mirrored band pair (BAND_RX read as
+        // the uplink), so it never folded into the local record.
+        dao.save(
+            reportConfirmation(satName = "SO-50").copy(band = "70CM", rxBand = "2M").toEntity()
+        )
+
+        repository.mergeLoTW(listOf(reportConfirmation(satName = "SO-50")))
+
+        val rows = dao.getAll()
+        assertEquals(1, rows.size)
+        assertEquals(uploadedId, rows.first().id)
+        assertTrue(rows.first().lotwConfirmed)
+        // The operator's own frequencies survive the consolidation.
+        assertEquals(145_850_000L, rows.first().txFrequencyHz)
+        assertEquals(436_795_000L, rows.first().rxFrequencyHz)
+    }
+
+    @Test
+    fun mergeLoTW_keepsAnotherContactOfTheSamePassApart() = runBlocking {
+        dao.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true).toEntity())
+        val otherOperator = reportConfirmation(satName = "SO-50").copy(theirCallsign = "BG5JVM")
+
+        repository.mergeLoTW(listOf(reportConfirmation(satName = "SO-50"), otherOperator))
+
+        val rows = dao.getAll()
+        assertEquals(2, rows.size)
+        // The local row is confirmed by its own report entry; the second operator's contact
+        // is a separate QSO and stays a separate, separately confirmed row.
+        assertEquals(setOf("BG5JSB", "BG5JVM"), rows.map { it.theirCallsign }.toSet())
+        assertTrue(rows.all { it.lotwConfirmed })
+    }
+
+    @Test
+    fun consolidateConfirmations_repairsAnAlreadySplitLogbook() = runBlocking {
+        val uploadedId = dao.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true).toEntity())
+        // Row imported before the fix: ARRL name + mirrored band pair.
+        dao.save(reportConfirmation(satName = "SO-50").copy(band = "70CM", rxBand = "2M").toEntity())
+
+        assertEquals(1, repository.consolidateConfirmations())
+
+        val rows = dao.getAll()
+        assertEquals(1, rows.size)
+        assertEquals(uploadedId, rows.first().id)
+        assertTrue(rows.first().lotwConfirmed)
+        // Nothing left to fold on a second pass.
+        assertEquals(0, repository.consolidateConfirmations())
+    }
+
+    @Test
+    fun consolidateConfirmations_renamesRowsImportedUnderATrackerName() = runBlocking {
+        // A record logged before names were normalised at write time.
+        val id = dao.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true).toEntity())
+
+        repository.consolidateConfirmations()
+
+        val row = dao.getAll().single()
+        assertEquals(id, row.id)
+        assertEquals("SO-50", row.satelliteName)
+        // Upload state and the operator's own frequencies survive the rename.
+        assertTrue(row.lotwUploaded)
+        assertEquals(145_850_000L, row.txFrequencyHz)
+        // A satellite ARRL does not list keeps whatever the tracker published.
+        dao.save(loggedInApp("FOO-1", lotwUploaded = false).toEntity())
+        repository.consolidateConfirmations()
+        assertEquals(setOf("SO-50", "FOO-1"), dao.getAll().map { it.satelliteName }.toSet())
+    }
+
+    @Test
+    fun mergeLoTW_fixesBandDirectionOfAStaleConfirmationRow() = runBlocking {
+        // A confirmation downloaded by the pre-fix parser: ARRL name but the band direction
+        // mirrored (downlink stored as the uplink), and no local row to fold it into, so it
+        // sits as its own QSL row.
+        val staleId = dao.save(reportConfirmation(satName = "SO-50").copy(band = "70CM", rxBand = "2M").toEntity())
+
+        repository.mergeLoTW(listOf(reportConfirmation(satName = "SO-50")))
+
+        val rows = dao.getAll()
+        assertEquals(1, rows.size)
+        assertEquals(staleId, rows.first().id)
+        assertTrue(rows.first().lotwConfirmed)
+        // The stale row adopts the report's (uplink-first) direction instead of being skipped
+        // forever by the dedupe key.
+        assertEquals("2M", rows.first().band)
+        assertEquals("70CM", rows.first().rxBand)
+    }
+
+    @Test
+    fun save_editingAnUploadedRecordCreatesANewRecord() = runBlocking {
+        val originalId = repository.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true))
+        val edited = loggedInApp("SAUDISAT 1C", lotwUploaded = true).copy(id = originalId, theirCallsign = "BG5JVM")
+
+        val newId = repository.save(edited)
+
+        assertNotEquals(originalId, newId)
+        val rows = dao.getAll()
+        assertEquals(2, rows.size)
+        // The original keeps its identity and upload state, untouched.
+        val original = rows.first { it.id == originalId }
+        assertEquals("BG5JSB", original.theirCallsign)
+        assertTrue(original.lotwUploaded)
+        // The edited content is a fresh, uploadable record.
+        val created = rows.first { it.id == newId }
+        assertEquals("BG5JVM", created.theirCallsign)
+        assertFalse(created.lotwUploaded)
+        assertFalse(created.lotwConfirmed)
+    }
+
+    @Test
+    fun save_editingAnUnuploadedRecordUpdatesInPlace() = runBlocking {
+        val id = repository.save(loggedInApp("SAUDISAT 1C", lotwUploaded = false))
+        repository.save(loggedInApp("SAUDISAT 1C", lotwUploaded = false).copy(id = id, theirCallsign = "BG5JVM"))
+
+        val rows = dao.getAll()
+        assertEquals(1, rows.size)
+        assertEquals("BG5JVM", rows.first().theirCallsign)
+    }
+
+    @Test
+    fun save_editingAnUploadedRecordWithoutChangesKeepsOneRow() = runBlocking {
+        val id = repository.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true))
+        repository.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true).copy(id = id))
+
+        assertEquals(1, dao.getAll().size)
+    }
+
+    @Test
+    fun save_editingAnUploadedRecordWithOnlySecondsChangedKeepsOneRow() = runBlocking {
+        val id = repository.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true))
+        // The edit dialog edits whole minutes and rounds the seconds away on save, so a
+        // seconds-only difference must not be treated as an edit (no new record).
+        repository.save(loggedInApp("SAUDISAT 1C", lotwUploaded = true).copy(id = id, startUtcMillis = qsoStart + 10_000L))
+
+        assertEquals(1, dao.getAll().size)
+    }
+
+    /** A record as the log page creates it: tracker name, repeater pair, uplink band. */
+    private fun loggedInApp(satelliteName: String, lotwUploaded: Boolean) = QsoRecord(
+        startUtcMillis = qsoStart,
+        theirCallsign = "BG5JSB",
+        myCallsign = "BA7OPF",
+        txFrequencyHz = 145_850_000L,
+        rxFrequencyHz = 436_795_000L,
+        band = "2M",
+        rxBand = "70CM",
+        mode = "FM",
+        satelliteName = satelliteName,
+        propagationMode = "SAT",
+        status = QsoStatus.COMPLETE,
+        lotwUploaded = lotwUploaded
+    )
+
+    /** A confirmation as the report parser + [toConfirmedRecord] build it (BAND carries the uplink). */
+    private fun reportConfirmation(satName: String) = GridQso(
+        call = "BG5JSB",
+        epochMs = qsoStart,
+        satName = satName,
+        mode = "FM",
+        bandUp = "2M",
+        bandDown = "70CM",
+        dxcc = 318,
+        country = "China",
+        cqz = 24,
+        state = "GD",
+        myGrid = "OL62",
+        myGrids = setOf("OL62", "OL63")
+    ).toConfirmedRecord("BA7OPF")
+
+    private fun QsoRecord.toEntity() = QsoEntity(
+        id = id,
+        startUtcMillis = startUtcMillis,
+        endUtcMillis = endUtcMillis,
+        theirCallsign = theirCallsign,
+        myCallsign = myCallsign,
+        theirGrid = theirGrid,
+        myGrid = myGrid,
+        sentReport = sentReport,
+        receivedReport = receivedReport,
+        txFrequencyHz = txFrequencyHz,
+        rxFrequencyHz = rxFrequencyHz,
+        band = band,
+        rxBand = rxBand,
+        mode = mode,
+        submode = submode,
+        satelliteName = satelliteName,
+        transponderName = transponderName,
+        satelliteMode = satelliteMode,
+        passAosUtcMillis = passAosUtcMillis,
+        automatic = automatic,
+        status = status.name,
+        dedupeKey = listOf(startUtcMillis, theirCallsign, myCallsign, txFrequencyHz, mode, submode, satelliteName)
+            .joinToString("|"),
+        propagationMode = propagationMode,
+        lotwConfirmed = lotwConfirmed,
+        lotwUploaded = lotwUploaded,
+        lotwReceived = lotwReceived,
+        lotwQslDate = lotwQslDate,
+        vuccGrids = vuccGrids.joinToString(","),
+        dxcc = dxcc,
+        country = country,
+        cqZone = cqZone,
+        region = region,
+        comment = comment
+    )
+
+    private class FakeQsoDao : QsoDao {
+        private val rows = linkedMapOf<Long, QsoEntity>()
+        private var nextId = 1L
+
+        override fun observeAll(): Flow<List<QsoEntity>> = flowOf(rows.values.toList())
+
+        override suspend fun find(id: Long): QsoEntity? = rows[id]
+
+        override suspend fun getAll(): List<QsoEntity> = rows.values.toList()
+
+        override suspend fun getDedupeKeys(): List<String> = rows.values.map { it.dedupeKey }
+
+        override suspend fun save(record: QsoEntity): Long {
+            val id = if (record.id == 0L) nextId++ else record.id
+            rows[id] = record.copy(id = id)
+            return id
+        }
+
+        override suspend fun importRecords(records: List<QsoEntity>): List<Long> = records.map { save(it) }
+
+        override suspend fun delete(id: Long) {
+            rows.remove(id)
+        }
+
+        override suspend fun markUploaded(ids: List<Long>) {
+            ids.forEach { id -> rows[id]?.let { rows[id] = it.copy(lotwUploaded = true) } }
+        }
+    }
+}