Merge pull request #77 from komari-monitor/dev

feat: 添加过期通知功能，支持配置过期前通知天数

.github/workflows/release-docker.yml

@@ -0,0 +1,57 @@
+name: Publish Docker Image
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:        
+  build-and-push-docker:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=raw,value=${{ github.event.release.tag_name }}
+            type=raw,value=latest
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          platforms: linux/amd64,linux/arm64
+          cache-from: type=gha
+          build-args: |
+            VERSION=${{ github.event.release.tag_name }}
+            VERSION_HASH=${{ github.sha }}

.github/workflows/release.yml

@@ -117,37 +117,3 @@ jobs:
           # Upload the binary as a release asset using GitHub CLI
           gh release upload ${{ github.event.release.tag_name }} $BINARY_NAME --repo ${{ github.repository }}
         shell: bash
-
-  build-and-push-docker:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Log in to the Container registry
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          tags: |
-            type=raw,value=${{ github.event.release.tag_name }}
-            type=raw,value=latest
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: |
-            VERSION=${{ github.event.release.tag_name }}
-            VERSION_HASH=${{ github.sha }}

api/admin/notification/expire.go

@@ -0,0 +1 @@
+package notification

api/admin/settings.go

@@ -7,6 +7,8 @@ import (
 	"github.com/komari-monitor/komari/database/config"
 	"github.com/komari-monitor/komari/database/logOperation"
 	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/database/records"
+	"github.com/komari-monitor/komari/database/tasks"
 
 	"github.com/gin-gonic/gin"
 )
@@ -69,3 +71,11 @@ func contains(slice []string, item string) bool {
 	}
 	return false
 }
+
+func ClearAllRecords(c *gin.Context) {
+	records.DeleteAll()
+	tasks.DeleteAllPingRecords()
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "clear all records", "info")
+	api.RespondSuccess(c, nil)
+}

api/admin/test/test.go

@@ -38,7 +38,7 @@ func TestGeoIp(c *gin.Context) {
 		api.RespondError(c, 400, "GeoIP is not enabled in the configuration.")
 		return
 	}
