ColdVerify_server/models/VerifyTemplate/VerifyTemplateMapData.go

package VerifyTemplate

import (
	"ColdVerify_server/lib"
	"ColdVerify_server/logs"
	"ColdVerify_server/models/Task"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
	"strings"
	"time"
)

// 模版
type VerifyTemplateMapData struct {
	Id                     int    `orm:"column(ID);size(11);auto;pk"`
	T_source               int    `orm:"size(2);"`             // 来源 0-所有 1-方案 2-报告 3-表单
	T_task_id              string `orm:"index,size(256);null"` // 任务id
	T_VerifyTemplate_id    string `orm:"index,size(256);null"` // 模版id
	T_VerifyTemplateMap_id string `orm:"index,size(256);null"` // 标签id
	T_value                string `orm:"size(1024);null"`      // 内容
	T_Required             int    `orm:"size(2);default(0)"`   // 必填项  1 必填   0 非必填
	T_Construction         int    `orm:"size(2);default(0)"`   // 实施（是否在APP 上显示）  1 显示   0 不显示

	// 验证流程
	T_flow_sort int `orm:"size(2);default(0)"` // 验证流程排序
	T_max_time  int `orm:"size(256);null"`     // 验证流程最大时间
	T_min_time  int `orm:"size(256);null"`     // 验证流程最小时间

	T_start_time int64 `orm:"size(256);null"` // 开始时间 app

	CreateTime time.Time `orm:"column(create_time);type(timestamp);null;auto_now_add"` //auto_now_add 第一次保存时才设置时间
	UpdateTime time.Time `orm:"column(update_time);type(timestamp);null;auto_now"`     //auto_now 每次 model 保存时都会对时间自动更新
}

type VerifyTemplateMapData_R struct {
	T_id                   int
	T_VerifyTemplateMap_id string // 标签id
	T_source               int
	T_label                int    //
	T_name                 string // 标题
	T_text                 string // 标题
	T_value                string //
	T_Required             int    //
	T_Construction         int    //
	// 验证流程
	T_flow_sort int // 验证流程排序
	T_max_time  int // 验证流程最大时间
	T_min_time  int // 验证流程最小时间

	T_start_time int64 // 开始时间 app
}

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

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

}

// -------------------------------------------------------------
func VerifyTemplateMapToVerifyTemplateMapData_R(T VerifyTemplateMap) (T_r VerifyTemplateMapData_R) {
	T_r.T_VerifyTemplateMap_id = T.T_id
	T_r.T_source = T.T_source
	T_r.T_label = T.T_label
	T_r.T_name = T.T_name
	T_r.T_text = T.T_text
	T_r.T_Required = T.T_Required
	T_r.T_Construction = T.T_Construction

	T_r.T_flow_sort = T.T_flow_sort
	T_r.T_max_time = T.T_max_time
	T_r.T_min_time = T.T_min_time

	T_r.T_value = ""
	return T_r
}

func VerifyTemplateMapDataToVerifyTemplateMapData_R(T VerifyTemplateMap, VerifyTemplateMapData map[string]VerifyTemplateMapData) (T_r VerifyTemplateMapData_R) {
	T_r.T_VerifyTemplateMap_id = T.T_id
	T_r.T_source = T.T_source
	T_r.T_label = T.T_label
	T_r.T_name = T.T_name
	T_r.T_text = T.T_text
	T_r.T_Required = T.T_Required
	T_r.T_Construction = T.T_Construction

	T_r.T_flow_sort = T.T_flow_sort
	T_r.T_max_time = T.T_max_time
	T_r.T_min_time = T.T_min_time

	T_r.T_value = ""
	if v, ok := VerifyTemplateMapData[T.T_id]; ok {
		T_r.T_value = v.T_value
		if T.T_label == 3 {
			T_r.T_value = DeleteDeduplicateValue(v.T_value)
		}
		T_r.T_start_time = v.T_start_time
	}
	return T_r
}

// 去掉重复测点
func DeleteDeduplicateValue(input string) (output string) {
	// 分割字符串
	parts := lib.SplitStringSeparator(input, "|")

	// 使用map去重
	seen := make(map[string]bool)
	var result []string

	for _, part := range parts {
		if !seen[part] {
			seen[part] = true
			result = append(result, part)
		}
	}

	// 重新拼接
	return strings.Join(result, "|")
}

