Revert "cleanup v2"

This reverts commit 8b82578809.

agent/internal/app/monitor.go

@@ -0,0 +1,130 @@
+package app
+
+import (
+	"context"
+	"crypto/x509"
+	"database/sql"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/corecontrol/agent/internal/models"
+	"github.com/corecontrol/agent/internal/notifications"
+)
+
+// MonitorApplications checks and updates the status of all applications
+func MonitorApplications(db *sql.DB, client *http.Client, apps []models.Application, notifSender *notifications.NotificationSender) {
+	var notificationTemplate string
+	err := db.QueryRow("SELECT notification_text_application FROM settings LIMIT 1").Scan(&notificationTemplate)
+	if err != nil || notificationTemplate == "" {
+		notificationTemplate = "The application !name (!url) went !status!"
+	}
+
+	for _, app := range apps {
+		logPrefix := fmt.Sprintf("[App %s (%s)]", app.Name, app.PublicURL)
+		fmt.Printf("%s Checking...\n", logPrefix)
+
+		// Determine which URL to use for monitoring
+		checkURL := app.PublicURL
+		if app.UptimeCheckURL != "" {
+			checkURL = app.UptimeCheckURL
+			fmt.Printf("%s Using custom uptime check URL: %s\n", logPrefix, checkURL)
+		}
+
+		parsedURL, parseErr := url.Parse(checkURL)
+		if parseErr != nil {
+			fmt.Printf("%s Invalid URL: %v\n", logPrefix, parseErr)
+			continue
+		}
+
+		hostIsIP := isIPAddress(parsedURL.Hostname())
+		var isOnline bool
+
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		req, err := http.NewRequestWithContext(ctx, "GET", checkURL, nil)
+		if err != nil {
+			fmt.Printf("%s Request creation failed: %v\n", logPrefix, err)
+			continue
+		}
+
+		resp, err := client.Do(req)
+		if err == nil {
+			defer resp.Body.Close()
+			isOnline = resp.StatusCode >= 200 && resp.StatusCode < 400
+			fmt.Printf("%s Response status: %d\n", logPrefix, resp.StatusCode)
+		} else {
+			fmt.Printf("%s Connection error: %v\n", logPrefix, err)
+
+			if hostIsIP {
+				var urlErr *url.Error
+				if errors.As(err, &urlErr) {
+					var certErr x509.HostnameError
+					var unknownAuthErr x509.UnknownAuthorityError
+					if errors.As(urlErr.Err, &certErr) || errors.As(urlErr.Err, &unknownAuthErr) {
+						fmt.Printf("%s Ignoring TLS error for IP, marking as online\n", logPrefix)
+						isOnline = true
+					}
+				}
+			}
+		}
+
+		if isOnline != app.Online {
+			status := "offline"
+			if isOnline {
+				status = "online"
+			}
+
+			message := strings.ReplaceAll(notificationTemplate, "!name", app.Name)
+			message = strings.ReplaceAll(message, "!url", app.PublicURL)
+			message = strings.ReplaceAll(message, "!status", status)
+
+			notifSender.SendNotifications(message)
+		}
+
+		// Update application status in database
+		updateApplicationStatus(db, app.ID, isOnline)
+
+		// Add entry to uptime history
+		addUptimeHistoryEntry(db, app.ID, isOnline)
+	}
+}
+
+// Helper function to update application status
+func updateApplicationStatus(db *sql.DB, appID int, online bool) {
+	dbCtx, dbCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer dbCancel()
+
+	_, err := db.ExecContext(dbCtx,
+		`UPDATE application SET online = $1 WHERE id = $2`,
+		online, appID,
+	)
+	if err != nil {
+		fmt.Printf("DB update failed for app ID %d: %v\n", appID, err)
+	}
+}
+
+// Helper function to add uptime history entry
+func addUptimeHistoryEntry(db *sql.DB, appID int, online bool) {
+	dbCtx, dbCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer dbCancel()
+
+	_, err := db.ExecContext(dbCtx,
+		`INSERT INTO uptime_history("applicationId", online, "createdAt") VALUES ($1, $2, now())`,
+		appID, online,
+	)
+	if err != nil {
+		fmt.Printf("History insert failed for app ID %d: %v\n", appID, err)
+	}
+}
+
+// Helper function to check if a host is an IP address
+func isIPAddress(host string) bool {
+	ip := net.ParseIP(host)
+	return ip != nil
+}

agent/internal/database/database.go