-	GeoIpRecord, err := geoip.GetGeoIpInfo(net.ParseIP(ip))
+	GeoIpRecord, err := geoip.CurrentProvider.GetGeoInfo(net.ParseIP(ip))
 	if err != nil {
 		api.RespondError(c, 500, "Failed to get GeoIP record: "+err.Error())
 		return

api/admin/update/geoip.go

@@ -8,7 +8,7 @@ import (
 )
 
 func UpdateMmdbGeoIP(c *gin.Context) {
-	if err := geoip.UpdateGeoIpDatabase(); err != nil {
+	if err := geoip.CurrentProvider.UpdateDatabase(); err != nil {
 		api.RespondError(c, 500, "Failed to update GeoIP database "+err.Error())
 		return
 	}

api/client/uploadBasicInfo.go

@@ -29,15 +29,15 @@ func UploadBasicInfo(c *gin.Context) {
 	if cfg, err := config.Get(); err == nil && cfg.GeoIpEnabled {
 		if ipv4, ok := cbi["ipv4"].(string); ok && ipv4 != "" {
 			ip4 := net.ParseIP(ipv4)
-			ip4_record, _ := geoip.GetGeoIpInfo(ip4)
+			ip4_record, _ := geoip.CurrentProvider.GetGeoInfo(ip4)
 			if ip4_record != nil {
-				cbi["region"] = geoip.GetRegionUnicodeEmoji(ip4_record.Country.ISOCode)
+				cbi["region"] = geoip.GetRegionUnicodeEmoji(ip4_record.ISOCode)
 			}
 		} else if ipv6, ok := cbi["ipv6"].(string); ok && ipv6 != "" {
 			ip6 := net.ParseIP(ipv6)
-			ip6_record, _ := geoip.GetGeoIpInfo(ip6)
+			ip6_record, _ := geoip.CurrentProvider.GetGeoInfo(ip6)
 			if ip6_record != nil {
-				cbi["region"] = geoip.GetRegionUnicodeEmoji(ip6_record.Country.ISOCode)
+				cbi["region"] = geoip.GetRegionUnicodeEmoji(ip6_record.ISOCode)
 			}
 		}
 	}

cmd/server.go

@@ -30,6 +30,7 @@ import (
 	"github.com/komari-monitor/komari/public"
 	"github.com/komari-monitor/komari/utils"
 	"github.com/komari-monitor/komari/utils/geoip"
+	u_notification "github.com/komari-monitor/komari/utils/notification"
 	"github.com/komari-monitor/komari/ws"
 	"github.com/spf13/cobra"
 )
@@ -64,6 +65,9 @@ var ServerCmd = &cobra.Command{
 		DynamicCorsEnabled = conf.AllowCors
 		config.Subscribe(func(event config.ConfigEvent) {
 			DynamicCorsEnabled = event.New.AllowCors
+			if event.New.GeoIpProvider != event.Old.GeoIpProvider {
+				go geoip.InitGeoIp()
+			}
 		})
 		r.Use(func(c *gin.Context) {
 			if DynamicCorsEnabled {
@@ -162,6 +166,7 @@ var ServerCmd = &cobra.Command{
 			recordGroup := adminAuthrized.Group("/record")
 			{
 				recordGroup.POST("/clear", admin.ClearRecord)
+				recordGroup.POST("/clear/all", admin.ClearAllRecords)
 			}
 			// oauth2
 			oauth2Group := adminAuthrized.Group("/oauth2")
@@ -284,6 +289,7 @@ func DoScheduledWork() {
 	//records.DeleteRecordBefore(time.Now().Add(-time.Hour * 24 * 30))
 	records.CompactRecord()
 	cfg, _ := config.Get()
+	go u_notification.CheckExpireScheduledWork()
 	for {
 		select {
 		case <-ticker.C:
@@ -294,6 +300,10 @@ func DoScheduledWork() {
 			logOperation.RemoveOldLogs()
 		case <-minute.C:
 			api.SaveClientReportToDB()
+			if !cfg.RecordEnabled {
+				records.DeleteAll()
+				tasks.DeleteAllPingRecords()
+			}
 		}
 	}
 

database/models/config.go

@@ -7,7 +7,7 @@ type Config struct {
 	AllowCors   bool   `json:"allow_cors" gorm:"column:allow_cors;default:false"`
 	// GeoIP 配置
 	GeoIpEnabled  bool   `json:"geo_ip_enabled" gorm:"default:true"`
-	GeoIpProvider string `json:"geo_ip_provider" gorm:"type:varchar(20);default:'mmdb'"` // mmdb, bilibili, ip-api. 暂时只实现了mmdb
+	GeoIpProvider string `json:"geo_ip_provider" gorm:"type:varchar(20);default:'ip-api'"` // empty, mmdb, ip-api, geojs
 	// OAuth 配置
 	OAuthClientID        string `json:"o_auth_client_id" gorm:"type:varchar(255)"`
 	OAuthClientSecret    string `json:"o_auth_client_secret" gorm:"type:varchar(255)"`
@@ -22,12 +22,14 @@ type Config struct {
 	TelegramBotToken string `json:"telegram_bot_token" gorm:"type:varchar(255)"`
 	TelegramChatID   string `json:"telegram_chat_id" gorm:"type:varchar(255)"`
 	// 通知
-	NotificationEnabled bool   `json:"notification_enabled" gorm:"default:false"` // 通知总开关
-	NotificationMethod  string `json:"notification_method" gorm:"type:varchar(64);default:'none'"`
+	NotificationEnabled        bool   `json:"notification_enabled" gorm:"default:false"` // 通知总开关
+	NotificationMethod         string `json:"notification_method" gorm:"type:varchar(64);default:'none'"`
+	ExpireNotificationEnabled  bool   `json:"expire_notification_enabled" gorm:"default:false"` // 是否启用过期通知
+	ExpireNotificationLeadDays int    `json:"expire_notification_lead_days" gorm:"default:7"`   // 过期前多少天通知，默认7天
 	// Record
 	RecordEnabled          bool `json:"record_enabled" gorm:"default:true"`          // 是否启用记录功能
 	RecordPreserveTime     int  `json:"record_preserve_time" gorm:"default:720"`     // 记录保留时间，单位小时，默认30天
-	PingRecordPreserveTime int  `json:"ping_record_preserve_time" gorm:"default:72"` // Ping 记录保留时间，单位小时，默认3天
+	PingRecordPreserveTime int  `json:"ping_record_preserve_time" gorm:"default:24"` // Ping 记录保留时间，单位小时，默认1天
 	CreatedAt              UTCTime
 	UpdatedAt              UTCTime
 }

database/records/records.go

@@ -42,13 +42,13 @@ func GetRecordsByClientAndTime(uuid string, start, end time.Time) ([]models.Reco
 	db := dbcore.GetDBInstance()
 	var records []models.Record
 
-	threeHoursAgo := time.Now().Add(-3 * time.Hour)
+	fourHoursAgo := time.Now().Add(-4*time.Hour - time.Minute)
 
 	var recentRecords []models.Record
 	recentStart := start
-	if end.After(threeHoursAgo) {
-		if recentStart.Before(threeHoursAgo) {
-			recentStart = threeHoursAgo
+	if end.After(fourHoursAgo) {
+		if recentStart.Before(fourHoursAgo) {
+			recentStart = fourHoursAgo
 		}
 		err := db.Where("client = ? AND time >= ? AND time <= ?", uuid, recentStart, end).Order("time ASC").Find(&recentRecords).Error
 		if err != nil {
@@ -122,7 +122,7 @@ func CompactRecord() error {
 			log.Printf("Error vacuuming database: %v", err)
 		}
 	}
-	log.Printf("Record compaction completed")
+	//log.Printf("Record compaction completed")
 	return nil
 }
 
@@ -251,7 +251,8 @@ func migrateOldRecords(db *gorm.DB) error {
 			for i, v := range data.Temp {
 				tempFloats[i] = float64(v)
 			}
-			high_percentile := 0.8
+			// 取高位
+			high_percentile := 0.7
 			// 检查 records_long_term 表中是否已存在相同的记录
 			var existingCount int64
 			if err := tx.Table("records_long_term").Where("client = ? AND time = ?", clientUUID, timeSlot).Count(&existingCount).Error; err != nil {
@@ -271,8 +272,8 @@ func migrateOldRecords(db *gorm.DB) error {
 				SwapTotal:      getIntPercentile(data.SwapTotal, high_percentile),
 				Disk:           getIntPercentile(data.Disk, high_percentile),
 				DiskTotal:      getIntPercentile(data.DiskTotal, high_percentile),
-				NetIn:          getIntPercentile(data.NetIn, high_percentile),
-				NetOut:         getIntPercentile(data.NetOut, high_percentile),
+				NetIn:          getIntPercentile(data.NetIn, 0.2),
+				NetOut:         getIntPercentile(data.NetOut, 0.2),
 				NetTotalUp:     getIntPercentile(data.NetTotalUp, high_percentile),
 				NetTotalDown:   getIntPercentile(data.NetTotalDown, high_percentile),
 				Process:        getInt32Percentile(data.Process, high_percentile),
@@ -293,7 +294,7 @@ func migrateOldRecords(db *gorm.DB) error {
 		}
 
 		// 删除 records 表中的旧数据
-		if err := tx.Table("records").Where("time < ?", fourHoursAgo).Delete(&models.Record{}).Error; err != nil {
+		if err := tx.Table("records").Where("time < ?", fourHoursAgo.Add(-1*time.Hour)).Delete(&models.Record{}).Error; err != nil {
 			return err
 		}
 

database/tasks/ping.go

@@ -85,6 +85,14 @@ func DeletePingRecords(id []uint) error {
 	return result.Error
 }
 
+func DeleteAllPingRecords() error {
+	db := dbcore.GetDBInstance()
+	result := db.Exec("DELETE FROM ping_records")
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return result.Error
+}
 func ReloadPingSchedule() error {
 	db := dbcore.GetDBInstance()
 	var pingTasks []models.PingTask

utils/geoip/emptyProvider.go

@@ -0,0 +1,21 @@
+package geoip
+
+import (
+	"fmt"
+	"net"
+)
+
+type EmptyProvider struct{}
+
+func (e *EmptyProvider) Initialize() error {
+	return nil
+}
+func (e *EmptyProvider) GetGeoInfo(ip net.IP) (*GeoInfo, error) {
+	return nil, fmt.Errorf("you are using an empty GeoIP provider, please set a valid provider")
+}
+func (e *EmptyProvider) UpdateDatabase() error {
+	return fmt.Errorf("you are using an empty GeoIP provider, please set a valid provider")
+}
+func (e *EmptyProvider) Close() error {
+	return nil
+}

utils/geoip/geoip.go

@@ -1,100 +1,33 @@
 package geoip
 
 import (
-	"fmt"
-	"io"
 	"log"
 	"net"
-	"net/http"
-	"os"
 	"strings"
-	"sync"
 	"unicode"
 
-	"github.com/oschwald/maxminddb-golang"
+	"github.com/komari-monitor/komari/database/config"
 )
 
-var (
-	GeoIpUrl                        = "https://raw.githubusercontent.com/Loyalsoldier/geoip/release/GeoLite2-Country.mmdb"
-	GeoIpFilePath                   = "./data/GeoLite2-Country.mmdb"
-	geoIpDb       *maxminddb.Reader = nil
-	lock                            = &sync.RWMutex{}
-)
+var CurrentProvider GeoIPService
 
-type GeoIpRecord struct {
-	Country struct {
-		ISOCode string            `maxminddb:"iso_code"`
-		Names   map[string]string `maxminddb:"names"`
-	} `maxminddb:"country"`
+type GeoInfo struct {
+	ISOCode string
+	Name    string
 }
 
-// 更新Geoip数据库，使用 GeoIpUrl下载最新的数据库文件，并覆盖本地的 GeoIpFilePath 文件
-func UpdateGeoIpDatabase() error {
-	lock.Lock()
-	defer lock.Unlock()
-	if geoIpDb != nil {
-		geoIpDb.Close()
-		geoIpDb = nil
-	}
-	log.Println("Downloading GeoIP database...")
-	resp, err := http.Get(GeoIpUrl)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("failed to download file: %s", resp.Status)
-	}
-
-	out, err := os.Create(GeoIpFilePath)
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-
-	_, err = io.Copy(out, resp.Body)
-	if err != nil {
-		return err
-	}
-	return nil
+func init() {
+	CurrentProvider = &EmptyProvider{}
 }
 
-func InitGeoIp() {
-	if os.MkdirAll("./data", os.ModePerm) != nil {
-		return
-	}
-	if _, err := os.Stat(GeoIpFilePath); os.IsNotExist(err) {
-		err := UpdateGeoIpDatabase()
-		if err != nil {
-			log.Println("Error updating GeoIP database:", err)
-		} else {
-			log.Println("GeoIP database updated successfully.")
-		}
-	}
-	var err error
-	geoIpDb, err = maxminddb.Open(GeoIpFilePath)
-	if err != nil {
-		log.Printf("Error opening GeoIP database: %v", err)
-	}
-}
+// GeoIPService 接口定义了获取地理位置信息的核心方法。
+// 任何实现此接口的类型都可以作为地理位置服务提供者。
+type GeoIPService interface {
+	GetGeoInfo(ip net.IP) (*GeoInfo, error)
 
-func GetGeoIpInfo(ip net.IP) (*GeoIpRecord, error) {
-	lock.RLock()
-	defer lock.RUnlock()
-	if geoIpDb == nil {
-		InitGeoIp()
-	}
-	if ip == nil {
-		return nil, fmt.Errorf("IP address is nil")
-	}
-	var record GeoIpRecord
-	err := geoIpDb.Lookup(ip, &record)
-	if err != nil {
-		log.Printf("Error looking up IP %s: %v", ip.String(), err)
-		return nil, err
-	}
-	return &record, nil
+	UpdateDatabase() error
+
+	Close() error
 }
 
 func GetRegionUnicodeEmoji(isoCode string) string {
@@ -111,3 +44,52 @@ func GetRegionUnicodeEmoji(isoCode string) string {
 	rune2 := rune(0x1F1E6 + (rune(isoCode[1]) - 'A'))
 	return string(rune1) + string(rune2)
 }
+
+func InitGeoIp() {
+	conf, err := config.Get()
+	if err != nil {
+		panic("Failed to get configuration for GeoIP: " + err.Error())
+	}
+	if !conf.GeoIpEnabled {
+		return
+	}
+	switch conf.GeoIpProvider {
+	case "mmdb":
+		NewCurrentProvider, err := NewMaxMindGeoIPService()
+		if err != nil {
+			log.Printf("Failed to initialize MaxMind GeoIP service: " + err.Error())
+		}
+		if NewCurrentProvider != nil {
+			CurrentProvider = NewCurrentProvider
+		} else {
+			CurrentProvider = &EmptyProvider{}
+			log.Println("Failed to initialize MaxMind GeoIP service, using EmptyProvider instead.")
+		}
+	case "ip-api":
+		NewCurrentProvider, err := NewIPAPIService()
+		if err != nil {
+			log.Printf("Failed to initialize ip-api service: " + err.Error())
+		}
+		if NewCurrentProvider != nil {
+			CurrentProvider = NewCurrentProvider
+			log.Println("Using ip-api.com as GeoIP provider.")
+		} else {
+			CurrentProvider = &EmptyProvider{}
+			log.Println("Failed to initialize ip-api service, using EmptyProvider instead.")
+		}
+	case "geojs":
+		NewCurrentProvider, err := NewGeoJSService()
+		if err != nil {
+			log.Printf("Failed to initialize GeoJS service: " + err.Error())
+		}
+		if NewCurrentProvider != nil {
+			CurrentProvider = NewCurrentProvider
+			log.Println("Using geojs.io as GeoIP provider.")
+		} else {
+			CurrentProvider = &EmptyProvider{}
+			log.Println("Failed to initialize GeoJS service, using EmptyProvider instead.")
+		}
+	default:
+		CurrentProvider = &EmptyProvider{}
+	}
+}

utils/geoip/geoip_test.go

@@ -2,58 +2,60 @@ package geoip_test
 
 import (
 	"net"
-	"os"
 	"testing"
 
 	"github.com/komari-monitor/komari/utils/geoip"
 )
 
 // 测试GeoIP数据库的初始化和更新功能
-func TestInitGeoIp(t *testing.T) {
-	geoip.InitGeoIp()
+func TestMmdb(t *testing.T) {
+	geoip.CurrentProvider, _ = geoip.NewMaxMindGeoIPService()
+	testIpAddr(t)
+}
+func TestIpApi(t *testing.T) {
+	geoip.CurrentProvider, _ = geoip.NewIPAPIService()
+	testIpAddr(t)
+}
 
-	// 检查数据库
-	fileInfo, err := os.Stat(geoip.GeoIpFilePath)
-	if err != nil {
-		t.Errorf("Failed to get file info: %v", err)
-	}
-	if fileInfo.Size() == 0 {
-		t.Errorf("GeoIP database file is empty: %s", geoip.GeoIpFilePath)
-	}
+func TestGeojs(t *testing.T) {
+	geoip.CurrentProvider, _ = geoip.NewGeoJSService()
+	testIpAddr(t)
+}
 
+func testIpAddr(t *testing.T) {
 	// IPv4
 	ipaddr := "8.8.8.8"
 	ip := net.ParseIP(ipaddr)
-	record, err := geoip.GetGeoIpInfo(ip)
+	record, err := geoip.CurrentProvider.GetGeoInfo(ip)
 	if err != nil {
 		t.Errorf("Failed to get GeoIP info for IP %s: %v", ipaddr, err)
 	}
 
 	if record != nil {
-		if record.Country.ISOCode == "" && record.Country.Names["zh-CN"] == "" {
+		if record.ISOCode == "" && record.Name == "" {
 			t.Errorf("Country information is missing for IP %s", ipaddr)
 		}
 	} else {
 		t.Errorf("GeoIP record is nil for IP %s", ipaddr)
 	}
 
-	t.Logf("IPv4:[%s]%s - %s", ipaddr, record.Country.ISOCode, record.Country.Names["zh-CN"])
+	t.Logf("IPv4:[%s]%s - %s", ipaddr, record.ISOCode, record.Name)
 
 	// IPv6
 	ipaddr = "2001:4860:4860::8888"
 	ip = net.ParseIP(ipaddr)
-	record, err = geoip.GetGeoIpInfo(ip)
+	record, err = geoip.CurrentProvider.GetGeoInfo(ip)
 	if err != nil {
 		t.Errorf("Failed to get GeoIP info for IPv6 %s: %v", ipaddr, err)
 	}
 	if record != nil {
-		if record.Country.ISOCode == "" && record.Country.Names["zh-CN"] == "" {
+		if record.ISOCode == "" && record.Name == "" {
 			t.Errorf("Country information is missing for IPv6 %s", ipaddr)
 		}
 	} else {
 		t.Errorf("GeoIP record is nil for IPv6 %s", ipaddr)
 	}
-	t.Logf("IPv6:[%s]%s - %s", ipaddr, record.Country.ISOCode, record.Country.Names["zh-CN"])
+	t.Logf("IPv6:[%s]%s - %s", ipaddr, record.ISOCode, record.Name)
 }
 
 func TestUnicodeEmoji(t *testing.T) {

utils/geoip/geojs.go

@@ -0,0 +1,75 @@
+package geoip
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+)
+
+// GeoJSService 使用 geojs.io 服务实现 GeoIPService 接口。
+type GeoJSService struct {
+	Client *http.Client
+}
+
+// geoJSResponse 定义了 geojs.io 服务返回的 JSON 响应的结构。
+// 我们只定义我们需要的字段。
+type geoJSResponse struct {
+	Country     string `json:"country"`
+	CountryCode string `json:"country_code"`
+	// 可以根据需要添加其他字段，例如:
+	// City    string `json:"city"`
+	// Region  string `json:"region"`
+}
+
+// NewGeoJSService 创建并返回一个 GeoJSService 的新实例。
+func NewGeoJSService() (*GeoJSService, error) {
+	return &GeoJSService{
+		Client: &http.Client{
+			Timeout: 5 * time.Second, // 设置一个合理的超时时间
+		},
+	}, nil
+}
+
+// GetGeoInfo 使用 geojs.io 服务检索给定 IP 地址的地理位置信息。
+func (s *GeoJSService) GetGeoInfo(ip net.IP) (*GeoInfo, error) {
+	// GeoJS 的 API 端点
+	apiURL := fmt.Sprintf("https://get.geojs.io/v1/ip/geo/%s.json", ip.String())
+
+	resp, err := s.Client.Get(apiURL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get geo info from geojs.io: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("geojs.io returned non-200 status code: %d", resp.StatusCode)
+	}
+
+	var apiResp geoJSResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
+		return nil, fmt.Errorf("failed to decode geojs.io response: %w", err)
+	}
+
+	// 检查国家代码是否为空，因为 geojs 对无效/私有IP可能返回200 OK但内容为空
+	if apiResp.CountryCode == "" {
+		return nil, fmt.Errorf("geojs.io returned empty geo info for ip: %s", ip.String())
+	}
+
+	return &GeoInfo{
+		ISOCode: apiResp.CountryCode,
+		Name:    apiResp.Country,
+	}, nil
+}
+
+// UpdateDatabase 对于 geojs.io 是一个空操作，因为它是一个 Web 服务。
+func (s *GeoJSService) UpdateDatabase() error {
+	return nil
+}
+
+// Close 对于 geojs.io 是一个空操作。
+func (s *GeoJSService) Close() error {
+	return nil
+}

utils/geoip/ipapi.go

@@ -0,0 +1,80 @@
+package geoip
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+)
+
+// IPAPIService 使用 ip-api.com 服务实现 GeoIPService 接口。
+type IPAPIService struct {
+	Client *http.Client
+}
+
+// ipAPIResponse 定义了 ip-api.com 服务返回的 JSON 响应的结构。
+type ipAPIResponse struct {
+	Status      string  `json:"status"`
+	Message     string  `json:"message"` // 当 status 为 fail 时出现
+	Country     string  `json:"country"`
+	CountryCode string  `json:"countryCode"`
+	Region      string  `json:"region"`
+	RegionName  string  `json:"regionName"`
+	City        string  `json:"city"`
+	Zip         string  `json:"zip"`
+	Lat         float64 `json:"lat"`
+	Lon         float64 `json:"lon"`
+	Timezone    string  `json:"timezone"`
+	ISP         string  `json:"isp"`
+	Org         string  `json:"org"`
+	As          string  `json:"as"`
+	Query       string  `json:"query"`
+}
+
+// NewIPAPIService 创建并返回一个 IPAPIService 的新实例。
+func NewIPAPIService() (*IPAPIService, error) {
+	return &IPAPIService{
+		Client: &http.Client{
+			Timeout: 5 * time.Second, // 设置请求超时
+		},
+	}, nil
+}
+
+// GetGeoInfo 使用 ip-api.com 服务检索给定 IP 地址的地理位置信息。
+func (s *IPAPIService) GetGeoInfo(ip net.IP) (*GeoInfo, error) {
+	// API URL, 使用 fields 参数来仅请求需要的字段
+	apiURL := fmt.Sprintf("http://ip-api.com/json/%s?fields=status,message,country,countryCode", ip.String())
+
+	resp, err := s.Client.Get(apiURL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get geo info from ip-api.com: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var apiResp ipAPIResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
+		return nil, fmt.Errorf("failed to decode ip-api.com response: %w", err)
+	}
+
+	if apiResp.Status != "success" {
+		return nil, fmt.Errorf("ip-api.com returned an error: %s", apiResp.Message)
+	}
+
+	return &GeoInfo{
+		ISOCode: apiResp.CountryCode,
+		Name:    apiResp.Country,
+	}, nil
+}
+
+// UpdateDatabase 对于 ip-api.com 是一个空操作，因为它是一个 Web 服务。
+func (s *IPAPIService) UpdateDatabase() error {
+	// 无需执行任何操作，因为数据由外部服务提供
+	return nil
+}
+
+// Close 对于 ip-api.com 是一个空操作，因为没有需要关闭的持久连接。
+func (s *IPAPIService) Close() error {
+	// 无需执行任何操作
+	return nil
+}

utils/geoip/mmdb.go

@@ -0,0 +1,176 @@
+package geoip // 与 geoip.go 保持相同的包名，表示它们是同一个包的组成部分
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath" // 新增导入，用于处理文件路径
+	"sync"
+
+	"github.com/komari-monitor/komari/database/logOperation"
+	"github.com/oschwald/maxminddb-golang"
+)
+
+// GeoIpUrl 是 MaxMind 数据库的下载地址。
+var GeoIpUrl = "https://raw.githubusercontent.com/Loyalsoldier/geoip/release/GeoLite2-Country.mmdb"
+
+// GeoIpFilePath 是本地存储 MaxMind 数据库的路径。
+var GeoIpFilePath = "./data/GeoLite2-Country.mmdb"
+
+// GeoIpRecord 结构体定义了 MaxMind 数据库查询结果的原始结构。
+// 它是 MaxMind 库特有的，用于从 .mmdb 文件中解析数据。
+type GeoIpRecord struct {
+	Country struct {
+		ISOCode string            `maxminddb:"iso_code"`
+		Names   map[string]string `maxminddb:"names"`
+	} `maxminddb:"country"`
+}
+
+// MaxMindGeoIPService 是 GeoIPService 接口的一个具体实现，
+// 它使用 MaxMind 数据库作为后端。
+type MaxMindGeoIPService struct {
+	// maxMindDBReader 内部持有的 MaxMind 数据库读取器实例。
+	maxMindDBReader *maxminddb.Reader
+	// dbFilePath 是 MaxMind 数据库文件的路径。
+	dbFilePath string
+	// mu 用于保护对 maxMindDBReader 的并发访问，确保线程安全。
+	mu sync.RWMutex
+}
+
+// NewMaxMindGeoIPService 创建并返回一个 MaxMindGeoIPService 实例。
+// 它负责初始化服务，包括尝试加载或下载数据库。
+func NewMaxMindGeoIPService() (*MaxMindGeoIPService, error) {
+	dbFilePath := GeoIpFilePath
+	service := &MaxMindGeoIPService{
+		dbFilePath: dbFilePath,
+	}
+
+	// 确保数据目录存在
+	if err := os.MkdirAll(filepath.Dir(dbFilePath), os.ModePerm); err != nil {
+		logOperation.Log("", "", "Failed to create data directory for MaxMind database: "+err.Error(), "error")
+		return nil, fmt.Errorf("failed to create data directory for MaxMind database: %w", err)
+	}
+
+	// 检查数据库文件是否存在，如果不存在则尝试下载
+	if _, err := os.Stat(dbFilePath); os.IsNotExist(err) {
+		if err := service.UpdateDatabase(); err != nil {
+			logOperation.Log("", "", "Failed to download initial MaxMind database: "+err.Error(), "error")
+			return nil, fmt.Errorf("failed to download initial MaxMind database: %w", err)
+		}
+	}
+
+	// 初始化或重新加载 MaxMind 数据库。
+	if err := service.initialize(); err != nil {
+		logOperation.Log("", "", "Failed to initialize MaxMind database: "+err.Error(), "error")
+		return nil, fmt.Errorf("failed to initialize MaxMind database: %w", err)
+	}
+	return service, nil
+}
+
+// initialize 初始化或重新加载 MaxMind 数据库。
+// 这是一个内部方法，供 NewMaxMindGeoIPService 和 UpdateDatabase 调用。
+// 它会关闭现有连接（如果存在）并重新打开数据库文件。
+func (s *MaxMindGeoIPService) initialize() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// 如果已存在数据库读取器，则先关闭它。
+	if s.maxMindDBReader != nil {
+		s.maxMindDBReader.Close()
+		s.maxMindDBReader = nil
+	}
+
+	// 尝试打开新的数据库文件。
+	reader, err := maxminddb.Open(s.dbFilePath)
+	if err != nil {
+		return fmt.Errorf("error opening MaxMind database at %s: %w", s.dbFilePath, err)
+	}
+	s.maxMindDBReader = reader
+	return nil
+}
+
+// GetGeoInfo 根据 IP 地址获取 MaxMind 的地理位置信息。
+// 它查询 MaxMind 数据库并将其特有的 GeoIpRecord 转换为通用的 GeoInfo 结构体。
+func (s *MaxMindGeoIPService) GetGeoInfo(ip net.IP) (*GeoInfo, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	if s.maxMindDBReader == nil {
+		return nil, fmt.Errorf("MaxMind database is not initialized or failed to open")
+	}
+	if ip == nil {
+		return nil, fmt.Errorf("IP address cannot be nil")
+	}
+
+	var record GeoIpRecord // 使用原始的 GeoIpRecord 结构体来接收查询结果
+	err := s.maxMindDBReader.Lookup(ip, &record)
+	if err != nil {
+		// 返回错误，但避免直接返回 maxminddb 库的内部错误，提供更友好的信息
+		return nil, fmt.Errorf("error looking up IP %s in MaxMind database: %w", ip.String(), err)
+	}
+
+	// 将 MaxMind 的特定结构体转换为通用的 GeoInfo 结构体
+	geoInfo := &GeoInfo{
+		ISOCode: record.Country.ISOCode,
+		// 尝试获取英文国家名称，如果不存在则使用 ISO 代码作为备用
+		Name: record.Country.Names["en"],
+	}
+	if geoInfo.Name == "" && geoInfo.ISOCode != "" {
+		geoInfo.Name = geoInfo.ISOCode // 如果没有英文名称，回退到 ISO 代码
+	}
+	return geoInfo, nil
+}
+
+// UpdateDatabase 实现了 GeoIPService 接口的 UpdateDatabase 方法。
+// 它会下载最新的 GeoLite2-Country.mmdb 文件并重新加载数据库。
+func (s *MaxMindGeoIPService) UpdateDatabase() error {
+	s.mu.Lock() // 获取写锁，确保更新过程的互斥性
+	defer s.mu.Unlock()
+
+	resp, err := http.Get(GeoIpUrl) // GeoIpUrl 是预定义的 MaxMind 数据库下载地址
+	if err != nil {
+		return fmt.Errorf("failed to initiate MaxMind database download: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to download MaxMind database: HTTP status %s", resp.Status)
+	}
+
+	// 确保数据目录存在（NewMaxMindGeoIPService 已处理，但这里再次确保以防直接调用）
+	if err := os.MkdirAll(filepath.Dir(s.dbFilePath), os.ModePerm); err != nil {
+		return fmt.Errorf("failed to create data directory for MaxMind database update: %w", err)
+	}
+
+	out, err := os.Create(s.dbFilePath) // 创建或覆盖本地数据库文件
+	if err != nil {
+		return fmt.Errorf("failed to create MaxMind database file at %s: %w", s.dbFilePath, err)
+	}
+	defer out.Close()
+
+	_, err = io.Copy(out, resp.Body) // 将下载内容写入文件
+	if err != nil {
+		return fmt.Errorf("failed to write MaxMind database file: %w", err)
+	}
+	// 重新加载数据库以使用新下载的文件
+	return s.initialize()
+}
+
+// Close 实现了 GeoIPService 接口的 Close 方法。
+// 它关闭 MaxMind 数据库读取器，释放文件句柄和其他资源。
+func (s *MaxMindGeoIPService) Close() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.maxMindDBReader != nil {
+		err := s.maxMindDBReader.Close()
+		s.maxMindDBReader = nil // 清空读取器实例
+		if err != nil {
+			return fmt.Errorf("error closing MaxMind database: %w", err)
+		}
+	}
+	log.Println("MaxMind GeoIP service closed.")
+	return nil
+}

utils/notification/expire.go

@@ -0,0 +1,65 @@
+package notification
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/utils/messageSender"
+)
+
+func CheckExpireScheduledWork() {
+	for {
+		now := time.Now()
+		next := time.Date(now.Year(), now.Month(), now.Day(), 17, 0, 0, 0, now.Location())
+		if now.After(next) {
+			// 如果已经过了今天的17:00，则设为明天的17:00
+			next = next.Add(24 * time.Hour)
+		}
+		duration := next.Sub(now)
+		time.Sleep(duration)
+
+		cfg, err := config.Get()
+		if err != nil {
+			time.Sleep(time.Second)
+			continue
+		}
+		if !cfg.ExpireNotificationEnabled {
+			time.Sleep(time.Second)
+			continue
+		}
+
+		notificationLeadDays := cfg.ExpireNotificationLeadDays
+
+		clients_all, err := clients.GetAllClientBasicInfo()
+		if err != nil {
+			time.Sleep(time.Second)
+			continue
+		}
+
+		var clientLeadToExpire []string
+		for _, client := range clients_all {
+			if client.ExpiredAt.ToTime().Before(now) {
+				continue
+			}
+
+			notificationThreshold := now.Add(time.Duration(notificationLeadDays) * 24 * time.Hour)
+
+			if client.ExpiredAt.ToTime().Before(notificationThreshold) || client.ExpiredAt.ToTime().Equal(notificationThreshold) {
+				clientLeadToExpire = append(clientLeadToExpire, client.Name)
+			}
+		}
+
+		if len(clientLeadToExpire) > 0 {
+			message := "The following clients are about to expire: \n"
+			for i := 0; i < len(clientLeadToExpire); i++ {
+				message += fmt.Sprintf("%s in %d days.\n", clientLeadToExpire[i], notificationLeadDays)
+			}
+			messageSender.SendTextMessage(message)
+		}
+
+		// 等待1秒，防止多次触发
+		time.Sleep(time.Second)
+	}
+}