// T_submit  // 1-app 2-报告生成
// T_cover   // 是否覆盖-app 0覆盖 1不覆盖
// T_history // 保存历史数据
// 添加或更新模版数据 并添加历史数据
func AddOrUpdate_VerifyTemplateMapData_ADD_History(List []VerifyTemplateMapData, T_source int, T_uuid string, T_submit, T_cover, T_history int) (ids []int64, is bool) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(VerifyTemplateMapData))
	o.Begin()
	T_time := time.Now().Format("2006-01-02 15:04:05")
	var err error
	var T_task_id string
	for _, v := range List {
		if len(T_task_id) == 0 {
			T_task_id = v.T_task_id
		}
		// app 不覆盖，只保存历史记录
		if !(T_submit == 1 && T_cover == 1) {
			var r VerifyTemplateMapData
			// 创建验证模版数据，有则更新，没有则创建
			err = qs.Filter("T_task_id", v.T_task_id).Filter("T_VerifyTemplate_id", v.T_VerifyTemplate_id).Filter("T_VerifyTemplateMap_id", v.T_VerifyTemplateMap_id).One(&r)
			if err != nil {
				if err.Error() == orm.ErrNoRows.Error() {
					id, err := o.Insert(&v)
					if err != nil {
						logs.Error(lib.FuncName(), err)
						o.Rollback()
						return ids, false
					}
					ids = append(ids, id)
				} else {
					logs.Error(lib.FuncName(), err)
					o.Rollback()
					return ids, false
				}
			}

			// 更新验证模版数据
			if r.Id > 0 && (len(v.T_value) > 0 || v.T_start_time > 0) {
				if v.T_start_time == 1 {
					v.T_start_time = 0
				}
				v.Id = r.Id
				//_, err = o.Update(&v, "T_flow_sort", "T_max_time", "T_min_time", "T_value")
				_, err = o.QueryTable(new(VerifyTemplateMapData)).Filter("T_task_id", v.T_task_id).Filter("T_VerifyTemplate_id", v.T_VerifyTemplate_id).
					Filter("T_VerifyTemplateMap_id", v.T_VerifyTemplateMap_id).Update(orm2.Params{
					"T_flow_sort": v.T_flow_sort, "T_max_time": v.T_max_time, "T_min_time": v.T_min_time, "T_value": v.T_value, "T_start_time": v.T_start_time,
				})
				if err != nil {
					logs.Error(lib.FuncName(), err)
					o.Rollback()
					return ids, false
				}
				ids = append(ids, int64(r.Id))
			}
		}

		// 添加历史记录
		_, err = o.Insert(&VerifyTemplateMapDataHistory{
			T_source:               v.T_source,
			T_task_id:              v.T_task_id,
			T_time:                 T_time,
			T_uuid:                 T_uuid,
			T_submit_source:        T_source,
			T_VerifyTemplate_id:    v.T_VerifyTemplate_id,
			T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
			T_value:                v.T_value,
			T_Required:             v.T_Required,
			T_flow_sort:            v.T_flow_sort,
			T_Construction:         v.T_Construction,
			T_max_time:             v.T_max_time,
			T_min_time:             v.T_min_time,
		})
		if err != nil {
			logs.Error(lib.FuncName(), err)
			o.Rollback()
			return ids, false
		}

	}

	if T_history == 1 && len(T_task_id) > 0 {
		// 添加历史记录
		_, err = o.Insert(&VerifyDataHistoryRecord{
			T_task_id:       T_task_id,
			T_time:          T_time,
			T_uuid:          T_uuid,
			T_submit_source: T_source,
		})
		if err != nil {
			logs.Error(lib.FuncName(), err)
			o.Rollback()
			return ids, false
		}
	}

	// 修改覆盖数据和备份信息
	if T_cover == 1 {
		_, err = o.QueryTable(new(Task.Task)).Filter("T_task_id", T_task_id).Update(orm2.Params{
			"T_cover":  1,
			"T_backup": T_time,
		})
		if err != nil {
			logs.Error(lib.FuncName(), err)
			o.Rollback()
			return ids, false
		}
		Task.Redis_Task_DelK(T_task_id)
	} else {

		_, err = o.QueryTable(new(Task.Task)).Filter("T_task_id", T_task_id).Update(orm2.Params{
			"T_cover":  0,
			"T_backup": "",
		})
		if err != nil {
			logs.Error(lib.FuncName(), err)
			o.Rollback()
			return ids, false
		}
		Task.Redis_Task_DelK(T_task_id)
	}

	o.Commit()

	return ids, true
}

