ColdVerify_server/models/VerifyTemplate/VerifyTemplateClass.go

package VerifyTemplate

import (
	"ColdVerify_server/lib"
	"ColdVerify_server/logs"
	"errors"
	"fmt"
	_ "github.com/astaxie/beego/cache/redis"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
	"strconv"
	"strings"
)

// 模版
type VerifyTemplateClass struct {
	Id     int    `orm:"column(ID);size(11);auto;pk"`
	T_fid  int    `orm:"size(200);null"` // 父级分类ID，主类 为 0
	T_name string `orm:"size(256);null"` // 标题
	T_path string `orm:"size(256);null"` // 路径

	T_State int `orm:"size(2);default(1)"` // 0 删除（伪删除）   1 正常

	Children []VerifyTemplateClass `orm:"-"`
}

func (t *VerifyTemplateClass) TableName() string {
	return "verify_template_class" // 数据库名称   // ************** 替换 FormulaList **************
}

func init() {
	//注册模型
	orm.RegisterModel(new(VerifyTemplateClass))
}

type VerifyTemplateClass_R struct {
	Id       int
	T_fid    int                   // 项目 id， VerifyTemplateClass.ID
	T_name   string                // 名称
	T_State  int                   // 0 删除（伪删除）   1 正常（已交付）     2 开发中
	Children []VerifyTemplateClass `orm:"-"`
}

// 获取 ById
func Read_VerifyTemplateClass_ById(id int) (r VerifyTemplateClass, err error) {
	o := orm.NewOrm()
	r = VerifyTemplateClass{Id: id, T_State: 1}
	err = o.Read(&r, "Id", "T_State")
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, err
	}
	return r, err
}

// 添加
func Add_VerifyTemplateClass(var_ VerifyTemplateClass) (id int64, err error) {
	o := orm.NewOrm()
	o.Begin()
	id, err = o.Insert(&var_)
	if err != nil {
		o.Rollback()
		return id, err
	}

	T_Path := "/0/" + strconv.Itoa(int(id)) + "/"
	if var_.T_fid != 0 {
		class_r, err := Read_VerifyTemplateClass_ById(var_.T_fid)
		if err != nil {
			o.Rollback()
			return id, err
		}
		T_Path = class_r.T_path + strconv.Itoa(int(id)) + "/"
	}

	var_.Id = int(id)
	var_.T_path = T_Path
	_, err = o.Update(&var_, "T_path")
	if err != nil {
		o.Rollback()
		return id, err
	}
	o.Commit()

	return id, err
}

// 修改
func Update_VerifyTemplateClass(r VerifyTemplateClass, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&r, cols...); err == nil {
		logs.Println("Number of records updated in database:", num)
		return true
	}
	return false
}

// 批量删除
func Delete_VerifyTemplateClass_ByIds(ids []int) bool {
	o := orm.NewOrm()
	o.Begin()
	for _, id := range ids {
		v := VerifyTemplateClass{Id: id, T_State: 0}
		if _, err := o.Update(&v, "T_State"); err != nil {
			o.Rollback()
			return false
		}
	}

	o.Commit()
	return true
}

// 获取列表
func Read_VerifyTemplateClass_List() (r []VerifyTemplateClass) {

	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名
	var map_r []VerifyTemplateClass
	qs := o.QueryTable(new(VerifyTemplateClass))

	cond := orm.NewCondition()

	cond1 := cond.And("T_State", 1)

	qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&map_r)

	r = VerifyTemplateClass_Call(map_r, 0)

	return r

}

func VerifyTemplateClass_Call(list []VerifyTemplateClass, parentId int) []VerifyTemplateClass {
	res := make([]VerifyTemplateClass, 0)
	for _, v := range list {
		if v.T_fid == parentId {
			v.Children = VerifyTemplateClass_Call(list, v.Id)
			res = append(res, v)
		}
	}
	return res
}

// 通过T_pid查询所有子id
func ReadVerifyTemplateClassIds_T_path(T_path string) (VerifyTemplateClassIds []int) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(VerifyTemplateClass))
	var VerifyTemplateClassList []VerifyTemplateClass
	qs.Filter("T_path__startswith", T_path).Filter("T_State", 1).All(&VerifyTemplateClassList)
	for _, v := range VerifyTemplateClassList {
		VerifyTemplateClassIds = append(VerifyTemplateClassIds, v.Id)
	}
	return VerifyTemplateClassIds
}

// 通过T_path查询所有子验证分类
func ReadVerifyTemplateClassList_T_path(T_path string, parentId int) (r []VerifyTemplateClass) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(VerifyTemplateClass))
	var VerifyTemplateClassList []VerifyTemplateClass
	qs.Filter("T_path__startswith", T_path).Filter("T_State", 1).All(&VerifyTemplateClassList)
	r = VerifyTemplateClass_Call(VerifyTemplateClassList, parentId)
	return r
}