@@ -0,0 +1,198 @@
+package database
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/corecontrol/agent/internal/models"
+
+	_ "github.com/jackc/pgx/v4/stdlib"
+	"github.com/joho/godotenv"
+)
+
+// InitDB initializes the database connection
+func InitDB() (*sql.DB, error) {
+	// Load environment variables
+	if err := godotenv.Load(); err != nil {
+		fmt.Println("No env vars found")
+	}
+
+	dbURL := os.Getenv("DATABASE_URL")
+	if dbURL == "" {
+		return nil, fmt.Errorf("DATABASE_URL not set")
+	}
+
+	db, err := sql.Open("pgx", dbURL)
+	if err != nil {
+		return nil, fmt.Errorf("database connection failed: %v", err)
+	}
+
+	return db, nil
+}
+
+// GetApplications fetches all applications with public URLs
+func GetApplications(db *sql.DB) ([]models.Application, error) {
+	rows, err := db.Query(
+		`SELECT id, name, "publicURL", online, "uptimecheckUrl" FROM application WHERE "publicURL" IS NOT NULL`,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching applications: %v", err)
+	}
+	defer rows.Close()
+
+	var apps []models.Application
+	for rows.Next() {
+		var app models.Application
+		if err := rows.Scan(&app.ID, &app.Name, &app.PublicURL, &app.Online, &app.UptimeCheckURL); err != nil {
+			fmt.Printf("Error scanning row: %v\n", err)
+			continue
+		}
+		apps = append(apps, app)
+	}
+	return apps, nil
+}
+
+// GetServers fetches all servers with monitoring enabled
+func GetServers(db *sql.DB) ([]models.Server, error) {
+	rows, err := db.Query(
+		`SELECT id, name, monitoring, "monitoringURL", online, "cpuUsage", "ramUsage", "diskUsage" 
+         FROM server WHERE monitoring = true`,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching servers: %v", err)
+	}
+	defer rows.Close()
+
+	var servers []models.Server
+	for rows.Next() {
+		var server models.Server
+		if err := rows.Scan(
+			&server.ID, &server.Name, &server.Monitoring, &server.MonitoringURL,
+			&server.Online, &server.CpuUsage, &server.RamUsage, &server.DiskUsage,
+		); err != nil {
+			fmt.Printf("Error scanning server row: %v\n", err)
+			continue
+		}
+		servers = append(servers, server)
+	}
+	return servers, nil
+}
+
+// LoadNotifications loads all enabled notifications
+func LoadNotifications(db *sql.DB) ([]models.Notification, error) {
+	rows, err := db.Query(
+		`SELECT id, enabled, type, "smtpHost", "smtpPort", "smtpFrom", "smtpUser", "smtpPass", "smtpSecure", "smtpTo",
+		       "telegramChatId", "telegramToken", "discordWebhook", "gotifyUrl", "gotifyToken", "ntfyUrl", "ntfyToken",
+			   "pushoverUrl", "pushoverToken", "pushoverUser", "echobellURL"
+		FROM notification
+		WHERE enabled = true`,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var configs []models.Notification
+	for rows.Next() {
+		var n models.Notification
+		if err := rows.Scan(
+			&n.ID, &n.Enabled, &n.Type,
+			&n.SMTPHost, &n.SMTPPort, &n.SMTPFrom, &n.SMTPUser, &n.SMTPPass, &n.SMTPSecure, &n.SMTPTo,
+			&n.TelegramChatID, &n.TelegramToken, &n.DiscordWebhook,
+			&n.GotifyUrl, &n.GotifyToken, &n.NtfyUrl, &n.NtfyToken,
+			&n.PushoverUrl, &n.PushoverToken, &n.PushoverUser, &n.EchobellURL,
+		); err != nil {
+			fmt.Printf("Error scanning notification: %v\n", err)
+			continue
+		}
+		configs = append(configs, n)
+	}
+	return configs, nil
+}
+
+// DeleteOldEntries removes entries older than 30 days
+func DeleteOldEntries(db *sql.DB) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// Delete old uptime history entries
+	res, err := db.ExecContext(ctx,
+		`DELETE FROM uptime_history WHERE "createdAt" < now() - interval '30 days'`,
+	)
+	if err != nil {
+		return err
+	}
+	affected, _ := res.RowsAffected()
+	fmt.Printf("Deleted %d old entries from uptime_history\n", affected)
+
+	// Delete old server history entries
+	res, err = db.ExecContext(ctx,
+		`DELETE FROM server_history WHERE "createdAt" < now() - interval '30 days'`,
+	)
+	if err != nil {
+		return err
+	}
+	affected, _ = res.RowsAffected()
+	fmt.Printf("Deleted %d old entries from server_history\n", affected)
+
+	return nil
+}
+
+// UpdateServerStatus updates a server's status and metrics
+func UpdateServerStatus(db *sql.DB, serverID int, online bool, cpuUsage, ramUsage, diskUsage float64, uptime string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	_, err := db.ExecContext(ctx,
+		`UPDATE server SET online = $1, "cpuUsage" = $2::float8, "ramUsage" = $3::float8, "diskUsage" = $4::float8, "uptime" = $5
+		 WHERE id = $6`,
+		online, cpuUsage, ramUsage, diskUsage, uptime, serverID,
+	)
+	return err
+}
+
+// CheckAndSendTestNotifications checks for and processes test notifications
+func CheckAndSendTestNotifications(db *sql.DB, notifications []models.Notification, sendFunc func(models.Notification, string)) {
+	// Query for test notifications
+	rows, err := db.Query(`SELECT tn.id, tn."notificationId" FROM test_notification tn`)
+	if err != nil {
+		fmt.Printf("Error fetching test notifications: %v\n", err)
+		return
+	}
+	defer rows.Close()
+
+	// Process each test notification
+	var testIds []int
+	for rows.Next() {
+		var id, notificationId int
+		if err := rows.Scan(&id, &notificationId); err != nil {
+			fmt.Printf("Error scanning test notification: %v\n", err)
+			continue
+		}
+
+		// Add to list of IDs to delete
+		testIds = append(testIds, id)
+
+		// Find the notification configuration
+		for _, n := range notifications {
+			if n.ID == notificationId {
+				// Send test notification
+				fmt.Printf("Sending test notification to notification ID %d\n", notificationId)
+				sendFunc(n, "Test notification from CoreControl")
+			}
+		}
+	}
+
+	// Delete processed test notifications
+	if len(testIds) > 0 {
+		for _, id := range testIds {
+			_, err := db.Exec(`DELETE FROM test_notification WHERE id = $1`, id)
+			if err != nil {
+				fmt.Printf("Error deleting test notification (ID: %d): %v\n", id, err)
+			}
+		}
+	}
+}

