go-svc-configure/internal/service/startup/create_config_startup.go

package startup

import (
	"context"
	"fmt"

	_ "git.x2erp.com/qdy/go-base/config/subconfigs"
	"git.x2erp.com/qdy/go-base/ctx"
	"git.x2erp.com/qdy/go-base/logger"
	"git.x2erp.com/qdy/go-base/model/request/configreq"
	"git.x2erp.com/qdy/go-base/model/response"
	"git.x2erp.com/qdy/go-base/util"
	"git.x2erp.com/qdy/go-db/factory/database"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/dao"
	"github.com/jmoiron/sqlx"
)

func CreateStartupConfig(req *configreq.ConfigRequest, ctx context.Context, dbFactory *database.DBFactory, reqCtx *ctx.RequestContext) *response.QueryResult[int64] {
	logger.Debug("CreateStartupConfig-开始创建启动配置")

	param := dao.GetConfigStartupParam(req)
	if len(param.IDS) == 0 {
		logger.ErrorC(reqCtx, "参数为空")
		return util.CreateErrorResult[int64]("参数为空", reqCtx)
	}

	// 1. 验证配置字段与元信息一致性
	logger.Debug("开始验证配置字段与元信息一致性")
	metaRecords, err := dao.ValidateConfigFieldsWithMeta(ctx, dbFactory, param)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("配置字段验证失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("配置字段验证失败: %v", err), reqCtx)
	}
	logger.Debug("配置字段验证通过")

	// 2. 验证字段值类型
	logger.Debug("开始验证字段值类型")
	if err := dao.ValidateFieldValues(req, metaRecords); err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("字段值验证失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("字段值验证失败: %v", err), reqCtx)
	}
	logger.Debug("字段值验证通过")

	// 3. 获取数据库连接
	db := dbFactory.GetDB()

	// 4. 开始事务
	logger.Debug("开始数据库事务")
	tx, err := db.BeginTxx(ctx, nil)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("开始事务失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("开始事务失败: %v", err), reqCtx)
	}

	defer func() {
		if p := recover(); p != nil {
			tx.Rollback()
			panic(p)
		}
	}()

	countDel, err := deleteExistingConfig(ctx, tx, param)

	if err != nil {
		tx.Rollback()
		logger.ErrorC(reqCtx, fmt.Sprintf("删除现有配置失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("删除现有配置失败: %v", err), reqCtx)
	}
	logger.Debug(fmt.Sprintf("已删除配置: %s 的 %d 个字段", req.YamlRoot, countDel))

	// 6. 生成批量插入数据
	logger.Debug("开始生成批量插入数据")
	records := generateBatchInsertData(param, reqCtx.UserID)
	logger.Debug(fmt.Sprintf("生成了 %d 条配置记录", len(records)))

	// 7. 批量插入配置记录
	logger.Debug("开始批量插入配置记录")
	count, err := batchInsertConfigRecords(ctx, tx, records)
	if err != nil {
		tx.Rollback()
		logger.ErrorC(reqCtx, fmt.Sprintf("插入配置记录失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("插入配置记录失败: %v", err), reqCtx)
	}
	logger.Debug(fmt.Sprintf("成功插入 %d 条记录", len(records)))

	// 8. 提交事务
	logger.Debug("正在提交事务")
	if err := tx.Commit(); err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("提交事务失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("提交事务失败: %v", err), reqCtx)
	}

	logger.Debug("启动配置创建完成")
	return util.CreateSuccessResultData[int64](count, reqCtx)
}

func DeleteStartupConfig(req *configreq.ConfigRequest, ctx context.Context, dbFactory *database.DBFactory, reqCtx *ctx.RequestContext) *response.QueryResult[int64] {

	logger.Debug("DeleteStartupConfig-开始删除启动配置")

	param := dao.GetConfigStartupParam(req)
	if len(param.IDS) == 0 {
		logger.ErrorC(reqCtx, "参数为空")
		return util.CreateErrorResult[int64]("参数为空", reqCtx)
	}
	// 获取数据库连接并开始事务
	db := dbFactory.GetDB()
	tx, err := db.BeginTxx(ctx, nil)
	if err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("开始事务失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("开始事务失败: %v", err), reqCtx)
	}

	// 执行删除
	count, err := deleteExistingConfig(ctx, tx, param)
	if err != nil {
		tx.Rollback()
		logger.ErrorC(reqCtx, fmt.Sprintf("删除配置失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("删除配置失败: %v", err), reqCtx)
	}

	// 提交事务
	if err := tx.Commit(); err != nil {
		logger.ErrorC(reqCtx, fmt.Sprintf("提交事务失败: %v", err))
		return util.CreateErrorResult[int64](fmt.Sprintf("提交事务失败: %v", err), reqCtx)
	}

	logger.Debug(fmt.Sprintf("成功删除配置: %s 的 %d 个字段", req.YamlRoot, len(req.ConfigFields)))
	return util.CreateSuccessResultData[int64](count, reqCtx)
}

// 删除现有配置
func deleteExistingConfig(ctx context.Context, tx *sqlx.Tx, param *dao.ConfigMetaParam) (int64, error) {

	query := `DELETE FROM config_startup WHERE  id IN (?)`

	query, args, err := sqlx.In(query, param.IDS)
	if err != nil {
		return -1, fmt.Errorf("构建删除语句失败: %v", err)
	}

	result, err := tx.ExecContext(ctx, query, args...)

	return dao.ValidateResultRowsAffected(result, err, len(param.IDS))

}

// 生成批量插入数据
func generateBatchInsertData(param *dao.ConfigMetaParam, creator string) []interface{} {

	req := param.ConfigRequest

	records := make([]interface{}, 0, len(req.ConfigFields))

	for _, configInfo := range req.ConfigFields {

		id := param.GetID(configInfo.YamlName)
		record := map[string]interface{}{
			"id":          id,
			"config_name": req.YamlRoot,
			"yaml_name":   configInfo.YamlName,
			"yaml_value":  configInfo.YamlValue,
			"creator":     creator,
			"created_at":  "CURRENT_TIMESTAMP",
		}
		records = append(records, record)
	}

	return records
}

// 批量插入配置记录
func batchInsertConfigRecords(ctx context.Context, tx *sqlx.Tx, records []interface{}) (int64, error) {
	if len(records) == 0 {
		return 0, nil
	}

	query := `
        INSERT INTO config_startup 
        (id,config_name, yaml_name, yaml_value, creator, created_at)
        VALUES (:id, :config_name, :yaml_name, :yaml_value, :creator, CURRENT_TIMESTAMP)
    `

	result, err := tx.NamedExecContext(ctx, query, records)

	return dao.ValidateResultRowsAffected(result, err, len(records))

}