// 递归复制节点
func copyVerifyTemplateClass(o orm.Ormer, r *VerifyTemplateClass, newParentId int, parentPath string) (*VerifyTemplateClass, error) {

	// 创建新节点
	verifyTemplateClass := VerifyTemplateClass{
		T_fid:   newParentId,
		T_name:  r.T_name, // 添加副本标识
		T_State: 1,
		// T_path 将在插入后更新
	}

	// 插入数据库
	newVerifyTemplateClassId, err := o.Insert(&verifyTemplateClass)
	if err != nil {
		return nil, err
	}

	newPath := parentPath + strconv.Itoa(verifyTemplateClass.Id) + "/"

	// 更新路径
	verifyTemplateClass.Id = int(newVerifyTemplateClassId)
	verifyTemplateClass.T_path = newPath
	_, err = o.Update(&verifyTemplateClass, "T_path")
	if err != nil {
		return nil, err
	}

	// 复制子节点
	for _, child := range r.Children {
		_, err = copyVerifyTemplateClass(o, &child, verifyTemplateClass.Id, newPath)
		if err != nil {
			return nil, err
		}
	}
	// 分类1
	//  ----模版
	//	--------标签
	// 分类2
	//   -- 子分类
	// 2 复制分类下的模版
	// 3 复制模版下的标签
	VerifyTemplateList, _ := Read_VerifyTemplate_List(r.Id, "", 0, 9999)
	for _, v := range VerifyTemplateList {
		verifyTemplate, is := Read_VerifyTemplate(v.T_VerifyTemplate_id)
		if !is {
			return nil, errors.New("查询验证模版失败")
		}

		newVerifyTemplate := VerifyTemplate{
			T_class: verifyTemplateClass.Id, // 新的分类id
			T_name:  verifyTemplate.T_name,
			T_sort:  verifyTemplate.T_sort,
		}

		newVerifyTemplateId, is := Add_VerifyTemplate(newVerifyTemplate)
		if !is {
			return nil, errors.New("复制验证模版失败")
		}

		// 复制模版下面的标签
		mapList, _ := Read_VerifyTemplateMap_List(v.T_VerifyTemplate_id, 0, 0)
		tempMap := make(map[string]struct{})
		idList := make([]string, len(mapList))
		// 生成mapList长度的T_id
		for i := 0; i < len(mapList); i++ {
			// 生成编号
			rand_x := 0
			T_id := ""
			for true {
				T_id = lib.GetRandstring(4, "", int64(rand_x))
				_, is = Read_VerifyTemplateMap(T_id)
				if !is {
					if _, ok := tempMap[T_id]; !ok {
						break
					}
				}
				rand_x += 1
			}
			tempMap[T_id] = struct{}{}
			idList[i] = T_id
		}
		mapInsertList := make([]VerifyTemplateMap, 0)
		for i, m := range mapList {
			vtm := VerifyTemplateMap{
				T_id:                idList[i],
				T_VerifyTemplate_id: newVerifyTemplateId,
				T_name:              m.T_name,
				T_text:              m.T_text,
				T_label:             m.T_label,
				T_sort:              m.T_sort,
			}

			mapInsertList = append(mapInsertList, vtm)
		}

		_, is = Add_VerifyTemplateMapMulti(mapInsertList)
		if !is {
			return nil, errors.New("复制验证模版标签失败")
		}
	}

	return &verifyTemplateClass, nil
}

func CopyVerifyTemplateClassTree(T_path string, parentId int, T_name string) (newRoot *VerifyTemplateClass, err error) {
	// 获取原始节点及其子树
	o := orm.NewOrm()
	srcNode := ReadVerifyTemplateClassList_T_path(T_path, parentId)
	if len(srcNode) == 0 {
		return nil, errors.New("查询验证模版分类失败")
	}
	srcNode[0].T_name = T_name
	// 开启事务
	err = o.Begin()
	if err != nil {
		o.Rollback()
		return nil, fmt.Errorf("事务启动失败: %v", err)
	}

	s := strings.Split(strings.Trim(T_path, "/"), "/")
	parentPath := fmt.Sprintf("/%s/", strings.Join(s[:len(s)-1], "/"))
	// 递归复制
	newRoot, err = copyVerifyTemplateClass(o, &srcNode[0], parentId, parentPath) // 假设复制到根目录
	if err != nil {
		o.Rollback()
		return nil, err
	}

	// 提交事务
	if err = o.Commit(); err != nil {
		o.Rollback()
		return nil, fmt.Errorf("事务提交失败: %v", err)
	}

	return newRoot, nil
}