feat: withdraw a deleted QSO from QRZ.com and Club Log

Opt-in, off by default: neither service can undo it, and a local delete is not
always a statement about the world — a duplicate cleared out of a contest log
was never meant to change the DX's log.

The two APIs are not alike, and the difference decides what is possible:

  - Club Log deletes by MATCH (callsign, exact timestamp, band number), so it
    works for every QSO in the log, past or future. The band table is its own
    list and is pinned by a test: a band mapped to the wrong number does not
    fail, it points the delete at a different QSO.
  - QRZ.com deletes ONLY by logid. So markExtUploaded now stores the LOGID it
    already received on every upload — it was being logged and thrown away. A
    QSO uploaded before this cannot be withdrawn from here at all, and the log
    says so by name rather than leaving the operator to assume it worked.

Both run BEFORE the local delete, because both need the QSO's own fields to
find their copy and there is nothing left to ask with once the row is gone.
Neither can block it: the operator asked for the QSO to go, and a refusing
website is not a reason to keep it.

app.go

@@ -273,6 +273,9 @@ const (
 	// External services (logbook upload). QRZ.com first; Clublog / LoTW
 	// will add their own keys under the same extsvc.* prefix.
 	keyExtQRZAPIKey = "extsvc.qrz.api_key"
+	// Opt-in, and off by default: withdrawing a QSO from QRZ or Club Log cannot
+	// be undone, and a local delete is not always meant to reach the world.
+	keyExtDeleteRemote  = "extsvc.delete_remote" // also delete from QRZ/Club Log when a QSO is deleted
 	keyExtQRZForceCall  = "extsvc.qrz.force_station_callsign"
 	keyExtQRZAutoUpload = "extsvc.qrz.auto_upload"
 	keyExtQRZUploadMode = "extsvc.qrz.upload_mode"
@@ -5513,15 +5516,77 @@ func (a *App) DeleteQSO(id int64) error {
 	if a.qso == nil {
 		return fmt.Errorf("db not initialized")
 	}
+	a.deleteRemoteCopies([]int64{id})
 	return a.qso.Delete(a.ctx, id)
 }
 
+// deleteRemoteCopies withdraws QSOs from QRZ.com and Club Log, when the
+// operator has asked for that.
+//
+// Called BEFORE the local delete, because both services need the QSO's own
+// fields to find their copy — Club Log matches on callsign, exact time and
+// band, and QRZ needs the logid stored on the record. Once the row is gone
+// there is nothing left to ask with.
+//
+// Failures never block the local delete. The operator asked for this QSO to go;
+// a refusing website is not a reason to keep it, and the log says what happened
+// so it can be sorted out on the site afterwards.
+func (a *App) deleteRemoteCopies(ids []int64) {
+	if a.qso == nil || len(ids) == 0 {
+		return
+	}
+	prefix := ""
+	if a.profileHasGroup(markerExtsvc) {
+		prefix = a.profileScope()
+	}
+	m, err := a.getManyScoped(prefix, keyExtDeleteRemote)
+	if err != nil || m[keyExtDeleteRemote] != "1" {
+		return
+	}
+	cfg := a.loadExternalServices()
+	doQRZ := strings.TrimSpace(cfg.QRZ.APIKey) != ""
+	doClublog := strings.TrimSpace(cfg.Clublog.Email) != "" && cfg.Clublog.Password != ""
+	if !doQRZ && !doClublog {
+		return
+	}
+	for _, id := range ids {
+		q, err := a.qso.GetByID(a.ctx, id)
+		if err != nil || q.Callsign == "" {
+			continue
+		}
+		if doQRZ {
+			logID := ""
+			if q.Extras != nil {
+				logID = q.Extras["APP_OPSLOG_QRZ_LOGID"]
+			}
+			if strings.TrimSpace(logID) == "" {
+				// Uploaded before OpsLog kept the identifier, or never uploaded.
+				// QRZ has no delete-by-callsign-and-date, so say so plainly rather
+				// than let the operator believe it was withdrawn.
+				applog.Printf("extsvc: QSO %d (%s) has no QRZ logid — remove it on qrz.com by hand", id, q.Callsign)
+			} else if msg, err := extsvc.DeleteQRZ(a.ctx, nil, cfg.QRZ.APIKey, []string{logID}); err != nil {
+				applog.Printf("extsvc: QRZ delete of QSO %d (%s) failed: %v", id, q.Callsign, err)
+			} else {
+				applog.Printf("extsvc: QRZ delete of QSO %d (%s): %s", id, q.Callsign, msg)
+			}
+		}
+		if doClublog {
+			if msg, err := extsvc.DeleteClublog(a.ctx, nil, cfg.Clublog, q.Callsign, q.QSODate, q.Band); err != nil {
+				applog.Printf("extsvc: Club Log delete of QSO %d (%s) failed: %v", id, q.Callsign, err)
+			} else {
+				applog.Printf("extsvc: Club Log delete of QSO %d (%s): %s", id, q.Callsign, msg)
+			}
+		}
+	}
+}
+
 // DeleteQSOs removes several QSOs at once (multi-row selection). Returns the
 // number actually deleted.
 func (a *App) DeleteQSOs(ids []int64) (int64, error) {
 	if a.qso == nil {
 		return 0, fmt.Errorf("db not initialized")
 	}
+	a.deleteRemoteCopies(ids)
 	return a.qso.DeleteMany(a.ctx, ids)
 }
 
@@ -9088,10 +9153,11 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
 		keyExtHRDLogCallsign, keyExtHRDLogCode, keyExtHRDLogAutoUpload, keyExtHRDLogUploadMode,
 		keyExtEQSLUsername, keyExtEQSLPassword, keyExtEQSLQTHNick, keyExtEQSLAutoUpload, keyExtEQSLUploadMode,
 		keyExtCloudlogURL, keyExtCloudlogAPIKey, keyExtCloudlogStationID,
-		keyExtCloudlogAutoUpload, keyExtCloudlogUploadMode)
+		keyExtCloudlogAutoUpload, keyExtCloudlogUploadMode, keyExtDeleteRemote)
 	if err != nil {
 		return out
 	}
