DeployHelper/internal/service/sys_deploy_file_service.go

package service

import (
	"crypto/md5"
	"ego/internal/model"
	"ego/internal/serializer"
	"ego/internal/types"
	"ego/pkg/logger"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"time"

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

// SysDeployFileService 部署文件服务
type SysDeployFileService struct {
	Db *gorm.DB
}

// NewSysDeployFileService 构建部署文件服务
func NewSysDeployFileService(db *gorm.DB) *SysDeployFileService {
	return &SysDeployFileService{
		Db: db,
	}
}

// Create 创建部署文件记录
func (s *SysDeployFileService) Create(c *gin.Context) serializer.Response {
	var deployFile model.SysDeployFile
	if err := c.ShouldBind(&deployFile); err != nil {
		logger.Error(c, "参数绑定失败!")
		return serializer.ParamErr("参数绑定失败!", err)
	}

	// 生成部署ID
	if id, err := SysSequenceServiceBuilder(deployFile.TableName()).GenerateId(); err == nil {
		deployFile.DeployId = id
	} else {
		return serializer.DBErr("序列生成失败!", err)
	}

	// 设置默认值
	now := time.Now()
	deployFile.CreateTime = &now
	deployFile.Status = model.DeployFileStatusNormal
	deployFile.DeployStatus = model.DeployStatusNotDeployed
	deployFile.DelFlag = "0"

	// 获取当前用户
	if createBy := c.GetString("id"); createBy != "" {
		deployFile.CreateBy = createBy
	}

	if err := s.Db.Create(&deployFile).Error; err != nil {
		logger.Error(c, "创建部署文件记录失败!")
		return serializer.DBErr("创建部署文件记录失败!", err)
	}

	return serializer.Succ("创建部署文件记录成功!", deployFile)
}

// GetByID 根据ID获取部署文件记录
func (s *SysDeployFileService) GetByID(c *gin.Context) serializer.Response {
	var deployFile model.SysDeployFile
	if err := s.Db.Where("deploy_id = ? AND del_flag = ?", c.Param("id"), "0").First(&deployFile).Error; err != nil {
		logger.Error(c, "获取部署文件记录失败!")
		return serializer.DBErr("获取部署文件记录失败!", err)
	}
	return serializer.Succ("查询成功!", deployFile)
}

// UpdateByID 根据ID更新部署文件记录
func (s *SysDeployFileService) UpdateByID(c *gin.Context) serializer.Response {
	var deployFile model.SysDeployFile
	if err := c.ShouldBind(&deployFile); err != nil {
		logger.Error(c, "参数绑定失败!")
		return serializer.ParamErr("参数绑定失败!", err)
	}

	id := deployFile.DeployId
	if id == "" {
		logger.Error(c, "id 不可为空!")
		return serializer.ParamErr("id不可为空!", fmt.Errorf("id不可为空"))
	}

	// 设置更新时间
	now := time.Now()
	deployFile.UpdateTime = &now

	// 获取当前用户
	if updateBy := c.GetString("id"); updateBy != "" {
		deployFile.UpdateBy = updateBy
	}

	if err := s.Db.Model(&deployFile).Where("deploy_id = ? AND del_flag = ?", id, "0").Updates(&deployFile).Error; err != nil {
		logger.Error(c, "更新部署文件记录失败!")
		return serializer.DBErr("更新部署文件记录失败!", err)
	}
	return serializer.Succ("更新部署文件记录成功!", deployFile)
}

// DeleteByID 根据ID删除部署文件记录
func (s *SysDeployFileService) DeleteByID(c *gin.Context) serializer.Response {
	id := c.Param("id")
	if id == "" {
		logger.Error(c, "id 不可为空!")
		return serializer.ParamErr("id不可为空!", fmt.Errorf("id不可为空"))
	}

	// 软删除
	data := map[string]any{
		"del_flag":    "1",
		"update_time": time.Now(),
		"update_by":   c.GetString("id"),
	}

	// 删除已经部署的文件夹
	deployFile := model.SysDeployFile{}
	if err := s.Db.Where("deploy_id = ?", id).First(&deployFile).Error; err != nil {
		logger.Error(c, "获取部署文件记录失败!")
		return serializer.DBErr("获取部署文件记录失败!", err)
	}

	// 删除 /home/:projectName
	err := os.RemoveAll(filepath.Join("/home", deployFile.ProjectName))
	if err != nil {
		logger.Error(c, "删除部署文件夹失败!")
		return serializer.DBErr("删除部署文件夹失败!", err)
	}

	// 删除数据库记录
	if err := s.Db.Model(&model.SysDeployFile{}).Where("deploy_id = ?", id).Updates(data).Error; err != nil {
		logger.Error(c, "删除部署文件记录失败!")
		return serializer.DBErr("删除部署文件记录失败!", err)
	}

	return serializer.Succ("删除部署文件记录成功!", nil)
}

// GetByCondition 条件查询部署文件记录
func (s *SysDeployFileService) GetByCondition(c *gin.Context) serializer.Response {
	var p types.Params
	if err := c.ShouldBind(&p); err != nil {
		return serializer.ParamErr("参数绑定失败!", err)
	}

	queryStr, args, err := p.ConvertToGormConditions()
	if err != nil {
		logger.Error(c, "参数绑定失败!")
		return serializer.ParamErr("参数绑定失败!", err)
	}

	var total int64
	var deployFiles []model.SysDeployFile
	offset := (p.Page - 1) * p.Limit

	// 构建基础查询
	db := s.Db.Model(&model.SysDeployFile{})

	// 如果有查询条件，添加条件
	if queryStr != "" {
		db = db.Where(queryStr, args...)
	}

	// 排序
	if p.Sort != "" {
		db = db.Order(p.Sort)
	} else {
		db = db.Order("create_time DESC")
	}

	// 执行分页查询
	if err := db.Where("del_flag = ?", "0").Offset(offset).Limit(p.Limit).Find(&deployFiles).Error; err != nil {
		logger.Error(c, "获取部署文件记录失败!")
		return serializer.DBErr("获取部署文件记录失败!", err)
	}

	// 执行总数查询
	if err := db.Where("del_flag = ?", "0").Count(&total).Error; err != nil {
		logger.Error(c, "获取部署文件记录总数失败!")
		return serializer.DBErr("获取部署文件记录总数失败!", err)
	}

	return serializer.Succ("查询成功!", gin.H{
		"total": total,
		"items": deployFiles,
		"page":  p.Page,
		"limit": p.Limit,
	})
}

// UpdateDeployStatus 更新部署状态
func (s *SysDeployFileService) UpdateDeployStatus(deployId, status, errorMsg string) error {
	data := map[string]any{
		"deploy_status": status,
		"update_time":   time.Now(),
	}

	if status == model.DeployStatusSuccess {
		now := time.Now()
		data["deploy_time"] = &now
	}

	if errorMsg != "" {
		data["error_msg"] = errorMsg
	}

	return s.Db.Model(&model.SysDeployFile{}).Where("deploy_id = ?", deployId).Updates(data).Error
}

// UpdateAccessInfo 更新访问信息
func (s *SysDeployFileService) UpdateAccessInfo(deployId string) error {
	now := time.Now()
	return s.Db.Model(&model.SysDeployFile{}).
		Where("deploy_id = ?", deployId).
		Updates(map[string]any{
			"last_access_time": &now,
			"access_count":     gorm.Expr("access_count + 1"),
		}).Error
}

// GetByDomain 根据域名获取部署文件记录
func (s *SysDeployFileService) GetByDomain(domain string) (*model.SysDeployFile, error) {
	var deployFile model.SysDeployFile
	err := s.Db.Where("domain = ? AND status = ? AND del_flag = ?",
		domain, model.DeployFileStatusNormal, "0").First(&deployFile).Error
	if err != nil {
		return nil, err
	}
	return &deployFile, nil
}

// CalculateFileHash 计算文件哈希值
func (s *SysDeployFileService) CalculateFileHash(reader io.Reader) (string, error) {
	hash := md5.New()
	if _, err := io.Copy(hash, reader); err != nil {
		return "", err
	}
	return fmt.Sprintf("%x", hash.Sum(nil)), nil
}