199 lines
4.9 KiB
Go
199 lines
4.9 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
telnetAddress = "dxc.nc7j.com:23" // Remplace par l'adresse et le port de ton serveur Telnet
|
|
gotifyURL = "https://gotify.rouggy.com/message" // Remplace par l'URL de ton serveur Gotify
|
|
gotifyToken = "ALaGS4MVMWTEMcP" // Remplace par le token de ton application Gotify
|
|
identificationMessage = "XV9Q" // Message d'identification à envoyer au serveur Telnet
|
|
)
|
|
|
|
var DX = readDXExpeFile("dx.txt")
|
|
|
|
type ClusterMessage struct {
|
|
From string
|
|
DX string
|
|
Freq string
|
|
Mode string
|
|
Report string
|
|
Time string
|
|
}
|
|
|
|
// Message structure for Gotify
|
|
type GotifyMessage struct {
|
|
Title string `json:"title"`
|
|
Message string `json:"message"`
|
|
Priority int `json:"priority"`
|
|
}
|
|
|
|
func readDXExpeFile(filename string) string {
|
|
file, err := os.Open(filename)
|
|
if err != nil {
|
|
fmt.Println("Error while opening file", err)
|
|
}
|
|
defer file.Close()
|
|
|
|
// Lire tout le contenu du fichier
|
|
content, err := io.ReadAll(file)
|
|
if err != nil {
|
|
fmt.Println("Error while reading the file", err)
|
|
}
|
|
log.Println("DX Expe file has been loaded properly")
|
|
return string(content)
|
|
}
|
|
|
|
// Function to send message to Gotify
|
|
func sendToGotify(title string, sMess ClusterMessage, priority int) {
|
|
|
|
message := fmt.Sprintf("DX: %s\nFrom: %s\nFreq: %s\nMode: %s\nReport: %s\nTime: %s", sMess.DX, sMess.From, sMess.Freq, sMess.Mode, sMess.Report, sMess.Time)
|
|
|
|
gotifyMsg := GotifyMessage{
|
|
Title: title,
|
|
Message: message,
|
|
Priority: priority,
|
|
}
|
|
|
|
jsonData, err := json.Marshal(gotifyMsg)
|
|
if err != nil {
|
|
log.Println("Error marshaling JSON:", err)
|
|
return
|
|
}
|
|
|
|
req, err := http.NewRequest("POST", gotifyURL, bytes.NewBuffer(jsonData))
|
|
if err != nil {
|
|
log.Println("Error creating request:", err)
|
|
return
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Add("Authorization", "Bearer ALaGS4MVMWTEMcP")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
log.Println("Error sending request:", err)
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
log.Println("Gotify server returned non-OK status:", resp.Status)
|
|
} else {
|
|
log.Println("message successfully sent to Gotify")
|
|
}
|
|
|
|
}
|
|
|
|
func SanitizeClusterMessage(message string) ClusterMessage {
|
|
r := regexp.MustCompile(`DX\sde\s([A-Z0-9]+)[-#:]+[\s]+([0-9]+.[0-9])[\s]+([^\s]+)[\s]+([A-Z]+[0-9])\s+(.*dB).*(.{4})Z$`)
|
|
matches := r.FindStringSubmatch(message)
|
|
|
|
mes := ClusterMessage{}
|
|
|
|
if len(matches) > 0 {
|
|
timeLayout := "1504"
|
|
formatedTime, _ := time.Parse(timeLayout, matches[6])
|
|
formatedTime = formatedTime.Add(time.Hour * time.Duration(7))
|
|
newTime := formatedTime.Format("15:04")
|
|
|
|
mes := ClusterMessage{
|
|
From: matches[1],
|
|
Freq: matches[2],
|
|
DX: matches[3],
|
|
Mode: matches[4],
|
|
Report: matches[5],
|
|
Time: newTime,
|
|
}
|
|
|
|
return mes
|
|
}
|
|
|
|
return mes
|
|
}
|
|
|
|
func main() {
|
|
fmt.Println("PushDXCluster v0.1")
|
|
for {
|
|
// Connect to the Telnet server
|
|
conn, err := net.Dial("tcp", "ve7cc.net:23")
|
|
if err != nil {
|
|
log.Printf("Failed to connect to Telnet server: %v", err)
|
|
time.Sleep(5 * time.Second) // Wait before retrying
|
|
continue
|
|
}
|
|
|
|
log.Println("Connected to Telnet server")
|
|
time.Sleep(3 * time.Second)
|
|
|
|
// Send identification message
|
|
_, err = conn.Write([]byte(identificationMessage + "\n"))
|
|
if err != nil {
|
|
log.Printf("Failed to send identification message: %v", err)
|
|
conn.Close()
|
|
time.Sleep(5 * time.Second) // Wait before retrying
|
|
continue
|
|
}
|
|
log.Println("Identification message sent")
|
|
|
|
time.Sleep(3 * time.Second)
|
|
|
|
_, err = conn.Write([]byte("set/ft8" + "\n"))
|
|
|
|
if err != nil {
|
|
log.Printf("Failed to send FT8 message: %v", err)
|
|
conn.Close()
|
|
time.Sleep(5 * time.Second) // Wait before retrying
|
|
continue
|
|
}
|
|
log.Println("Set FT8 message sent")
|
|
|
|
time.Sleep(3 * time.Second)
|
|
|
|
_, err = conn.Write([]byte("SET/FILTER DOC/PASS 3W" + "\n"))
|
|
|
|
if err != nil {
|
|
log.Printf("Failed to send Filter message: %v", err)
|
|
conn.Close()
|
|
time.Sleep(5 * time.Second) // Wait before retrying
|
|
continue
|
|
}
|
|
log.Println("Set filter Vietnam message sent")
|
|
|
|
// Create a buffered reader to read from the Telnet server
|
|
reader := bufio.NewReader(conn)
|
|
|
|
// Loop to read from the Telnet server
|
|
for {
|
|
message, err := reader.ReadString('\n')
|
|
if err != nil {
|
|
log.Printf("Error reading from Telnet server: %v", err)
|
|
conn.Close()
|
|
break
|
|
}
|
|
message = strings.TrimSpace(message)
|
|
sMess := SanitizeClusterMessage(message)
|
|
log.Printf("Received message: %s", message)
|
|
if sMess.DX != "" && sMess.From == "XV9Q" && strings.Contains(DX, sMess.DX) {
|
|
sendToGotify("Spot", sMess, 5)
|
|
}
|
|
|
|
}
|
|
|
|
log.Println("Disconnected from Telnet server, reconnecting...")
|
|
time.Sleep(5 * time.Second) // Wait before reconnecting
|
|
}
|
|
}
|