agent/internal/models/models.go

@@ -0,0 +1,98 @@
+package models
+
+import (
+	"database/sql"
+)
+
+type Application struct {
+	ID             int
+	Name           string
+	PublicURL      string
+	Online         bool
+	UptimeCheckURL string
+}
+
+type Server struct {
+	ID            int
+	Name          string
+	Monitoring    bool
+	MonitoringURL sql.NullString
+	Online        bool
+	CpuUsage      sql.NullFloat64
+	RamUsage      sql.NullFloat64
+	DiskUsage     sql.NullFloat64
+	GpuUsage      sql.NullFloat64
+	Temp          sql.NullFloat64
+	Uptime        sql.NullString
+}
+
+type CPUResponse struct {
+	Total float64 `json:"total"`
+}
+
+type MemoryResponse struct {
+	Active    int64   `json:"active"`
+	Available int64   `json:"available"`
+	Buffers   int64   `json:"buffers"`
+	Cached    int64   `json:"cached"`
+	Free      int64   `json:"free"`
+	Inactive  int64   `json:"inactive"`
+	Percent   float64 `json:"percent"`
+	Shared    int64   `json:"shared"`
+	Total     int64   `json:"total"`
+	Used      int64   `json:"used"`
+}
+
+type FSResponse []struct {
+	DeviceName string  `json:"device_name"`
+	MntPoint   string  `json:"mnt_point"`
+	Percent    float64 `json:"percent"`
+}
+
+type UptimeResponse struct {
+	Value string `json:"value"`
+}
+
+type GPUResponse struct {
+	Proc float64 `json:"proc"`
+}
+
+type TemperatureResponse struct {
+	Composite []struct {
+		Label    string  `json:"label"`
+		Unit     string  `json:"unit"`
+		Value    float64 `json:"value"`
+		Warning  float64 `json:"warning"`
+		Critical float64 `json:"critical"`
+		Type     string  `json:"type"`
+		Key      string  `json:"key"`
+	} `json:"Composite"`
+}
+
+type TempResponse struct {
+	Value float64 `json:"value"`
+}
+
+type Notification struct {
+	ID             int
+	Enabled        bool
+	Type           string
+	SMTPHost       sql.NullString
+	SMTPPort       sql.NullInt64
+	SMTPFrom       sql.NullString
+	SMTPUser       sql.NullString
+	SMTPPass       sql.NullString
+	SMTPSecure     sql.NullBool
+	SMTPTo         sql.NullString
+	TelegramChatID sql.NullString
+	TelegramToken  sql.NullString
+	DiscordWebhook sql.NullString
+	GotifyUrl      sql.NullString
+	GotifyToken    sql.NullString
+	NtfyUrl        sql.NullString
+	NtfyToken      sql.NullString
+	PushoverUrl    sql.NullString
+	PushoverToken  sql.NullString
+	PushoverUser   sql.NullString
+	EchobellURL    sql.NullString
+}

