zeromesh/internal/handler/network.go

package handler

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"

	"zeromesh/internal/service"
)

type NetworkHandler struct {
	networkService *service.NetworkService
}

func NewNetworkHandler(networkService *service.NetworkService) *NetworkHandler {
	return &NetworkHandler{networkService: networkService}
}

type createNetworkReq struct {
	Name    string `json:"name" binding:"required"`
	IPRange string `json:"ip_range"`
}

func (h *NetworkHandler) Create(c *gin.Context) {
	var req createNetworkReq
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	uid := userID(c)
	network, err := h.networkService.CreateNetwork(uid, req.Name, req.IPRange)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, gin.H{"network": network})
}

func (h *NetworkHandler) List(c *gin.Context) {
	uid := userID(c)
	if !isAdmin(c) {
		networks, err := h.networkService.ListNetworks(uid)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{"networks": networks})
		return
	}
	networks, err := h.networkService.ListNetworks(0)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, gin.H{"networks": networks})
}

func (h *NetworkHandler) Get(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid network id"})
		return
	}
	uid := userID(c)
	network, err := h.networkService.GetNetwork(uint32(id), uid)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "network not found"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"network": network})
}

func (h *NetworkHandler) Delete(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid network id"})
		return
	}
	uid := userID(c)
	if err := h.networkService.DeleteNetwork(uint32(id), uid); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "deleted"})
}

func (h *NetworkHandler) Members(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid network id"})
		return
	}
	uid := userID(c)
	members, err := h.networkService.ListMembers(uint32(id), uid)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, gin.H{"members": members})
}

type authorizeReq struct {
	NodeID string `json:"node_id" binding:"required"`
}

func (h *NetworkHandler) Authorize(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid network id"})
		return
	}
	var req authorizeReq
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	uid := userID(c)
	if err := h.networkService.AuthorizeMember(uint32(id), req.NodeID, uid); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "member authorized"})
}

func (h *NetworkHandler) Deauthorize(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid network id"})
		return
	}
	var req authorizeReq
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	uid := userID(c)
	if err := h.networkService.DeauthorizeMember(uint32(id), req.NodeID, uid); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "member deauthorized"})
}