+	out.DeleteRemote = m[keyExtDeleteRemote] == "1"
 	out.QRZ = extsvc.ServiceConfig{
 		APIKey:               m[keyExtQRZAPIKey],
 		ForceStationCallsign: m[keyExtQRZForceCall],
@@ -9233,8 +9299,13 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
 	if cfg.Cloudlog.AutoUpload {
 		clgAuto = "1"
 	}
+	delRemote := "0"
+	if cfg.DeleteRemote {
+		delRemote = "1"
+	}
 	scope := a.profileScope() // write under the active profile's prefix
 	for k, v := range map[string]string{
+		keyExtDeleteRemote:  delRemote,
 		keyExtQRZAPIKey:     strings.TrimSpace(cfg.QRZ.APIKey),
 		keyExtQRZForceCall:  strings.ToUpper(strings.TrimSpace(cfg.QRZ.ForceStationCallsign)),
 		keyExtQRZAutoUpload: auto,
@@ -10713,6 +10784,17 @@ func (a *App) markExtUploaded(svc extsvc.Service, id int64, logID string) {
 	if a.qso == nil {
 		return
 	}
+	// Keep the identifier the service handed back. QRZ deletes ONLY by logid —
+	// its API has no delete-by-callsign-and-date — so a QSO uploaded without
+	// recording this can never be withdrawn from QRZ afterwards except by hand.
+	// It costs one small write per upload and it is the only chance to get it.
+	if strings.TrimSpace(logID) != "" && id != 0 {
+		key := "APP_OPSLOG_" + strings.ToUpper(string(svc)) + "_LOGID"
+		if err := a.qso.SetExtra(ctx, id, key, strings.TrimSpace(logID)); err != nil {
+			applog.Printf("extsvc: store %s logid for QSO %d: %v", svc, id, err)
+		}
+	}
+
 	var err error
 	switch svc {
 	case extsvc.ServiceQRZ:

changelog.json

@@ -14,7 +14,8 @@
       "The CAT backend list is renamed by how the radio is reached: OmniRig, FlexRadio (API), Yaesu (USB), Kenwood (USB, network), Xiegu (USB), Icom (CI-V USB), Icom (CI-V network), TCI.",
       "With automatic recording off but the audio devices configured, a red dot appears where the recording counter goes. Click it to record the contact by hand: the counter starts, the dot disappears, and logging the QSO saves the file as usual. The sound devices are released again afterwards.",
       "A recording in progress can be stopped and TRANSMITTED to the station being worked, keyed and sent like a voice-keyer message — for when they ask to hear their own signal. The audio is kept and still saved with the QSO, and recording can be resumed.",
-      "The award reference table can be sorted by reference (the default) or by description — click either heading, click again to reverse. Both the grid and list views follow."
+      "The award reference table can be sorted by reference (the default) or by description — click either heading, click again to reverse. Both the grid and list views follow.",
+      "Deleting a QSO can now withdraw it from QRZ.com and Club Log as well — Settings → External services, off by default. Club Log matches on callsign, time and band so it works for any QSO; QRZ.com can only remove records OpsLog uploaded itself, since its API deletes by record number only."
     ],
     "fr": [
       "Le backend Kenwood est désormais éprouvé face à une radio qui répond : OpsLog dialogue avec l'émulateur TS-2000 qu'il embarque déjà pour les amplis ACOM, ce qui vérifie fréquence, mode, VFO, split et PTT de bout en bout. Un essai sur un vrai Kenwood reste nécessaire, mais le dialogue n'est plus non testé.",
@@ -28,7 +29,8 @@
       "La liste des backends CAT est renommée selon la façon dont la radio est jointe : OmniRig, FlexRadio (API), Yaesu (USB), Kenwood (USB, réseau), Xiegu (USB), Icom (CI-V USB), Icom (CI-V réseau), TCI.",
       "Quand l'enregistrement automatique est désactivé mais que les périphériques audio sont configurés, un rond rouge apparaît à l'emplacement du compteur. Un clic enregistre le contact à la main : le compteur démarre, le rond disparaît, et journaliser le QSO enregistre le fichier comme d'habitude. Les périphériques audio sont ensuite relâchés.",
       "Un enregistrement en cours peut être arrêté puis ÉMIS vers la station travaillée, radio passée en émission comme un message du manipulateur vocal — pour quand elle demande à entendre son propre signal. L'audio est conservé et toujours enregistré avec le QSO, et l'enregistrement peut reprendre.",
-      "Le tableau des références d'un diplôme peut être trié par référence (par défaut) ou par description — cliquez sur l'en-tête, un second clic inverse l'ordre. Les vues grille et liste suivent toutes deux."
+      "Le tableau des références d'un diplôme peut être trié par référence (par défaut) ou par description — cliquez sur l'en-tête, un second clic inverse l'ordre. Les vues grille et liste suivent toutes deux.",
+      "Supprimer un QSO peut désormais le retirer aussi de QRZ.com et Club Log — Réglages → Services externes, désactivé par défaut. Club Log retrouve le contact par indicatif, heure et bande, donc cela vaut pour n'importe quel QSO ; QRZ.com ne peut retirer que les enregistrements envoyés par OpsLog, son API ne supprimant que par numéro d'enregistrement."
     ]
   },
   {

frontend/src/components/SettingsModal.tsx

@@ -1287,7 +1287,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     upload_flags: string[]; write_log: boolean;
     auto_upload: boolean; upload_mode: string;
   };
-  type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg; eqsl: ExtServiceCfg; cloudlog: ExtServiceCfg };
+  type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg; eqsl: ExtServiceCfg; cloudlog: ExtServiceCfg; delete_remote?: boolean };
   const emptyExtCfg = (): ExtServiceCfg => ({
     api_key: '', url: '', station_id: '', email: '', username: '', password: '', callsign: '', code: '', qth_nickname: '',
     force_station_callsign: '', tqsl_path: '', station_location: '', key_password: '',
@@ -1295,7 +1295,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     auto_upload: false, upload_mode: 'immediate',
   });
   const [extSvc, setExtSvc] = useState<ExternalServices>({
-    qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(), eqsl: emptyExtCfg(), cloudlog: emptyExtCfg(),
+    qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(), eqsl: emptyExtCfg(), cloudlog: emptyExtCfg(), delete_remote: false,
   });
   const [qrzTest, setQrzTest] = useState<{ ok: boolean; msg: string } | null>(null);
   const [qrzTesting, setQrzTesting] = useState(false);
