aiops/backend/controller/cloud_domain.go

package controller

import (
	"net/http"
	"strconv"
	"strings"
	"time"

	"ezops/model"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

// DomainHandler 域名处理器
type DomainHandler struct {
	db *gorm.DB
}

// NewDomainHandler 创建域名处理器
func NewDomainHandler(db *gorm.DB) *DomainHandler {
	return &DomainHandler{db: db}
}

// ListDomains 获取域名列表
// @Summary 获取域名列表
// @Description 获取所有域名列表
// @Tags 域名
// @Produce json
// @Security Bearer
// @Param page query int false "页码"
// @Param page_size query int false "每页数量"
// @Param keyword query string false "搜索关键词"
// @Success 200 {object} model.Response{data=model.ListResponse}
// @Router /domains [get]
func (h *DomainHandler) ListDomains(c *gin.Context) {
	var query model.PageQuery
	c.ShouldBindQuery(&query)

	db := h.db.Model(&model.Domain{})
	if query.Keyword != "" {
		db = db.Where("name LIKE ?", "%"+query.Keyword+"%")
	}

	var total int64
	db.Count(&total)

	var domains []model.Domain
	db.Offset(query.GetOffset()).Limit(query.GetLimit()).Find(&domains)

	c.JSON(http.StatusOK, model.Response{
		Code:    200,
		Message: "success",
		Data: model.ListResponse{
			List:  domains,
			Total: total,
		},
	})
}

// CreateDomain 创建域名
// @Summary 创建域名
// @Description 创建新域名
// @Tags 域名
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body model.Domain true "创建请求"
// @Success 200 {object} model.Response{data=model.Domain}
// @Router /domains [post]
func (h *DomainHandler) CreateDomain(c *gin.Context) {
	var req updateDomainRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Response{
			Code:    400,
			Message: "请求参数错误: " + err.Error(),
		})
		return
	}

	if strings.TrimSpace(req.Name) == "" {
		c.JSON(http.StatusBadRequest, model.Response{
			Code:    400,
			Message: "域名不能为空",
		})
		return
	}

	status := req.Status
	if status == "" {
		status = "active"
	}

	domain := model.Domain{
		Name:          strings.TrimSpace(req.Name),
		Registrar:     req.Registrar,
		Status:        status,
		ExpireDate:    parseDateStr(req.ExpireDate),
		DNSProvider:   req.DNSProvider,
		RecordCount:   req.RecordCount,
		SSLEnabled:    req.SSLEnabled,
		SSLExpireDate: parseDateStr(req.SSLExpireDate),
	}

	if err := h.db.Create(&domain).Error; err != nil {
		c.JSON(http.StatusInternalServerError, model.Response{
			Code:    500,
			Message: "创建失败",
		})
		return
	}

	c.JSON(http.StatusOK, model.Response{
		Code:    200,
		Message: "创建成功",
		Data:    domain,
	})
}

// updateDomainRequest 域名创建/更新请求（日期字段用字符串接收，避免 RFC3339 解析失败）
type updateDomainRequest struct {
	Name          string `json:"name"`
	Registrar     string `json:"registrar"`
	Status        string `json:"status"`
	ExpireDate    string `json:"expire_date"`
	DNSProvider   string `json:"dns_provider"`
	RecordCount   int    `json:"record_count"`
	SSLEnabled    bool   `json:"ssl_enabled"`
	SSLExpireDate string `json:"ssl_expire_date"`
}

// parseDateStr 将 YYYY-MM-DD 格式字符串解析为 *time.Time，空串返回 nil
func parseDateStr(s string) *time.Time {
	s = strings.TrimSpace(s)
	if s == "" {
		return nil
	}
	t, err := time.Parse("2006-01-02", s)
	if err != nil {
		return nil
	}
	return &t
}

// DeleteDomain 删除域名
// @Summary 删除域名
// @Description 删除指定域名
// @Tags 域名
// @Produce json
// @Security Bearer
// @Param id path int true "域名ID"
// @Success 200 {object} model.Response
// @Router /domains/{id} [delete]
func (h *DomainHandler) DeleteDomain(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	if err := h.db.Delete(&model.Domain{}, id).Error; err != nil {
		c.JSON(http.StatusInternalServerError, model.Response{
			Code:    500,
			Message: "删除失败",
		})
		return
	}

	c.JSON(http.StatusOK, model.Response{
		Code:    200,
		Message: "删除成功",
	})
}

// UpdateDomain 更新域名
// @Summary 更新域名
// @Description 更新指定域名信息
// @Tags 域名
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "域名ID"
// @Param request body updateDomainRequest true "更新请求"
// @Success 200 {object} model.Response{data=model.Domain}
// @Router /domains/{id} [put]
func (h *DomainHandler) UpdateDomain(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	var req updateDomainRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Response{
			Code:    400,
			Message: "请求参数错误: " + err.Error(),
		})
		return
	}

	var domain model.Domain
	if err := h.db.First(&domain, id).Error; err != nil {
		c.JSON(http.StatusNotFound, model.Response{
			Code:    404,
			Message: "域名不存在",
		})
		return
	}

	if strings.TrimSpace(req.Name) != "" {
		domain.Name = strings.TrimSpace(req.Name)
	}
	domain.Registrar = req.Registrar
	domain.Status = req.Status
	if domain.Status == "" {
		domain.Status = "active"
	}
	domain.ExpireDate = parseDateStr(req.ExpireDate)
	domain.DNSProvider = req.DNSProvider
	domain.RecordCount = req.RecordCount
	domain.SSLEnabled = req.SSLEnabled
	domain.SSLExpireDate = parseDateStr(req.SSLExpireDate)

	if err := h.db.Save(&domain).Error; err != nil {
		c.JSON(http.StatusInternalServerError, model.Response{
			Code:    500,
			Message: "更新失败",
		})
		return
	}

	c.JSON(http.StatusOK, model.Response{
		Code:    200,
		Message: "更新成功",
		Data:    domain,
	})
}