rouggy/OpsLog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 7 Wiki Activity

feat: added support for eQSL

Browse Source
This commit is contained in:
Gregory Salaun
2026-06-18 14:56:13 +02:00
parent cdd71b17c8
commit dd2deee939
10 changed files with 351 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app.go
+55 -1
View File
@@ -195,6 +195,12 @@ const (
keyExtHRDLogAutoUpload = "extsvc.hrdlog.auto_upload"
keyExtHRDLogUploadMode = "extsvc.hrdlog.upload_mode"
keyExtEQSLUsername = "extsvc.eqsl.username"
keyExtEQSLPassword = "extsvc.eqsl.password"
keyExtEQSLQTHNick = "extsvc.eqsl.qth_nickname"
keyExtEQSLAutoUpload = "extsvc.eqsl.auto_upload"
keyExtEQSLUploadMode = "extsvc.eqsl.upload_mode"
keyExtPotaToken = "extsvc.pota.token" // pota.app session token for hunter-log sync
keyExtLoTWTQSLPath = "extsvc.lotw.tqsl_path"
@@ -4873,7 +4879,8 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
keyExtLoTWUploadFlag, keyExtLoTWUploadFlags, keyExtLoTWWriteLog,
keyExtLoTWAutoUpload, keyExtLoTWUploadMode,
keyExtLoTWUsername, keyExtLoTWWebPassword,
keyExtHRDLogCallsign, keyExtHRDLogCode, keyExtHRDLogAutoUpload, keyExtHRDLogUploadMode)
keyExtHRDLogCallsign, keyExtHRDLogCode, keyExtHRDLogAutoUpload, keyExtHRDLogUploadMode,
keyExtEQSLUsername, keyExtEQSLPassword, keyExtEQSLQTHNick, keyExtEQSLAutoUpload, keyExtEQSLUploadMode)
if err != nil {
return out
}
@@ -4930,6 +4937,19 @@ func (a *App) loadExternalServices() extsvc.ExternalServices {
out.HRDLog.Callsign = p.Callsign
}
}
out.EQSL = extsvc.ServiceConfig{
Username: m[keyExtEQSLUsername],
Password: m[keyExtEQSLPassword],
QTHNickname: m[keyExtEQSLQTHNick],
AutoUpload: m[keyExtEQSLAutoUpload] == "1",
UploadMode: extsvc.UploadMode(m[keyExtEQSLUploadMode]),
}
// Default the eQSL username to the active profile's call when unset.
if out.EQSL.Username == "" && a.profiles != nil {
if p, perr := a.profiles.Active(a.ctx); perr == nil {
out.EQSL.Username = p.Callsign
}
}
return out
}
@@ -4982,6 +5002,11 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
if cfg.HRDLog.AutoUpload {
hlAuto = "1"
}
eqMode := modeOf(cfg.EQSL.UploadMode)
eqAuto := "0"
if cfg.EQSL.AutoUpload {
eqAuto = "1"
}
scope := a.profileScope() // write under the active profile's prefix
for k, v := range map[string]string{
keyExtQRZAPIKey: strings.TrimSpace(cfg.QRZ.APIKey),
@@ -5011,6 +5036,12 @@ func (a *App) SaveExternalServices(cfg extsvc.ExternalServices) error {
keyExtHRDLogCode: strings.TrimSpace(cfg.HRDLog.Code),
keyExtHRDLogAutoUpload: hlAuto,
keyExtHRDLogUploadMode: hlMode,
keyExtEQSLUsername: strings.ToUpper(strings.TrimSpace(cfg.EQSL.Username)),
keyExtEQSLPassword: cfg.EQSL.Password,
keyExtEQSLQTHNick: strings.TrimSpace(cfg.EQSL.QTHNickname),
keyExtEQSLAutoUpload: eqAuto,
keyExtEQSLUploadMode: eqMode,
} {
if err := a.settings.Set(a.ctx, scope+k, v); err != nil {
return err
@@ -5044,6 +5075,11 @@ func (a *App) TestHRDLogUpload() (string, error) {
return extsvc.TestHRDLog(a.ctx, nil, a.loadExternalServices().HRDLog)
}
// TestEQSLUpload validates the eQSL credentials with a real (no-op) request.
func (a *App) TestEQSLUpload() (string, error) {
return extsvc.TestEQSL(a.ctx, nil, a.loadExternalServices().EQSL)
}
// ── QSL Manager (manual upload) ────────────────────────────────────────
// uploadColumnFor maps a service id to its QSO sent-status column.
@@ -5057,6 +5093,8 @@ func uploadColumnFor(service string) string {
return "lotw_sent"
case extsvc.ServiceHRDLog:
return "hrdlog_qso_upload_status"
case extsvc.ServiceEQSL:
return "eqsl_sent"
}
return ""
}
@@ -5197,6 +5235,8 @@ func (a *App) runManualUpload(svc extsvc.Service, ids []int64, cfg extsvc.Extern
res, err = extsvc.UploadQRZ(ctx, nil, cfg.QRZ.APIKey, rec)
case extsvc.ServiceHRDLog:
res, err = extsvc.UploadHRDLog(ctx, nil, cfg.HRDLog.Callsign, cfg.HRDLog.Code, rec)
case extsvc.ServiceEQSL:
res, err = extsvc.UploadEQSL(ctx, nil, cfg.EQSL.Username, cfg.EQSL.Password, cfg.EQSL.QTHNickname, rec)
default:
res, err = extsvc.UploadClublog(ctx, nil, cfg.Clublog, rec)
}
@@ -5770,6 +5810,8 @@ func (a *App) uploadOwnerCall(svc extsvc.Service) string {
owner = cfg.Clublog.Callsign
case extsvc.ServiceHRDLog:
owner = cfg.HRDLog.Callsign
case extsvc.ServiceEQSL:
owner = cfg.EQSL.Username
}
owner = strings.ToUpper(strings.TrimSpace(owner))
if owner == "" && a.profiles != nil {
@@ -5866,6 +5908,12 @@ func (a *App) extShouldUpload(svc extsvc.Service, id int64) bool {
return false
}
return true
case extsvc.ServiceEQSL:
if strings.EqualFold(q.EQSLSent, "Y") {
applog.Printf("extsvc: QSO %d not eligible for eqsl — EQSLSent already %q (set Confirmations default to N to upload)", id, q.EQSLSent)
return false
}
return true
case extsvc.ServiceLoTW:
for _, f := range a.loadExternalServices().LoTW.UploadFlags {
if strings.EqualFold(q.LOTWSent, f) {
@@ -5906,6 +5954,12 @@ func (a *App) markExtUploaded(svc extsvc.Service, id int64, logID string) {
applog.Printf("extsvc: mark hrdlog uploaded %d: %v", id, err)
}
}
case extsvc.ServiceEQSL:
if a.qso != nil {
if err := a.qso.MarkEQSLSent(a.ctx, id, date); err != nil {
applog.Printf("extsvc: mark eqsl sent %d: %v", id, err)
}
}
}
if a.ctx != nil {
wruntime.EventsEmit(a.ctx, "extsvc:uploaded", map[string]any{
app_secret.go
+1
View File
@@ -25,6 +25,7 @@ var sensitiveSettingKeys = map[string]bool{
keyExtLoTWKeyPassword: true,
keyExtLoTWWebPassword: true,
keyExtHRDLogCode: true,
keyExtEQSLPassword: true,
}
func isSensitiveSetting(key string) bool { return sensitiveSettingKeys[key] }
frontend/src/components/QSLManagerModal.tsx
+1
View File
@@ -24,6 +24,7 @@ const SERVICES = [
{ v: 'qrz', label: 'QRZ.com' },
{ v: 'clublog', label: 'Club Log' },
{ v: 'hrdlog', label: 'HRDLog.net' },
{ v: 'eqsl', label: 'eQSL.cc' },
{ v: 'lotw', label: 'LoTW' },
{ v: 'pota', label: 'POTA hunter log' },
{ v: 'paper', label: 'Paper QSL' },
frontend/src/components/SettingsModal.tsx
+93 -8
View File
@@ -31,7 +31,7 @@ import {
GetTelemetryEnabled, SetTelemetryEnabled,
GetLiveStatusEnabled, SetLiveStatusEnabled,
GetQSLDefaults, SaveQSLDefaults,
GetExternalServices, SaveExternalServices, TestQRZUpload, TestClublogUpload, TestHRDLogUpload,
GetExternalServices, SaveExternalServices, TestQRZUpload, TestClublogUpload, TestHRDLogUpload, TestEQSLUpload,
GetPOTAToken, SavePOTAToken,
TestLoTWUpload, ListTQSLStationLocations,
ComputeStationInfo,
@@ -747,21 +747,21 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
// wired today. upload_mode is 'immediate' | 'delayed' (per-service).
type ExtServiceCfg = {
api_key: string; email: string; username: string; password: string; callsign: string;
code: string;
code: string; qth_nickname: string;
force_station_callsign: string;
tqsl_path: string; station_location: string; key_password: string;
upload_flags: string[]; write_log: boolean;
auto_upload: boolean; upload_mode: string;
};
type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg };
type ExternalServices = { qrz: ExtServiceCfg; clublog: ExtServiceCfg; lotw: ExtServiceCfg; hrdlog: ExtServiceCfg; eqsl: ExtServiceCfg };
const emptyExtCfg = (): ExtServiceCfg => ({
api_key: '', email: '', username: '', password: '', callsign: '', code: '',
api_key: '', email: '', username: '', password: '', callsign: '', code: '', qth_nickname: '',
force_station_callsign: '', tqsl_path: '', station_location: '', key_password: '',
upload_flags: ['N', 'R'], write_log: false,
auto_upload: false, upload_mode: 'immediate',
});
const [extSvc, setExtSvc] = useState<ExternalServices>({
qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(),
qrz: emptyExtCfg(), clublog: emptyExtCfg(), lotw: emptyExtCfg(), hrdlog: emptyExtCfg(), eqsl: emptyExtCfg(),
});
const [qrzTest, setQrzTest] = useState<{ ok: boolean; msg: string } | null>(null);
const [qrzTesting, setQrzTesting] = useState(false);
@@ -771,10 +771,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
const [lotwTesting, setLotwTesting] = useState(false);
const [hrdlogTest, setHrdlogTest] = useState<{ ok: boolean; msg: string } | null>(null);
const [hrdlogTesting, setHrdlogTesting] = useState(false);
const [eqslTest, setEqslTest] = useState<{ ok: boolean; msg: string } | null>(null);
const [eqslTesting, setEqslTesting] = useState(false);
const [stationLocations, setStationLocations] = useState<string[]>([]);
// Active tab in the External Services panel — lifted here because
// PANELS[selected]() is called as a function, so panels can't hold hooks.
const [extSvcTab, setExtSvcTab] = useState<'qrz' | 'clublog' | 'hrdlog' | 'eqsl' | 'hamqth' | 'lotw' | 'pota'>('qrz');
const [extSvcTab, setExtSvcTab] = useState<'qrz' | 'clublog' | 'hrdlog' | 'eqsl' | 'lotw' | 'pota'>('qrz');
// POTA hunter-log sync (stamps pota_ref on local QSOs from your pota.app log).
const [potaToken, setPotaToken] = useState('');
const [potaBusy, setPotaBusy] = useState(false);
@@ -2607,8 +2609,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
{ k: 'qrz', label: 'QRZ.COM', ready: true },
{ k: 'clublog', label: 'CLUBLOG', ready: true },
{ k: 'hrdlog', label: 'HRDLOG.NET', ready: true },
{ k: 'eqsl', label: 'EQSL' },
{ k: 'hamqth', label: 'HAMQTH' },
{ k: 'eqsl', label: 'EQSL', ready: true },
{ k: 'lotw', label: 'LOTW', ready: true },
{ k: 'pota', label: 'POTA', ready: true },
];
@@ -2679,6 +2680,24 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
}
}
const eqsl = extSvc.eqsl;
const setEqsl = (patch: Partial<ExtServiceCfg>) =>
setExtSvc((s) => ({ ...s, eqsl: { ...s.eqsl, ...patch } }));
async function testEqsl() {
setEqslTesting(true);
setEqslTest(null);
try {
await SaveExternalServices(extSvc as any);
const msg = await TestEQSLUpload();
setEqslTest({ ok: true, msg });
} catch (e: any) {
setEqslTest({ ok: false, msg: String(e?.message ?? e) });
} finally {
setEqslTesting(false);
}
}
const lotw = extSvc.lotw;
const setLotw = (patch: Partial<ExtServiceCfg>) =>
setExtSvc((s) => ({ ...s, lotw: { ...s.lotw, ...patch } }));
@@ -2913,6 +2932,72 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
</div>
</div>
</div>
) : extSvcTab === 'eqsl' ? (
<div className="space-y-4 max-w-2xl">
<div className="grid grid-cols-[170px_1fr] gap-3 items-center">
<Label className="text-sm">Username (callsign)</Label>
<Input
value={eqsl.username}
onChange={(e) => setEqsl({ username: e.target.value.toUpperCase() })}
placeholder="your eQSL.cc login (callsign)"
className="font-mono text-xs"
/>
<Label className="text-sm">Password</Label>
<Input
type="password"
value={eqsl.password}
onChange={(e) => setEqsl({ password: e.target.value })}
placeholder="eQSL.cc account password"
className="text-xs"
/>
<Label className="text-sm">QTH nickname</Label>
<Input
value={eqsl.qth_nickname}
onChange={(e) => setEqsl({ qth_nickname: e.target.value })}
placeholder="optional — required only if your eQSL account has several QTHs"
className="text-xs"
/>
</div>
<div className="text-[10px] text-muted-foreground -mt-1">
The QTH nickname tells eQSL which location profile to file the QSO under. Leave blank if you have only one.
</div>
<div className="border-t border-border/60 pt-3 space-y-3">
<label className="flex items-center gap-2 text-sm cursor-pointer">
<Checkbox
checked={eqsl.auto_upload}
onCheckedChange={(c) => setEqsl({ auto_upload: !!c })}
/>
Automatic upload on new QSO
</label>
<div className="grid grid-cols-[170px_1fr] gap-3 items-center">
<Label className="text-sm">Upload timing</Label>
<Select
value={eqsl.upload_mode || 'immediate'}
onValueChange={(v) => setEqsl({ upload_mode: v })}
>
<SelectTrigger className="h-8 w-64"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="immediate">Immediate</SelectItem>
<SelectItem value="delayed">Delayed (1–2 min, lets you fix mistakes)</SelectItem>
<SelectItem value="on_close">On app close (batch)</SelectItem>
</SelectContent>
</Select>
</div>
<div className="flex items-center gap-3">
<Button variant="outline" size="sm" onClick={testEqsl} disabled={eqslTesting}>
<UploadCloud className="size-3.5" /> {eqslTesting ? 'Testing…' : 'Test connection'}
</Button>
{eqslTest && (
<span className={cn('text-xs', eqslTest.ok ? 'text-emerald-700' : 'text-rose-700')}>
{eqslTest.msg}
</span>
)}
</div>
</div>
</div>
) : extSvcTab === 'lotw' ? (
<div className="space-y-4 max-w-2xl">
<div className="grid grid-cols-[170px_1fr] gap-3 items-center">
frontend/wailsjs/go/main/App.d.ts
Vendored
+2
View File
@@ -471,6 +471,8 @@ export function SyncPOTAHunterLog(arg1:boolean,arg2:boolean):Promise<main.POTASy
export function TestClublogUpload():Promise<string>;
export function TestEQSLUpload():Promise<string>;
export function TestEmail(arg1:string):Promise<void>;
export function TestHRDLogUpload():Promise<string>;
frontend/wailsjs/go/main/App.js
+4
View File
@@ -914,6 +914,10 @@ export function TestClublogUpload() {
return window['go']['main']['App']['TestClublogUpload']();
}
export function TestEQSLUpload() {
return window['go']['main']['App']['TestEQSLUpload']();
}
export function TestEmail(arg1) {
return window['go']['main']['App']['TestEmail'](arg1);
}
frontend/wailsjs/go/models.ts
+4
View File
@@ -670,6 +670,7 @@ export namespace extsvc {
password: string;
callsign: string;
code: string;
qth_nickname: string;
force_station_callsign: string;
tqsl_path: string;
station_location: string;
@@ -691,6 +692,7 @@ export namespace extsvc {
this.password = source["password"];
this.callsign = source["callsign"];
this.code = source["code"];
this.qth_nickname = source["qth_nickname"];
this.force_station_callsign = source["force_station_callsign"];
this.tqsl_path = source["tqsl_path"];
this.station_location = source["station_location"];
@@ -706,6 +708,7 @@ export namespace extsvc {
clublog: ServiceConfig;
lotw: ServiceConfig;
hrdlog: ServiceConfig;
eqsl: ServiceConfig;
static createFrom(source: any = {}) {
return new ExternalServices(source);
@@ -717,6 +720,7 @@ export namespace extsvc {
this.clublog = this.convertValues(source["clublog"], ServiceConfig);
this.lotw = this.convertValues(source["lotw"], ServiceConfig);
this.hrdlog = this.convertValues(source["hrdlog"], ServiceConfig);
this.eqsl = this.convertValues(source["eqsl"], ServiceConfig);
}
convertValues(a: any, classs: any, asMap: boolean = false): any {
internal/extsvc/eqsl.go
+161
View File
@@ -0,0 +1,161 @@
package extsvc
import (
"context"
"fmt"
"io"
"net/http"
"net/url"
"regexp"
"strconv"
"strings"
"time"
)
// eqslImportURL is eQSL.cc's ADIF import endpoint. It accepts a form-encoded
// POST (or URL params) with the account credentials and the ADIF content.
const eqslImportURL = "https://www.eQSL.cc/qslcard/ImportADIF.cfm"
// eqslResultRe extracts "Result: X out of Y records added" from the reply.
var eqslResultRe = regexp.MustCompile(`(?i)result:\s*(\d+)\s+out of\s+(\d+)\s+records added`)
// eqslPost performs the import POST and returns the raw response body. eQSL
// replies HTTP 200 with a plain-text/HTML body for both success and errors;
// callers classify it via the markers below.
func eqslPost(ctx context.Context, client *http.Client, user, pswd, adif string) (string, error) {
form := url.Values{}
form.Set("EQSL_USER", user)
form.Set("EQSL_PSWD", pswd)
form.Set("ADIFData", adif)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, eqslImportURL, strings.NewReader(form.Encode()))
if err != nil {
return "", fmt.Errorf("eqsl: build request: %w", err)
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
if client == nil {
client = &http.Client{Timeout: 30 * time.Second}
}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("eqsl: request failed: %w", err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(io.LimitReader(resp.Body, 256*1024))
msg := strings.TrimSpace(string(body))
if resp.StatusCode != http.StatusOK {
if msg == "" {
msg = fmt.Sprintf("HTTP %d", resp.StatusCode)
}
return msg, fmt.Errorf("eqsl: http %d: %s", resp.StatusCode, msg)
}
return msg, nil
}
// authErrEQSL returns a reason when the response signals bad credentials, else
// "". eQSL replies "Error: No match on eQSL_User/eQSL_Pswd".
func authErrEQSL(body string) string {
if strings.Contains(strings.ToLower(body), "no match on eqsl") {
return "invalid username or password"
}
return ""
}
// eqslRecordWithNickname prepends the APP_EQSL_QTH_NICKNAME tag to an ADIF
// record when nick is set, so eQSL files the QSO under the right QTH profile
// (required when the account has more than one). ADIF field order is free, so
// prepending before the rest of the record is valid.
func eqslRecordWithNickname(record, nick string) string {
nick = strings.TrimSpace(nick)
if nick == "" {
return record
}
return fmt.Sprintf("<APP_EQSL_QTH_NICKNAME:%d>%s%s", len(nick), nick, record)
}
// UploadEQSL pushes one ADIF record to eQSL.cc for the given account. qthNick
// is the optional eQSL QTH nickname.
//
// eQSL replies with text: "Result: 1 out of 1 records added" on success,
// "Bad record: Duplicate" for an already-present QSO (treated as success so
// retries are idempotent), or "Error: No match on eQSL_User/eQSL_Pswd" for bad
// credentials.
func UploadEQSL(ctx context.Context, client *http.Client, user, pswd, qthNick, adifRecord string) (UploadResult, error) {
user = strings.ToUpper(strings.TrimSpace(user))
if user == "" {
return UploadResult{}, fmt.Errorf("eqsl: username (callsign) not set")
}
if strings.TrimSpace(pswd) == "" {
return UploadResult{}, fmt.Errorf("eqsl: password not set")
}
if strings.TrimSpace(adifRecord) == "" {
return UploadResult{}, fmt.Errorf("eqsl: empty adif record")
}
body, err := eqslPost(ctx, client, user, pswd, eqslRecordWithNickname(adifRecord, qthNick))
if err != nil {
return UploadResult{OK: false, Message: body}, err
}
b := strings.ToLower(body)
if reason := authErrEQSL(body); reason != "" {
return UploadResult{OK: false, Message: reason}, fmt.Errorf("eqsl: %s", reason)
}
if strings.Contains(b, "duplicate") {
return UploadResult{OK: true, Message: "already in logbook"}, nil
}
if m := eqslResultRe.FindStringSubmatch(body); m != nil {
added, _ := strconv.Atoi(m[1])
if added >= 1 {
return UploadResult{OK: true, Message: strings.TrimSpace(m[0])}, nil
}
// "0 out of N" — eQSL accepted nothing; surface why if it said so.
reason := eqslReason(body)
return UploadResult{OK: false, Message: reason}, fmt.Errorf("eqsl: upload failed: %s", reason)
}
reason := eqslReason(body)
return UploadResult{OK: false, Message: reason}, fmt.Errorf("eqsl: upload failed: %s", reason)
}
// eqslReason trims an eQSL reply to a short human-readable reason: the first
// "Error:" / "Warning:" / "Bad record:" line if present, else the whole body
// (capped), else a generic phrase.
func eqslReason(body string) string {
for _, line := range strings.Split(body, "\n") {
l := strings.TrimSpace(line)
ll := strings.ToLower(l)
if strings.HasPrefix(ll, "error:") || strings.HasPrefix(ll, "warning:") || strings.Contains(ll, "bad record") {
return l
}
}
b := strings.TrimSpace(body)
if b == "" {
return "upload rejected"
}
if len(b) > 200 {
b = b[:200]
}
return b
}
// TestEQSL validates the configured eQSL credentials with a REAL request: it
// posts an empty ADIF so nothing is inserted, then checks for the bad-login
// marker. Anything else means the credentials were accepted.
func TestEQSL(ctx context.Context, client *http.Client, cfg ServiceConfig) (string, error) {
user := strings.ToUpper(strings.TrimSpace(cfg.Username))
if user == "" {
return "", fmt.Errorf("eqsl: username (callsign) not set")
}
if strings.TrimSpace(cfg.Password) == "" {
return "", fmt.Errorf("eqsl: password not set")
}
body, err := eqslPost(ctx, client, user, cfg.Password, "")
if err != nil {
return "", err
}
if reason := authErrEQSL(body); reason != "" {
return "", fmt.Errorf("eqsl: %s", reason)
}
return fmt.Sprintf("Credentials accepted — %s", user), nil
}
internal/extsvc/extsvc.go
+5
View File
@@ -32,6 +32,7 @@ const (
ServiceClublog Service = "clublog" // Club Log real-time upload
ServiceLoTW Service = "lotw" // ARRL Logbook of The World (via TQSL)
ServiceHRDLog Service = "hrdlog" // HRDLog.net real-time upload
ServiceEQSL Service = "eqsl" // eQSL.cc ADIF upload
)
// UploadMode selects when an auto-upload fires after a QSO is saved.
@@ -67,6 +68,7 @@ type ServiceConfig struct {
Password string `json:"password"` // Club Log account / LoTW website password
Callsign string `json:"callsign"` // Club Log / HRDLog logbook (owner) callsign
Code string `json:"code"` // HRDLog: account upload code
QTHNickname string `json:"qth_nickname"` // eQSL: QTH nickname (when the account has several)
ForceStationCallsign string `json:"force_station_callsign"` // QRZ + LoTW: override STATION_CALLSIGN
TQSLPath string `json:"tqsl_path"` // LoTW: path to tqsl.exe
StationLocation string `json:"station_location"` // LoTW: TQSL Station Location name
@@ -84,6 +86,8 @@ func (c ServiceConfig) normalised() ServiceConfig {
c.Email = strings.TrimSpace(c.Email)
c.Callsign = strings.ToUpper(strings.TrimSpace(c.Callsign))
c.Code = strings.TrimSpace(c.Code)
c.Username = strings.TrimSpace(c.Username)
c.QTHNickname = strings.TrimSpace(c.QTHNickname)
c.ForceStationCallsign = strings.ToUpper(strings.TrimSpace(c.ForceStationCallsign))
c.TQSLPath = strings.TrimSpace(c.TQSLPath)
c.StationLocation = strings.TrimSpace(c.StationLocation)
@@ -115,6 +119,7 @@ type ExternalServices struct {
Clublog ServiceConfig `json:"clublog"`
LoTW ServiceConfig `json:"lotw"`
HRDLog ServiceConfig `json:"hrdlog"`
EQSL ServiceConfig `json:"eqsl"`
}
// UploadResult is the outcome of a single upload attempt.
internal/extsvc/manager.go
+25
View File
@@ -116,6 +116,7 @@ func (m *Manager) SetConfig(cfg ExternalServices) {
cfg.Clublog = cfg.Clublog.normalised()
cfg.LoTW = cfg.LoTW.normalised()
cfg.HRDLog = cfg.HRDLog.normalised()
cfg.EQSL = cfg.EQSL.normalised()
m.cfg = cfg
}
@@ -156,6 +157,10 @@ func (m *Manager) OnQSOLogged(id int64) {
if h := cfg.HRDLog; h.AutoUpload && h.Callsign != "" && h.Code != "" {
m.route(ServiceHRDLog, id, h)
}
// eQSL — needs the account username (callsign) + password.
if e := cfg.EQSL; e.AutoUpload && e.Username != "" && e.Password != "" {
m.route(ServiceEQSL, id, e)
}
}
// route sends a logged QSO down the configured timing path: queue it for the
@@ -198,6 +203,9 @@ func (m *Manager) onCloseServices() []Service {
if h := cfg.HRDLog; h.AutoUpload && h.UploadMode == ModeOnClose && h.Callsign != "" && h.Code != "" {
out = append(out, ServiceHRDLog)
}
if e := cfg.EQSL; e.AutoUpload && e.UploadMode == ModeOnClose && e.Username != "" && e.Password != "" {
out = append(out, ServiceEQSL)
}
return out
}
@@ -251,6 +259,12 @@ func (m *Manager) FlushOnClose() int {
uploaded++
}
}
case ServiceEQSL:
for _, id := range ids {
if m.upload(svc, id, cfg.EQSL) {
uploaded++
}
}
}
}
return uploaded
@@ -319,6 +333,8 @@ func (m *Manager) upload(svc Service, id int64, cfg ServiceConfig) bool {
owner = cfg.ForceStationCallsign
case ServiceClublog, ServiceHRDLog:
owner = cfg.Callsign
case ServiceEQSL:
owner = cfg.Username
}
if owner != "" && m.deps.StationCallOf != nil {
qcall := m.deps.StationCallOf(id)
@@ -374,6 +390,15 @@ func (m *Manager) upload(svc Service, id int64, cfg ServiceConfig) bool {
return false
}
res, err = UploadHRDLog(ctx, m.deps.Client, cfg.Callsign, cfg.Code, record)
case ServiceEQSL:
// eQSL keeps the QSO's own station call; the account is identified by
// the Username + Password, with an optional QTH nickname.
record, ok := m.deps.BuildADIF(id, "")
if !ok {
m.logf("extsvc: %s upload of QSO %d skipped (no record)", svc, id)
return false
}
res, err = UploadEQSL(ctx, m.deps.Client, cfg.Username, cfg.Password, cfg.QTHNickname, record)
default:
return false
}