@@ -4243,6 +4243,18 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           ))}
         </div>
 
+        <label className="flex items-start gap-2 text-sm cursor-pointer mb-4 max-w-2xl">
+          <Checkbox
+            checked={!!extSvc.delete_remote}
+            onCheckedChange={(c) => setExtSvc((v) => ({ ...v, delete_remote: !!c }))}
+            className="mt-0.5"
+          />
+          <span>
+            {t('es.deleteRemote')}
+            <span className="block text-xs text-muted-foreground mt-0.5">{t('es.deleteRemoteHint')}</span>
+          </span>
+        </label>
+
         {extSvcTab === 'qrz' ? (
           <div className="space-y-4 max-w-2xl">
             <div className="grid grid-cols-[170px_1fr] gap-3 items-center">

frontend/src/lib/i18n.tsx

@@ -298,7 +298,7 @@ const en: Dict = {
   'es.usernameCall': 'Username (callsign)', 'es.eqslUserPh': 'your eQSL.cc login (callsign)', 'es.eqslPwPh': 'eQSL.cc account password', 'es.qthNick': 'QTH nickname', 'es.qthNickPh': 'optional — required only if your eQSL account has several QTHs', 'es.eqslHint': 'The QTH nickname tells eQSL which location profile to file the QSO under. Leave blank if you have only one.',
   'es.lotwUser': 'LoTW user', 'es.lotwUserPh': 'LoTW website login (for downloading confirmations)', 'es.lotwPw': 'LoTW password', 'es.lotwPwPh': 'LoTW website password', 'es.tqslPath': 'TQSL path', 'es.stationLoc': 'Station location', 'es.pickLoc': '— pick a TQSL location —', 'es.noLoc': 'No TQSL locations found', 'es.reloadLoc': 'Reload locations from TQSL', 'es.lotwForcePh': "e.g. F4BPO/P — leave blank to use the QSO's own call", 'es.lotwForceHint': 'Overrides STATION_CALLSIGN at sign time so one certificate can sign several calls (F4BPO, F4BPO/P, TM2Q). Pick the matching Station Location above.', 'es.keyPw': 'Key password', 'es.keyPwPh': 'only if your certificate key has a password', 'es.considerUnsent': 'Consider as unsent', 'es.flagN': 'No (N)', 'es.flagR': 'Requested (R)', 'es.lotwUnsentHint': "At app close, every QSO whose LoTW sent status is one of these is signed and uploaded in one TQSL batch — including QSOs imported from an ADIF. Uploaded QSOs become Y and won't be re-sent. Must include your default sent status from Confirmations.", 'es.lotwAutoClose': 'Automatic upload on application close', 'es.lotwWriteLog': 'Write TQSL diagnostic log (-t)',
   'es.potaHint': 'Update your QSOs with the park reference from your pota.app hunter log. Paste your session token: log in at pota.app, open the browser DevTools → Network tab, click any api.pota.app request, and copy the full Authorization header value. The token expires after a while — re-copy it if the sync fails.', 'es.sessionToken': 'Session token', 'es.saving': 'Saving…', 'es.saveToken': 'Save token', 'es.potaThen': 'Then run the sync from the QSL Manager tab → service POTA hunter log (you can see and fix unmatched QSOs there).',
-  'es.soon': 'soon', 'es.comingSoon': '{name} — coming soon', 'es.notWired': "This external service isn't wired up yet.",
+  'es.soon': 'soon', 'es.deleteRemote': 'Also delete from QRZ.com and Club Log', 'es.deleteRemoteHint': 'When you delete a QSO here, withdraw it from those services too. Neither offers an undo. Club Log matches on callsign, time and band, so it works for any QSO; QRZ.com can only delete records OpsLog uploaded itself \u2014 older ones must be removed on the website. The local delete happens either way, and the log says what each service answered.', 'es.comingSoon': '{name} — coming soon', 'es.notWired': "This external service isn't wired up yet.",
   'lotw.usersTitle': 'LoTW user list', 'lotw.usersHint': "Downloads ARRL's public list of LoTW users + their last-upload date, to show a colour-coded LoTW badge next to a callsign (green < 1 week · amber 1–4 weeks · red > 30 days).", 'lotw.usersDownload': 'Download LoTW user list', 'lotw.usersDownloading': 'Downloading…', 'lotw.usersLoaded': '{n} users loaded · updated {date}', 'lotw.usersNone': 'Not downloaded yet — the badge stays hidden until you do.',
   'scp.title': 'Super Check Partial', 'scp.partial': 'Partial', 'scp.close': 'Close', 'scp.fill': 'Fill {call}', 'scp.none': 'No match', 'scp.typeMore': 'Type a call…', 'scp.noList': 'Download the SCP list in Settings → General.', 'scp.enable': 'Super Check Partial / N+1 callsign helper', 'scp.settingsHint': 'Downloads the community MASTER.SCP master list and shows a two-column widget as you type a call: Partial (known calls containing what you typed) and N+1 (calls one character away) — to spot and fix a busted call.', 'scp.download': 'Update SCP list', 'scp.downloading': 'Downloading…', 'scp.loaded': '{n} calls loaded · updated {date}', 'scp.notLoaded': 'Not downloaded yet.',
   'hw.connecting': 'Connecting…', 'hw.testConn': 'Test connection', 'hw.sending': 'Sending…', 'hw.testRotator': 'Test (point to 0°)',
@@ -698,7 +698,7 @@ const fr: Dict = {
   'es.usernameCall': 'Identifiant (indicatif)', 'es.eqslUserPh': 'ton identifiant eQSL.cc (indicatif)', 'es.eqslPwPh': 'mot de passe du compte eQSL.cc', 'es.qthNick': 'Surnom QTH', 'es.qthNickPh': 'optionnel — requis seulement si ton compte eQSL a plusieurs QTH', 'es.eqslHint': "Le surnom QTH indique à eQSL sous quel profil de lieu classer le QSO. Laisse vide si tu n'en as qu'un.",
   'es.lotwUser': 'Utilisateur LoTW', 'es.lotwUserPh': 'identifiant du site LoTW (pour télécharger les confirmations)', 'es.lotwPw': 'Mot de passe LoTW', 'es.lotwPwPh': 'mot de passe du site LoTW', 'es.tqslPath': 'Chemin TQSL', 'es.stationLoc': 'Station location', 'es.pickLoc': '— choisir une Station Location TQSL —', 'es.noLoc': 'Aucune Station Location TQSL trouvée', 'es.reloadLoc': 'Recharger les locations depuis TQSL', 'es.lotwForcePh': "p. ex. F4BPO/P — laisse vide pour utiliser l'indicatif du QSO", 'es.lotwForceHint': "Remplace STATION_CALLSIGN à la signature pour qu'un même certificat signe plusieurs indicatifs (F4BPO, F4BPO/P, TM2Q). Choisis la Station Location correspondante ci-dessus.", 'es.keyPw': 'Mot de passe de la clé', 'es.keyPwPh': 'seulement si la clé de ton certificat a un mot de passe', 'es.considerUnsent': 'Considérer comme non envoyé', 'es.flagN': 'Non (N)', 'es.flagR': 'Demandé (R)', 'es.lotwUnsentHint': "À la fermeture, chaque QSO dont le statut LoTW « envoyé » est l'un de ceux-ci est signé et envoyé dans un même lot TQSL — y compris les QSO importés depuis un ADIF. Les QSO envoyés passent à Y et ne sont pas renvoyés. Doit inclure ton statut « envoyé » par défaut défini dans Confirmations.", 'es.lotwAutoClose': "Envoi automatique à la fermeture de l'application", 'es.lotwWriteLog': 'Écrire le journal de diagnostic TQSL (-t)',
   'es.potaHint': "Met à jour tes QSO avec la référence du parc depuis ton carnet chasseur pota.app. Colle ton jeton de session : connecte-toi sur pota.app, ouvre les DevTools du navigateur → onglet Network, clique sur une requête api.pota.app, et copie toute la valeur de l'en-tête Authorization. Le jeton expire au bout d'un moment — recopie-le si la synchro échoue.", 'es.sessionToken': 'Jeton de session', 'es.saving': 'Enregistrement…', 'es.saveToken': 'Enregistrer le jeton', 'es.potaThen': "Puis lance la synchro depuis l'onglet Gestionnaire QSL → service POTA hunter log (tu peux y voir et corriger les QSO non appariés).",
-  'es.soon': 'bientôt', 'es.comingSoon': '{name} — bientôt', 'es.notWired': "Ce service externe n'est pas encore branché.",
+  'es.soon': 'bientôt', 'es.deleteRemote': 'Supprimer aussi sur QRZ.com et Club Log', 'es.deleteRemoteHint': 'Quand vous supprimez un QSO ici, le retirer aussi de ces services. Aucun des deux ne propose d\u2019annulation. Club Log retrouve le QSO par indicatif, heure et bande, donc cela fonctionne pour n\u2019importe quel contact ; QRZ.com ne peut supprimer que les enregistrements envoy\u00e9s par OpsLog lui-m\u00eame \u2014 les plus anciens doivent \u00eatre retir\u00e9s sur le site. La suppression locale a lieu dans tous les cas, et le journal indique ce que chaque service a r\u00e9pondu.', 'es.comingSoon': '{name} — bientôt', 'es.notWired': "Ce service externe n'est pas encore branché.",
   'lotw.usersTitle': 'Liste des utilisateurs LoTW', 'lotw.usersHint': "Télécharge la liste publique ARRL des utilisateurs LoTW + leur date de dernier upload, pour afficher un badge LoTW coloré à côté d'un indicatif (vert < 1 semaine · ambre 1–4 semaines · rouge > 30 j).", 'lotw.usersDownload': 'Télécharger la liste LoTW', 'lotw.usersDownloading': 'Téléchargement…', 'lotw.usersLoaded': '{n} utilisateurs chargés · maj {date}', 'lotw.usersNone': 'Pas encore téléchargée — le badge reste caché tant que ce n’est pas fait.',
   'scp.title': 'Super Check Partial', 'scp.partial': 'Partiel', 'scp.close': 'Fermer', 'scp.fill': 'Remplir {call}', 'scp.none': 'Aucun', 'scp.typeMore': 'Tape un indicatif…', 'scp.noList': 'Télécharge la liste SCP dans Réglages → Général.', 'scp.enable': 'Assistant indicatifs Super Check Partial / N+1', 'scp.settingsHint': "Télécharge la liste communautaire MASTER.SCP et affiche un widget en 2 colonnes pendant que tu tapes un indicatif : Partiel (indicatifs connus contenant ce que tu tapes) et N+1 (indicatifs à une lettre près) — pour repérer et corriger un call busté.", 'scp.download': 'Mettre à jour la liste SCP', 'scp.downloading': 'Téléchargement…', 'scp.loaded': '{n} indicatifs chargés · maj {date}', 'scp.notLoaded': 'Pas encore téléchargée.',
   'hw.connecting': 'Connexion…', 'hw.testConn': 'Tester la connexion', 'hw.sending': 'Envoi…', 'hw.testRotator': 'Tester (pointer vers 0°)',

frontend/wailsjs/go/models.ts

@@ -1297,6 +1297,7 @@ export namespace extsvc {
 	    hrdlog: ServiceConfig;
 	    eqsl: ServiceConfig;
 	    cloudlog: ServiceConfig;
+	    delete_remote: boolean;
 	
 	    static createFrom(source: any = {}) {
 	        return new ExternalServices(source);
@@ -1310,6 +1311,7 @@ export namespace extsvc {
 	        this.hrdlog = this.convertValues(source["hrdlog"], ServiceConfig);
 	        this.eqsl = this.convertValues(source["eqsl"], ServiceConfig);
 	        this.cloudlog = this.convertValues(source["cloudlog"], ServiceConfig);
+	        this.delete_remote = source["delete_remote"];
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {

internal/extsvc/delete.go

@@ -0,0 +1,198 @@
+package extsvc
+
+// Withdrawing a QSO from the external services after it is deleted locally.
+//
+// The two services could hardly be less alike, and the difference decides what
+// is possible for QSOs already in the log:
+//
+//   - QRZ.com deletes ONLY by logid — the identifier it returns on INSERT.
+//     There is no delete-by-callsign-and-date. A QSO uploaded before OpsLog
+//     started recording that identifier therefore cannot be withdrawn from
+//     here; the operator has to do it on the website. QRZ's own documentation
+//     puts it plainly: "There is no undo from this operation."
+//   - Club Log deletes by MATCH: the worked callsign, the exact timestamp and
+//     the band. Nothing has to have been stored in advance, so this works for
+//     every QSO in the log, past or future.
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// clublogDeleteURL is Club Log's real-time single-QSO delete endpoint.
+const clublogDeleteURL = "https://clublog.org/delete.php"
+
+// DeleteQRZ removes QSOs from a QRZ logbook by their logid.
+//
+// The identifiers come from the LOGID QRZ returns on INSERT, which OpsLog
+// stores on the QSO as APP_OPSLOG_QRZ_LOGID.
+//
+// QRZ answers RESULT=OK when every id was deleted, PARTIAL when some were not
+// found, FAIL when none were. PARTIAL and FAIL are NOT treated as errors here:
+// the QSO is being deleted locally either way, and "it was already gone from
+// QRZ" is the outcome the operator wanted. The message is returned so the
+// caller can log what actually happened.
+func DeleteQRZ(ctx context.Context, client *http.Client, apiKey string, logIDs []string) (string, error) {
+	apiKey = strings.TrimSpace(apiKey)
+	if apiKey == "" {
+		return "", fmt.Errorf("qrz: api key not set")
+	}
+	ids := make([]string, 0, len(logIDs))
+	for _, id := range logIDs {
+		if id = strings.TrimSpace(id); id != "" {
+			ids = append(ids, id)
+		}
+	}
+	if len(ids) == 0 {
+		return "", fmt.Errorf("qrz: no logid recorded for this QSO — it can only be removed on qrz.com")
+	}
+
+	form := url.Values{}
+	form.Set("KEY", apiKey)
+	form.Set("ACTION", "DELETE")
+	form.Set("LOGIDS", strings.Join(ids, ","))
+
+	body, err := postForm(ctx, client, qrzAPIURL, form, 20*time.Second)
+	if err != nil {
+		return "", fmt.Errorf("qrz: %w", err)
+	}
+	LogSink("qrz: DELETE raw response: %s", strings.TrimSpace(body))
+
+	vals, _ := url.ParseQuery(strings.TrimSpace(body))
+	result := strings.ToUpper(strings.TrimSpace(vals.Get("RESULT")))
+	count := strings.TrimSpace(vals.Get("COUNT"))
+	switch result {
+	case "OK", "PARTIAL", "FAIL":
+		return fmt.Sprintf("RESULT=%s COUNT=%s", result, count), nil
+	case "AUTH":
+		return "", fmt.Errorf("qrz: the logbook key was refused")
+	}
+	return "", fmt.Errorf("qrz: unexpected reply %q", strings.TrimSpace(body))
+}
+
+// DeleteClublog removes one QSO from a Club Log logbook.
+//
+// whenUTC must be the QSO's start time; Club Log matches on it EXACTLY, to the
+// second, so a rounded or local-time value simply finds nothing. band is an
+// ADIF band name ("20m"), translated below to the band number Club Log wants.
+func DeleteClublog(ctx context.Context, client *http.Client, cfg ServiceConfig, dxCall string, whenUTC time.Time, band string) (string, error) {
+	email := strings.TrimSpace(cfg.Email)
+	call := strings.ToUpper(strings.TrimSpace(cfg.Callsign))
+	dx := strings.ToUpper(strings.TrimSpace(dxCall))
+	switch {
+	case email == "":
+		return "", fmt.Errorf("clublog: account email not set")
+	case cfg.Password == "":
+		return "", fmt.Errorf("clublog: password not set")
+	case call == "":
+		return "", fmt.Errorf("clublog: logbook callsign not set")
+	case dx == "":
+		return "", fmt.Errorf("clublog: no callsign to delete")
+	case whenUTC.IsZero():
+		return "", fmt.Errorf("clublog: the QSO has no time — Club Log matches on it exactly")
+	}
+	bandID, ok := clublogBandID(band)
+	if !ok {
+		return "", fmt.Errorf("clublog: band %q is not one Club Log accepts for deletion", band)
+	}
+
+	form := url.Values{}
+	form.Set("email", email)
+	form.Set("password", cfg.Password)
+	form.Set("callsign", call)
+	form.Set("dxcall", dx)
+	form.Set("datetime", whenUTC.UTC().Format("2006-01-02 15:04:05"))
+	form.Set("bandid", strconv.Itoa(bandID))
+	api := strings.TrimSpace(cfg.APIKey)
+	if api == "" {
+		api = clublogAppAPIKey
+	}
+	form.Set("api", api)
+
+	body, err := postForm(ctx, client, clublogDeleteURL, form, 20*time.Second)
+	if err != nil {
+		return "", fmt.Errorf("clublog: %w", err)
+	}
+	msg := strings.TrimSpace(body)
+	LogSink("clublog: DELETE raw response: %s", msg)
+	// "QSO Not Deleted" means no record matched. That is not an error worth
+	// stopping for — the QSO is going away locally regardless, and a QSO absent
+	// from Club Log is the state being asked for.
+	return msg, nil
+}
+
+// clublogBandID maps an ADIF band name to Club Log's band number.
+//
+// The list is Club Log's own, and it is deliberately NOT derived from the
+// frequency: Club Log accepts these values and no others, so a band outside it
+// must be reported rather than approximated to a neighbour.
+func clublogBandID(band string) (int, bool) {
+	switch strings.ToLower(strings.TrimSpace(band)) {
+	case "160m":
+		return 160, true
+	case "80m":
+		return 80, true
+	case "60m":
+		return 60, true
+	case "40m":
+		return 40, true
+	case "30m":
+		return 30, true
+	case "20m":
+		return 20, true
+	case "17m":
+		return 17, true
+	case "15m":
+		return 15, true
+	case "12m":
+		return 12, true
+	case "10m":
+		return 10, true
+	case "6m":
+		return 6, true
+	case "4m":
+		return 4, true
+	case "2m":
+		return 2, true
+	case "70cm":
+		return 70, true
+	case "23cm":
+		return 23, true
+	case "13cm":
+		return 13, true
+	}
+	return 0, false
+}
+
+// postForm is the shared request/read for both deletes.
+func postForm(ctx context.Context, client *http.Client, endpoint string, form url.Values, timeout time.Duration) (string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, strings.NewReader(form.Encode()))
+	if err != nil {
+		return "", fmt.Errorf("build request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", clublogUserAgent)
+	if client == nil {
+		client = &http.Client{Timeout: timeout}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
+	if err != nil {
+		return "", fmt.Errorf("read response: %w", err)
+	}
+	b := string(raw)
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("http %d: %s", resp.StatusCode, strings.TrimSpace(b))
+	}
+	return b, nil
+}

internal/extsvc/delete_test.go

@@ -0,0 +1,32 @@
+package extsvc
+
+import "testing"
+
+// Club Log matches a deletion on callsign, exact time and BAND NUMBER. A band
+// that maps to the wrong number does not fail — it points the delete at a
+// different QSO, or at nothing, silently. So the table is pinned.
+func TestClublogBandID(t *testing.T) {
+	for _, c := range []struct {
+		band string
+		want int
+	}{
+		{"160m", 160}, {"80m", 80}, {"60m", 60}, {"40m", 40}, {"30m", 30},
+		{"20m", 20}, {"17m", 17}, {"15m", 15}, {"12m", 12}, {"10m", 10},
+		{"6m", 6}, {"4m", 4}, {"2m", 2},
+		{"70cm", 70}, {"23cm", 23}, {"13cm", 13},
+		{"20M", 20}, {" 20m ", 20}, // ADIF case and stray spaces
+	} {
+		got, ok := clublogBandID(c.band)
+		if !ok || got != c.want {
+			t.Errorf("clublogBandID(%q) = %d,%v — want %d", c.band, got, ok, c.want)
+		}
+	}
+
+	// Bands Club Log does not accept must be REFUSED, never approximated to a
+	// neighbour: 6 cm silently becoming 13 cm would delete somebody else's QSO.
+	for _, bad := range []string{"", "6cm", "3cm", "2200m", "630m", "9cm", "banana"} {
+		if id, ok := clublogBandID(bad); ok {
+			t.Errorf("clublogBandID(%q) accepted as %d — it is not a Club Log band", bad, id)
+		}
+	}
+}

internal/extsvc/extsvc.go

@@ -128,6 +128,13 @@ type ExternalServices struct {
 	HRDLog   ServiceConfig `json:"hrdlog"`
 	EQSL     ServiceConfig `json:"eqsl"`
 	Cloudlog ServiceConfig `json:"cloudlog"`
+
+	// DeleteRemote asks OpsLog to withdraw a QSO from QRZ.com and Club Log when
+	// it is deleted locally. Off unless the operator turns it on: neither
+	// service can undo it, and a local delete is not always meant to reach the
+	// world — a duplicate cleared from a contest log was never meant to be a
+	// statement about the DX's log.
+	DeleteRemote bool `json:"delete_remote"`
 }
 
 // UploadResult is the outcome of a single upload attempt.