// ---------------- 特殊方法 -------------------
// 添加
func AddOrUpdate_VerifyTemplateMapData(List []VerifyTemplateMapData) (ids []int64, is bool) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(VerifyTemplateMapData))
	o.Begin()
	for _, v := range List {
		var r VerifyTemplateMapData
		// 创建验证模版数据，有则更新，没有则创建
		err := qs.Filter("T_task_id", v.T_task_id).Filter("T_VerifyTemplate_id", v.T_VerifyTemplate_id).Filter("T_VerifyTemplateMap_id", v.T_VerifyTemplateMap_id).One(&r)
		if err != nil {
			if err.Error() == orm.ErrNoRows.Error() {
				id, err := o.Insert(&v)
				if err != nil {
					logs.Error(lib.FuncName(), err)
					o.Rollback()
					return ids, false
				}
				ids = append(ids, id)
			} else {
				logs.Error(lib.FuncName(), err)
				o.Rollback()
				return ids, false
			}
		}

		// 更新验证模版数据
		if r.Id > 0 && (len(v.T_value) > 0 || v.T_start_time > 0) {
			if v.T_start_time == 1 {
				v.T_start_time = 0
			}
			v.Id = r.Id
			//_, err = o.Update(&v, "T_flow_sort", "T_max_time", "T_min_time", "T_value")
			_, err = o.QueryTable(new(VerifyTemplateMapData)).Filter("T_task_id", v.T_task_id).Filter("T_VerifyTemplate_id", v.T_VerifyTemplate_id).
				Filter("T_VerifyTemplateMap_id", v.T_VerifyTemplateMap_id).Update(orm2.Params{
				"T_flow_sort": v.T_flow_sort, "T_max_time": v.T_max_time, "T_min_time": v.T_min_time, "T_value": v.T_value, "T_start_time": v.T_start_time,
			})
			if err != nil {
				logs.Error(lib.FuncName(), err)
				o.Rollback()
				return ids, false
			}
			ids = append(ids, int64(r.Id))
		}

	}

	o.Commit()

	return ids, true
}

// 获取列表
func Read_VerifyTemplateMapData_List(T_source int, T_task_id, T_VerifyTemplate_id string, Map_List []VerifyTemplateMap) []VerifyTemplateMapData_R {

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

	cond1 := cond.And("T_task_id", T_task_id).And("T_VerifyTemplate_id", T_VerifyTemplate_id)

	qs.SetCond((*orm2.Condition)(cond1)).All(&r)

	if len(r) == 0 {
		// 转换
		var VerifyTemplateMapData_r []VerifyTemplateMapData_R
		for k, v := range Map_List {
			Data_r := VerifyTemplateMapToVerifyTemplateMapData_R(v)
			Data_r.T_id = k
			VerifyTemplateMapData_r = append(VerifyTemplateMapData_r, Data_r)
		}

		return VerifyTemplateMapData_r
	}

	// 转换
	var VerifyTemplateMapData_r []VerifyTemplateMapData_R
	for k, v := range Map_List {
		Data_r := VerifyTemplateMapDataToVerifyTemplateMapData_R(v, VerifyTemplateMapDataToMap(r))
		Data_r.T_id = k
		VerifyTemplateMapData_r = append(VerifyTemplateMapData_r, Data_r)
	}
	return VerifyTemplateMapData_r
}

// 获取列表
func Read_MapData_List(T_source int, T_task_id, T_VerifyTemplate_id string) []VerifyTemplateMapData {

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

	var source []int
	switch T_source {
	case 1:
		source = []int{0, 1, 7}
	case 2:
		source = []int{0, 2, 3, 7}
	case 3:
		source = []int{3}
	case 4:
		source = []int{0, 5, 8}
	case 5:
		source = []int{0, 6, 8}
	}

	cond1 := cond.And("T_task_id", T_task_id).And("T_VerifyTemplate_id", T_VerifyTemplate_id)

	if len(source) > 0 {
		cond1 = cond1.And("T_source__in", source)
	}

	qs.SetCond((*orm2.Condition)(cond1)).All(&r)

	return r
}

func VerifyTemplateMapDataToMap(T []VerifyTemplateMapData) map[string]VerifyTemplateMapData {
	maps := make(map[string]VerifyTemplateMapData, len(T))
	for _, v := range T {
		if _, ok := maps[v.T_VerifyTemplateMap_id]; ok {
			continue
		}
		maps[v.T_VerifyTemplateMap_id] = v
	}
	return maps
}

// 清除T_value数据
func Clear_VerifyTemplateMapData_T_value(T_task_id, T_VerifyTemplate_id, T_VerifyTemplateMap_id string) (err error) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(VerifyTemplateMapData))

	var r VerifyTemplateMapData
	// 创建验证模版数据，有则更新，没有则创建
	err = qs.Filter("T_task_id", T_task_id).Filter("T_VerifyTemplate_id", T_VerifyTemplate_id).Filter("T_VerifyTemplateMap_id", T_VerifyTemplateMap_id).One(&r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return err
	}
	r.T_value = ""
	_, err = o.Update(&r, "T_value")
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return err
	}
	return nil
}