initial: ZeroTier-like P2P mesh VPN server with multi-tenant Web UI

2026-06-17 03:50:23 +08:00
commit ee5f036325
74 changed files with 9517 additions and 0 deletions
--- a/internal/repository/log.go
+++ b/internal/repository/log.go
@@ -0,0 +1,111 @@
+package repository
+
+import (
+	"zeromesh/internal/database"
+	"zeromesh/internal/model"
+)
+
+type LogRepo struct {
+	db *database.DB
+}
+
+func NewLogRepo(db *database.DB) *LogRepo {
+	return &LogRepo{db: db}
+}
+
+func (r *LogRepo) InsertApiLog(log *model.ApiLog) error {
+	return r.db.Create(log).Error
+}
+
+func (r *LogRepo) InsertErrorLog(log *model.ErrorLog) error {
+	return r.db.Create(log).Error
+}
+
+func (r *LogRepo) ListApiLogs(page, pageSize int, ip, path, method string, statusCode int) ([]model.ApiLog, int64, error) {
+	q := r.db.Model(&model.ApiLog{})
+	if ip != "" {
+		q = q.Where("ip LIKE ?", "%"+ip+"%")
+	}
+	if path != "" {
+		q = q.Where("path LIKE ?", "%"+path+"%")
+	}
+	if method != "" {
+		q = q.Where("method = ?", method)
+	}
+	if statusCode > 0 {
+		q = q.Where("status_code = ?", statusCode)
+	}
+	var total int64
+	if err := q.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+	var logs []model.ApiLog
+	offset := (page - 1) * pageSize
+	if err := q.Order("id DESC").Offset(offset).Limit(pageSize).Find(&logs).Error; err != nil {
+		return nil, 0, err
+	}
+	return logs, total, nil
+}
+
+func (r *LogRepo) ListErrorLogs(page, pageSize int, ip, path, method string, statusCode int) ([]model.ErrorLog, int64, error) {
+	q := r.db.Model(&model.ErrorLog{})
+	if ip != "" {
+		q = q.Where("ip LIKE ?", "%"+ip+"%")
+	}
+	if path != "" {
+		q = q.Where("path LIKE ?", "%"+path+"%")
+	}
+	if method != "" {
+		q = q.Where("method = ?", method)
+	}
+	if statusCode > 0 {
+		q = q.Where("status_code = ?", statusCode)
+	}
+	var total int64
+	if err := q.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+	var logs []model.ErrorLog
+	offset := (page - 1) * pageSize
+	if err := q.Order("id DESC").Offset(offset).Limit(pageSize).Find(&logs).Error; err != nil {
+		return nil, 0, err
+	}
+	return logs, total, nil
+}
+
+func (r *LogRepo) ListApiLogGrouped() ([]map[string]interface{}, error) {
+	rows, err := r.db.Model(&model.ApiLog{}).
+		Select("ip, method, path, COUNT(*) as count, SUM(latency_ms) as total_latency").
+		Group("ip, method, path").
+		Order("count DESC").
+		Rows()
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []map[string]interface{}
+	for rows.Next() {
+		var ip, method, path string
+		var count int64
+		var totalLatency int64
+		if err := rows.Scan(&ip, &method, &path, &count, &totalLatency); err != nil {
+			return nil, err
+		}
+		result = append(result, map[string]interface{}{
+			"ip":            ip,
+			"method":        method,
+			"path":          path,
+			"count":         count,
+			"total_latency": totalLatency,
+		})
+	}
+	return result, nil
+}
+
+func (r *LogRepo) ClearApiLogs() error {
+	return r.db.Where("1 = 1").Delete(&model.ApiLog{}).Error
+}
+
+func (r *LogRepo) ClearErrorLogs() error {
+	return r.db.Where("1 = 1").Delete(&model.ErrorLog{}).Error
+}
--- a/internal/repository/network.go
+++ b/internal/repository/network.go
@@ -0,0 +1,82 @@
+package repository
+
+import (
+	"zeromesh/internal/database"
+	"zeromesh/internal/model"
+)
+
+type NetworkRepo struct {
+	db *database.DB
+}
+
+func NewNetworkRepo(db *database.DB) *NetworkRepo {
+	return &NetworkRepo{db: db}
+}
+
+func (r *NetworkRepo) Create(network *model.Network) error {
+	return r.db.Create(network).Error
+}
+
+func (r *NetworkRepo) FindByNetworkID(networkID uint32) (*model.Network, error) {
+	var network model.Network
+	err := r.db.Where("network_id = ?", networkID).Preload("Members").First(&network).Error
+	if err != nil {
+		return nil, err
+	}
+	return &network, nil
+}
+
+func (r *NetworkRepo) List() ([]model.Network, error) {
+	var networks []model.Network
+	err := r.db.Preload("Members").Find(&networks).Error
+	return networks, err
+}
+
+func (r *NetworkRepo) ListByUser(userID uint) ([]model.Network, error) {
+	var networks []model.Network
+	err := r.db.Where("user_id = ?", userID).Preload("Members").Find(&networks).Error
+	return networks, err
+}
+
+func (r *NetworkRepo) FindByNetworkIDForUser(networkID uint32, userID uint) (*model.Network, error) {
+	var network model.Network
+	err := r.db.Where("network_id = ? AND user_id = ?", networkID, userID).Preload("Members").First(&network).Error
+	if err != nil {
+		return nil, err
+	}
+	return &network, nil
+}
+
+func (r *NetworkRepo) CountByUser(userID uint) (int64, error) {
+	var count int64
+	err := r.db.Model(&model.Network{}).Where("user_id = ?", userID).Count(&count).Error
+	return count, err
+}
+
+func (r *NetworkRepo) Update(network *model.Network) error {
+	return r.db.Save(network).Error
+}
+
+func (r *NetworkRepo) Delete(networkID uint32) error {
+	return r.db.Where("network_id = ?", networkID).Delete(&model.Network{}).Error
+}
+
+func (r *NetworkRepo) AddMember(member *model.NetworkMember) error {
+	return r.db.Create(member).Error
+}
+
+func (r *NetworkRepo) RemoveMember(networkID uint32, nodeID string) error {
+	return r.db.Where("network_id = ? AND node_id = ?", networkID, nodeID).Delete(&model.NetworkMember{}).Error
+}
+
+func (r *NetworkRepo) FindMembers(networkID uint32) ([]model.NetworkMember, error) {
+	var members []model.NetworkMember
+	err := r.db.Where("network_id = ?", networkID).Find(&members).Error
+	return members, err
+}
+
+func (r *NetworkRepo) Count() (int64, error) {
+	var count int64
+	err := r.db.Model(&model.Network{}).Count(&count).Error
+	return count, err
+}
--- a/internal/repository/node.go
+++ b/internal/repository/node.go
@@ -0,0 +1,75 @@
+package repository
+
+import (
+	"time"
+
+	"zeromesh/internal/database"
+	"zeromesh/internal/model"
+)
+
+type NodeRepo struct {
+	db *database.DB
+}
+
+func NewNodeRepo(db *database.DB) *NodeRepo {
+	return &NodeRepo{db: db}
+}
+
+func (r *NodeRepo) Create(node *model.Node) error {
+	return r.db.Create(node).Error
+}
+
+func (r *NodeRepo) FindByNodeID(nodeID string) (*model.Node, error) {
+	var node model.Node
+	err := r.db.Where("node_id = ?", nodeID).First(&node).Error
+	if err != nil {
+		return nil, err
+	}
+	return &node, nil
+}
+
+func (r *NodeRepo) Upsert(node *model.Node) error {
+	var existing model.Node
+	result := r.db.Where("node_id = ?", node.NodeID).First(&existing)
+	if result.Error != nil {
+		return r.db.Create(node).Error
+	}
+	existing.PublicKey = node.PublicKey
+	existing.Name = node.Name
+	existing.IPAddress = node.IPAddress
+	existing.Port = node.Port
+	existing.Version = node.Version
+	return r.db.Save(&existing).Error
+}
+
+func (r *NodeRepo) SetOnline(nodeID string, online bool) error {
+	now := time.Now()
+	return r.db.Model(&model.Node{}).Where("node_id = ?", nodeID).Updates(map[string]interface{}{
+		"online":    online,
+		"last_seen": now,
+	}).Error
+}
+
+func (r *NodeRepo) List() ([]model.Node, error) {
+	var nodes []model.Node
+	err := r.db.Order("id desc").Find(&nodes).Error
+	return nodes, err
+}
+
+func (r *NodeRepo) ListByUser(userID uint) ([]model.Node, error) {
+	var nodes []model.Node
+	err := r.db.Where("user_id = ?", userID).Order("id desc").Find(&nodes).Error
+	return nodes, err
+}
+
+func (r *NodeRepo) CountByUser(userID uint) (int64, error) {
+	var count int64
+	err := r.db.Model(&model.Node{}).Where("user_id = ?", userID).Count(&count).Error
+	return count, err
+}
+
+func (r *NodeRepo) ListOnline() ([]model.Node, error) {
+	var nodes []model.Node
+	err := r.db.Where("online = ?", true).Find(&nodes).Error
+	return nodes, err
+}
--- a/internal/repository/user.go
+++ b/internal/repository/user.go
@@ -0,0 +1,58 @@
+package repository
+
+import (
+	"zeromesh/internal/database"
+	"zeromesh/internal/model"
+)
+
+type UserRepo struct {
+	db *database.DB
+}
+
+func NewUserRepo(db *database.DB) *UserRepo {
+	return &UserRepo{db: db}
+}
+
+func (r *UserRepo) FindByUsername(username string) (*model.User, error) {
+	var user model.User
+	err := r.db.Where("username = ?", username).First(&user).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (r *UserRepo) FindByID(id uint) (*model.User, error) {
+	var user model.User
+	err := r.db.First(&user, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (r *UserRepo) Create(user *model.User) error {
+	return r.db.Create(user).Error
+}
+
+func (r *UserRepo) Count() (int64, error) {
+	var count int64
+	err := r.db.Model(&model.User{}).Count(&count).Error
+	return count, err
+}
+
+func (r *UserRepo) HasAdmin() (bool, error) {
+	var count int64
+	err := r.db.Model(&model.User{}).Where("role = ?", "admin").Count(&count).Error
+	return count > 0, err
+}
+
+func (r *UserRepo) UpdatePassword(id uint, hashed string) error {
+	return r.db.Model(&model.User{}).Where("id = ?", id).Update("password", hashed).Error
+}
+
+func (r *UserRepo) List(offset, limit int) ([]model.User, error) {
+	var users []model.User
+	err := r.db.Offset(offset).Limit(limit).Order("id desc").Find(&users).Error
+	return users, err
+}