agent/internal/notifications/notifications.go

@@ -0,0 +1,266 @@
+package notifications
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/corecontrol/agent/internal/models"
+
+	"gopkg.in/gomail.v2"
+)
+
+type NotificationSender struct {
+	notifications []models.Notification
+	notifMutex    sync.RWMutex
+}
+
+// NewNotificationSender creates a new notification sender
+func NewNotificationSender() *NotificationSender {
+	return &NotificationSender{
+		notifications: []models.Notification{},
+		notifMutex:    sync.RWMutex{},
+	}
+}
+
+// UpdateNotifications updates the stored notifications
+func (ns *NotificationSender) UpdateNotifications(notifs []models.Notification) {
+	ns.notifMutex.Lock()
+	defer ns.notifMutex.Unlock()
+
+	copyDst := make([]models.Notification, len(notifs))
+	copy(copyDst, notifs)
+	ns.notifications = copyDst
+}
+
+// GetNotifications returns a safe copy of current notifications
+func (ns *NotificationSender) GetNotifications() []models.Notification {
+	ns.notifMutex.RLock()
+	defer ns.notifMutex.RUnlock()
+
+	copyDst := make([]models.Notification, len(ns.notifications))
+	copy(copyDst, ns.notifications)
+	return copyDst
+}
+
+// SendNotifications sends a message to all configured notifications
+func (ns *NotificationSender) SendNotifications(message string) {
+	notifs := ns.GetNotifications()
+
+	for _, n := range notifs {
+		ns.SendSpecificNotification(n, message)
+	}
+}
+
+// SendSpecificNotification sends a message to a specific notification
+func (ns *NotificationSender) SendSpecificNotification(n models.Notification, message string) {
+	fmt.Println("Sending specific notification..." + n.Type)
+	switch n.Type {
+	case "smtp":
+		if n.SMTPHost.Valid && n.SMTPTo.Valid {
+			ns.sendEmail(n, message)
+		}
+	case "telegram":
+		if n.TelegramToken.Valid && n.TelegramChatID.Valid {
+			ns.sendTelegram(n, message)
+		}
+	case "discord":
+		if n.DiscordWebhook.Valid {
+			ns.sendDiscord(n, message)
+		}
+	case "gotify":
+		if n.GotifyUrl.Valid && n.GotifyToken.Valid {
+			ns.sendGotify(n, message)
+		}
+	case "ntfy":
+		if n.NtfyUrl.Valid && n.NtfyToken.Valid {
+			ns.sendNtfy(n, message)
+		}
+	case "pushover":
+		if n.PushoverUrl.Valid && n.PushoverToken.Valid && n.PushoverUser.Valid {
+			ns.sendPushover(n, message)
+		}
+	case "echobell":
+		if n.EchobellURL.Valid {
+			ns.sendEchobell(n, message)
+		}
+	}
+}
+
+// Helper function to check if a host is an IP address
+func (ns *NotificationSender) isIPAddress(host string) bool {
+	ip := net.ParseIP(host)
+	return ip != nil
+}
+
+// Individual notification methods
+func (ns *NotificationSender) sendEmail(n models.Notification, body string) {
+	// Initialize SMTP dialer with host, port, user, pass
+	d := gomail.NewDialer(
+		n.SMTPHost.String,
+		int(n.SMTPPort.Int64),
+		n.SMTPUser.String,
+		n.SMTPPass.String,
+	)
+	if n.SMTPSecure.Valid && n.SMTPSecure.Bool {
+		d.SSL = true
+	}
+
+	m := gomail.NewMessage()
+	m.SetHeader("From", n.SMTPFrom.String)
+	m.SetHeader("To", n.SMTPTo.String)
+	m.SetHeader("Subject", "Uptime Notification")
+	m.SetBody("text/plain", body)
+
+	if err := d.DialAndSend(m); err != nil {
+		fmt.Printf("Email send failed: %v\n", err)
+	}
+}
+
+func (ns *NotificationSender) sendTelegram(n models.Notification, message string) {
+	apiUrl := fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage?chat_id=%s&text=%s",
+		n.TelegramToken.String,
+		n.TelegramChatID.String,
+		message,
+	)
+	resp, err := http.Get(apiUrl)
+	if err != nil {
+		fmt.Printf("Telegram send failed: %v\n", err)
+		return
+	}
+	resp.Body.Close()
+}
+
+func (ns *NotificationSender) sendDiscord(n models.Notification, message string) {
+	payload := fmt.Sprintf(`{"content": "%s"}`, message)
+	req, err := http.NewRequest("POST", n.DiscordWebhook.String, strings.NewReader(payload))
+	if err != nil {
+		fmt.Printf("Discord request creation failed: %v\n", err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Printf("Discord send failed: %v\n", err)
+		return
+	}
+	resp.Body.Close()
+}
+
+func (ns *NotificationSender) sendGotify(n models.Notification, message string) {
+	baseURL := strings.TrimSuffix(n.GotifyUrl.String, "/")
+	targetURL := fmt.Sprintf("%s/message", baseURL)
+
+	form := url.Values{}
+	form.Add("message", message)
+	form.Add("priority", "5")
+
+	req, err := http.NewRequest("POST", targetURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		fmt.Printf("Gotify: ERROR creating request: %v\n", err)
+		return
+	}
+
+	req.Header.Set("X-Gotify-Key", n.GotifyToken.String)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Printf("Gotify: ERROR sending request: %v\n", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		fmt.Printf("Gotify: ERROR status code: %d\n", resp.StatusCode)
+	}
+}
+
+func (ns *NotificationSender) sendNtfy(n models.Notification, message string) {
+	fmt.Println("Sending Ntfy notification...")
+	baseURL := strings.TrimSuffix(n.NtfyUrl.String, "/")
+
+	// Don't append a topic to the URL - the URL itself should have the correct endpoint
+	requestURL := baseURL
+
+	// Send message directly as request body instead of JSON
+	req, err := http.NewRequest("POST", requestURL, strings.NewReader(message))
+	if err != nil {
+		fmt.Printf("Ntfy: ERROR creating request: %v\n", err)
+		return
+	}
+
+	if n.NtfyToken.Valid {
+		req.Header.Set("Authorization", "Bearer "+n.NtfyToken.String)
+	}
+	// Use text/plain instead of application/json
+	req.Header.Set("Content-Type", "text/plain")
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Printf("Ntfy: ERROR sending request: %v\n", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		fmt.Printf("Ntfy: ERROR status code: %d\n", resp.StatusCode)
+	}
+}
+
+func (ns *NotificationSender) sendPushover(n models.Notification, message string) {
+	form := url.Values{}
+	form.Add("token", n.PushoverToken.String)
+	form.Add("user", n.PushoverUser.String)
+	form.Add("message", message)
+
+	req, err := http.NewRequest("POST", n.PushoverUrl.String, strings.NewReader(form.Encode()))
+	if err != nil {
+		fmt.Printf("Pushover: ERROR creating request: %v\n", err)
+		return
+	}
+
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Printf("Pushover: ERROR sending request: %v\n", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		fmt.Printf("Pushover: ERROR status code: %d\n", resp.StatusCode)
+	}
+}
+
+func (ns *NotificationSender) sendEchobell(n models.Notification, message string) {
+	jsonData := fmt.Sprintf(`{"message": "%s"}`, message)
+	req, err := http.NewRequest("POST", n.EchobellURL.String, strings.NewReader(jsonData))
+	if err != nil {
+		fmt.Printf("Echobell: ERROR creating request: %v\n", err)
+		return
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Printf("Echobell: ERROR sending request: %v\n", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		fmt.Printf("Echobell: ERROR status code: %d\n", resp.StatusCode)
+	}
+}

agent/internal/server/monitor.go

@@ -0,0 +1,381 @@
+package server
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/corecontrol/agent/internal/models"
+	"github.com/corecontrol/agent/internal/notifications"
+)
+
+// notificationState tracks the last known status for each server
+var notificationState = struct {
+	sync.RWMutex
+	lastStatus map[int]bool
+}{
+	lastStatus: make(map[int]bool),
+}
+
+// MonitorServers checks and updates the status of all servers
+func MonitorServers(db *sql.DB, client *http.Client, servers []models.Server, notifSender *notifications.NotificationSender) {
+	var notificationTemplate string
+	err := db.QueryRow("SELECT notification_text_server FROM settings LIMIT 1").Scan(&notificationTemplate)
+	if err != nil || notificationTemplate == "" {
+		notificationTemplate = "The server !name is now !status!"
+	}
+
+	for _, server := range servers {
+		if !server.Monitoring || !server.MonitoringURL.Valid {
+			continue
+		}
+
+		logPrefix := fmt.Sprintf("[Server %s]", server.Name)
+		fmt.Printf("%s Checking...\n", logPrefix)
+
+		baseURL := strings.TrimSuffix(server.MonitoringURL.String, "/")
+		var cpuUsage, ramUsage, diskUsage, gpuUsage, temp float64
+		var online = true
+		var uptimeStr string
+
+		// Get CPU usage
+		online, cpuUsage = fetchCPUUsage(client, baseURL, logPrefix)
+		if !online {
+			updateServerStatus(db, server.ID, false, 0, 0, 0, 0, 0, "")
+			if shouldSendNotification(server.ID, online) {
+				sendStatusChangeNotification(server, online, notificationTemplate, notifSender)
+			}
+			addServerHistoryEntry(db, server.ID, false, 0, 0, 0, 0, 0)
+			continue
+		}
+
+		// Get uptime if server is online
+		uptimeStr = fetchUptime(client, baseURL, logPrefix)
+
+		// Get Memory usage
+		memOnline, memUsage := fetchMemoryUsage(client, baseURL, logPrefix)
+		if !memOnline {
+			online = false
+			updateServerStatus(db, server.ID, false, 0, 0, 0, 0, 0, "")
+			if shouldSendNotification(server.ID, online) {
+				sendStatusChangeNotification(server, online, notificationTemplate, notifSender)
+			}
+			addServerHistoryEntry(db, server.ID, false, 0, 0, 0, 0, 0)
+			continue
+		}
+		ramUsage = memUsage
+
+		// Get Disk usage
+		diskOnline, diskUsageVal := fetchDiskUsage(client, baseURL, logPrefix)
+		if !diskOnline {
+			online = false
+			updateServerStatus(db, server.ID, false, 0, 0, 0, 0, 0, "")
+			if shouldSendNotification(server.ID, online) {
+				sendStatusChangeNotification(server, online, notificationTemplate, notifSender)
+			}
+			addServerHistoryEntry(db, server.ID, false, 0, 0, 0, 0, 0)
+			continue
+		}
+		diskUsage = diskUsageVal
+
+		// Get GPU usage
+		_, gpuUsageVal := fetchGPUUsage(client, baseURL, logPrefix)
+		gpuUsage = gpuUsageVal
+
+		// Get Temperature
+		_, tempVal := fetchTemperature(client, baseURL, logPrefix)
+		temp = tempVal
+
+		// Check if status changed and send notification if needed
+		if online != server.Online && shouldSendNotification(server.ID, online) {
+			sendStatusChangeNotification(server, online, notificationTemplate, notifSender)
+		}
+
+		// Update server status with metrics
+		updateServerStatus(db, server.ID, online, cpuUsage, ramUsage, diskUsage, gpuUsage, temp, uptimeStr)
+
+		// Add entry to server history
+		addServerHistoryEntry(db, server.ID, online, cpuUsage, ramUsage, diskUsage, gpuUsage, temp)
+
+		fmt.Printf("%s Updated - CPU: %.2f%%, RAM: %.2f%%, Disk: %.2f%%, GPU: %.2f%%, Temp: %.2f°C, Uptime: %s\n",
+			logPrefix, cpuUsage, ramUsage, diskUsage, gpuUsage, temp, uptimeStr)
+	}
+}
+
+// shouldSendNotification checks if a notification should be sent based on status change
+func shouldSendNotification(serverID int, online bool) bool {
+	notificationState.Lock()
+	defer notificationState.Unlock()
+
+	lastStatus, exists := notificationState.lastStatus[serverID]
+
+	// If this is the first check or status has changed
+	if !exists || lastStatus != online {
+		notificationState.lastStatus[serverID] = online
+		return true
+	}
+
+	return false
+}
+
+// Helper function to fetch CPU usage
+func fetchCPUUsage(client *http.Client, baseURL, logPrefix string) (bool, float64) {
+	cpuResp, err := client.Get(fmt.Sprintf("%s/api/4/cpu", baseURL))
+	if err != nil {
+		fmt.Printf("%s CPU request failed: %v\n", logPrefix, err)
+		return false, 0
+	}
+	defer cpuResp.Body.Close()
+
+	if cpuResp.StatusCode != http.StatusOK {
+		fmt.Printf("%s Bad CPU status code: %d\n", logPrefix, cpuResp.StatusCode)
+		return false, 0
+	}
+
+	var cpuData models.CPUResponse
+	if err := json.NewDecoder(cpuResp.Body).Decode(&cpuData); err != nil {
+		fmt.Printf("%s Failed to parse CPU JSON: %v\n", logPrefix, err)
+		return false, 0
+	}
+
+	return true, cpuData.Total
+}
+
+// Helper function to fetch memory usage
+func fetchMemoryUsage(client *http.Client, baseURL, logPrefix string) (bool, float64) {
+	memResp, err := client.Get(fmt.Sprintf("%s/api/4/mem", baseURL))
+	if err != nil {
+		fmt.Printf("%s Memory request failed: %v\n", logPrefix, err)
+		return false, 0
+	}
+	defer memResp.Body.Close()
+
+	if memResp.StatusCode != http.StatusOK {
+		fmt.Printf("%s Bad memory status code: %d\n", logPrefix, memResp.StatusCode)
+		return false, 0
+	}
+
+	var memData models.MemoryResponse
+	if err := json.NewDecoder(memResp.Body).Decode(&memData); err != nil {
+		fmt.Printf("%s Failed to parse memory JSON: %v\n", logPrefix, err)
+		return false, 0
+	}
+
+	return true, memData.Percent
+}
+
+// Helper function to fetch disk usage
+func fetchDiskUsage(client *http.Client, baseURL, logPrefix string) (bool, float64) {
+	fsResp, err := client.Get(fmt.Sprintf("%s/api/4/fs", baseURL))
+	if err != nil {
+		fmt.Printf("%s Filesystem request failed: %v\n", logPrefix, err)
+		return false, 0
+	}
+	defer fsResp.Body.Close()
+
+	if fsResp.StatusCode != http.StatusOK {
+		fmt.Printf("%s Bad filesystem status code: %d\n", logPrefix, fsResp.StatusCode)
+		return false, 0
+	}
+
+	var fsData models.FSResponse
+	if err := json.NewDecoder(fsResp.Body).Decode(&fsData); err != nil {
+		fmt.Printf("%s Failed to parse filesystem JSON: %v\n", logPrefix, err)
+		return false, 0
+	}
+
+	if len(fsData) > 0 {
+		return true, fsData[0].Percent
+	}
+
+	return true, 0
+}
+
+// Helper function to fetch uptime
+func fetchUptime(client *http.Client, baseURL, logPrefix string) string {
+	uptimeResp, err := client.Get(fmt.Sprintf("%s/api/4/uptime", baseURL))
+	if err != nil || uptimeResp.StatusCode != http.StatusOK {
+		if err != nil {
+			fmt.Printf("%s Uptime request failed: %v\n", logPrefix, err)
+		} else {
+			fmt.Printf("%s Bad uptime status code: %d\n", logPrefix, uptimeResp.StatusCode)
+			uptimeResp.Body.Close()
+		}
+		return ""
+	}
+	defer uptimeResp.Body.Close()
+
+	// Read the response body as a string first
+	uptimeBytes, err := io.ReadAll(uptimeResp.Body)
+	if err != nil {
+		fmt.Printf("%s Failed to read uptime response: %v\n", logPrefix, err)
+		return ""
+	}
+
+	uptimeStr := strings.Trim(string(uptimeBytes), "\"")
+
+	// Try to parse as JSON object first, then fallback to direct string if that fails
+	var uptimeData models.UptimeResponse
+	if jsonErr := json.Unmarshal(uptimeBytes, &uptimeData); jsonErr == nil && uptimeData.Value != "" {
+		uptimeStr = formatUptime(uptimeData.Value)
+	} else {
+		// Use the string directly
+		uptimeStr = formatUptime(uptimeStr)
+	}
+
+	fmt.Printf("%s Uptime: %s (formatted: %s)\n", logPrefix, string(uptimeBytes), uptimeStr)
+	return uptimeStr
+}
+
+// Helper function to fetch GPU usage
+func fetchGPUUsage(client *http.Client, baseURL, logPrefix string) (bool, float64) {
+	gpuResp, err := client.Get(fmt.Sprintf("%s/api/4/gpu", baseURL))
+	if err != nil {
+		fmt.Printf("%s GPU request failed: %v\n", logPrefix, err)
+		return true, 0 // Return true to indicate server is still online
+	}
+	defer gpuResp.Body.Close()
+
+	if gpuResp.StatusCode != http.StatusOK {
+		fmt.Printf("%s Bad GPU status code: %d\n", logPrefix, gpuResp.StatusCode)
+		return true, 0 // Return true to indicate server is still online
+	}
+
+	var gpuData models.GPUResponse
+	if err := json.NewDecoder(gpuResp.Body).Decode(&gpuData); err != nil {
+		fmt.Printf("%s Failed to parse GPU JSON: %v\n", logPrefix, err)
+		return true, 0 // Return true to indicate server is still online
+	}
+
+	return true, gpuData.Proc
+}
+
+// Helper function to fetch temperature
+func fetchTemperature(client *http.Client, baseURL, logPrefix string) (bool, float64) {
+	tempResp, err := client.Get(fmt.Sprintf("%s/api/4/sensors/label/value/Composite", baseURL))
+	if err != nil {
+		fmt.Printf("%s Temperature request failed: %v\n", logPrefix, err)
+		return true, 0 // Return true to indicate server is still online
+	}
+	defer tempResp.Body.Close()
+
+	if tempResp.StatusCode != http.StatusOK {
+		fmt.Printf("%s Bad temperature status code: %d\n", logPrefix, tempResp.StatusCode)
+		return true, 0 // Return true to indicate server is still online
+	}
+
+	var tempData models.TemperatureResponse
+	if err := json.NewDecoder(tempResp.Body).Decode(&tempData); err != nil {
+		fmt.Printf("%s Failed to parse temperature JSON: %v\n", logPrefix, err)
+		return true, 0 // Return true to indicate server is still online
+	}
+
+	if len(tempData.Composite) > 0 {
+		return true, tempData.Composite[0].Value
+	}
+
+	return true, 0
+}
+
+// Helper function to send notification about status change
+func sendStatusChangeNotification(server models.Server, online bool, template string, notifSender *notifications.NotificationSender) {
+	status := "offline"
+	if online {
+		status = "online"
+	}
+
+	message := strings.ReplaceAll(template, "!name", server.Name)
+	message = strings.ReplaceAll(message, "!status", status)
+
+	notifSender.SendNotifications(message)
+}
+
+// Helper function to update server status
+func updateServerStatus(db *sql.DB, serverID int, online bool, cpuUsage, ramUsage, diskUsage, gpuUsage, temp float64, uptime string) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	_, err := db.ExecContext(ctx,
+		`UPDATE server SET online = $1, "cpuUsage" = $2::float8, "ramUsage" = $3::float8, "diskUsage" = $4::float8, "gpuUsage" = $5::float8, "temp" = $6::float8, "uptime" = $7
+		 WHERE id = $8`,
+		online, cpuUsage, ramUsage, diskUsage, gpuUsage, temp, uptime, serverID,
+	)
+	if err != nil {
+		fmt.Printf("Failed to update server status (ID: %d): %v\n", serverID, err)
+	}
+}
+
+// Helper function to add server history entry
+func addServerHistoryEntry(db *sql.DB, serverID int, online bool, cpuUsage, ramUsage, diskUsage, gpuUsage, temp float64) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	_, err := db.ExecContext(ctx,
+		`INSERT INTO server_history(
+			"serverId", online, "cpuUsage", "ramUsage", "diskUsage", "gpuUsage", "temp", "createdAt"
+		) VALUES ($1, $2, $3, $4, $5, $6, $7, now())`,
+		serverID, online, fmt.Sprintf("%.2f", cpuUsage), fmt.Sprintf("%.2f", ramUsage),
+		fmt.Sprintf("%.2f", diskUsage), fmt.Sprintf("%.2f", gpuUsage), fmt.Sprintf("%.2f", temp),
+	)
+	if err != nil {
+		fmt.Printf("Failed to insert server history (ID: %d): %v\n", serverID, err)
+	}
+}
+
+// FormatUptime formats the uptime string to a standard format
+func formatUptime(uptimeStr string) string {
+	// Example input: "3 days, 3:52:36"
+	// Target output: "28.6 13:52"
+
+	now := time.Now()
+
+	// Parse the uptime components
+	parts := strings.Split(uptimeStr, ", ")
+
+	var days int
+	var timeStr string
+
+	if len(parts) == 2 {
+		// Has days part and time part
+		_, err := fmt.Sscanf(parts[0], "%d days", &days)
+		if err != nil {
+			// Try singular "day"
+			_, err = fmt.Sscanf(parts[0], "%d day", &days)
+			if err != nil {
+				return uptimeStr // Return original if parsing fails
+			}
+		}
+		timeStr = parts[1]
+	} else if len(parts) == 1 {
+		// Only has time part (less than a day)
+		days = 0
+		timeStr = parts[0]
+	} else {
+		return uptimeStr // Return original if format is unexpected
+	}
+
+	// Parse the time component (hours:minutes:seconds)
+	var hours, minutes, seconds int
+	_, err := fmt.Sscanf(timeStr, "%d:%d:%d", &hours, &minutes, &seconds)
+	if err != nil {
+		return uptimeStr // Return original if parsing fails
+	}
+
+	// Calculate the total duration
+	duration := time.Duration(days)*24*time.Hour +
+		time.Duration(hours)*time.Hour +
+		time.Duration(minutes)*time.Minute +
+		time.Duration(seconds)*time.Second
+
+	// Calculate the start time by subtracting the duration from now
+	startTime := now.Add(-duration)
+
+	// Format the result in the required format (day.month hour:minute)
+	return startTime.Format("2.1 15:04")
+}