package controllers

import (
	"ColdVerify_server/conf"
	"ColdVerify_server/lib"
	"ColdVerify_server/logs"
	"ColdVerify_server/models/Account"
	"ColdVerify_server/models/Distributor"
	"ColdVerify_server/models/System"
	"ColdVerify_server/models/Task"
	"ColdVerify_server/models/VerifyTemplate"
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"strings"
	"time"

	beego "github.com/beego/beego/v2/server/web"
	"github.com/xuri/excelize/v2"
)

type VerifyTemplateController struct {
	beego.Controller
	User_r Account.Admin // 登陆的用户
}

func (c *VerifyTemplateController) Prepare() {
	GetCookie := c.Ctx.GetCookie("User_tokey")
	GetString := c.GetString("User_tokey")
	fmt.Println(c.Ctx.Request.URL.Path)
	if strings.Contains(c.Ctx.Request.URL.Path, "/VerifyTemplateMapData/Pu") ||
		strings.Contains(c.Ctx.Request.URL.Path, "/VerifyTemplateMapData/Batch_Update") {
		return
	}

	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(GetCookie, GetString)
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	// 经销商只能访问列表接口，不能操作

	//if len(User_r.T_Distributor_id) > 0 {
	//	checkUrl := []string{"Add", "Up", "Del"}
	//	for _, v := range checkUrl {
	//		if strings.Contains(c.Ctx.Request.URL.Path, v) {
	//			c.Data["json"] = lib.JSONS{Code: 202, Msg: "没有操作权限!"}
	//			c.ServeJSON()
	//			return
	//		}
	//	}
	//}

	c.User_r = User_r
}

// 列表 -
func (c *VerifyTemplateController) List() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	var r_jsons lib.R_JSONS
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = conf.Page_size
	}

	T_class, _ := c.GetInt("T_class")
	if T_class <= 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_class Err!"}
		c.ServeJSON()
		return
	}

	T_name := c.GetString("T_name")

	logs.Debug("经销商id", User_r.T_Distributor_id)
	if len(User_r.T_Distributor_id) > 0 {
		var cnt int64
		List, cnt := Distributor.Read_DistributorVerifyTemplate_List(User_r.T_Distributor_id, T_class, T_name, page, page_z)
		page_size := math.Ceil(float64(cnt) / float64(page_z))
		r_jsons.List = List
		r_jsons.Page = page
		r_jsons.Page_size = int(page_size)
		r_jsons.Pages = lib.Func_page(int64(page), int64(page_size))
		r_jsons.Num = int(cnt)

		c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: r_jsons}
		c.ServeJSON()
		return
	}

	var cnt int64
	List, cnt := VerifyTemplate.Read_VerifyTemplate_List(T_class, T_name, page, page_z)
	page_size := math.Ceil(float64(cnt) / float64(page_z))
	r_jsons.List = List
	r_jsons.Page = page
	r_jsons.Page_size = int(page_size)
	r_jsons.Pages = lib.Func_page(int64(page), int64(page_size))
	r_jsons.Num = int(cnt)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: r_jsons}
	c.ServeJSON()
	return
}

// 添加-
func (c *VerifyTemplateController) Add() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_name := c.GetString("T_name")
	T_sort, _ := c.GetInt("T_sort")
	T_class, _ := c.GetInt("T_class")

	var_ := VerifyTemplate.VerifyTemplate{
		T_class: T_class,
		T_name:  T_name,
		T_sort:  T_sort,
	}

	Id, is := VerifyTemplate.Add_VerifyTemplate(var_)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "验证模版", "添加", var_)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: Id}
	c.ServeJSON()
	return
}

// 修改-
func (c *VerifyTemplateController) Up() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_name := c.GetString("T_name")
	T_sort, T_sort_err := c.GetInt("T_sort")

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")

	T_scheme := c.GetString("T_scheme")
	T_reporting := c.GetString("T_reporting")
	T_inspect := c.GetString("T_inspect")
	T_marking := c.GetString("T_marking")
	T_cover := c.GetString("T_cover")
	T_deploy := c.GetString("T_deploy")
	T_examining_report := c.GetString("T_examining_report")
	T_original_record := c.GetString("T_original_record")

	r, is := VerifyTemplate.Read_VerifyTemplate(T_VerifyTemplate_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}

	// .......
	if len(T_name) > 0 {
		r.T_name = T_name
	}
	if len(T_scheme) > 0 {
		r.T_scheme = T_scheme
	}
	if len(T_reporting) > 0 {
		r.T_reporting = T_reporting
	}
	if len(T_inspect) > 0 {
		r.T_inspect = T_inspect
	}
	if len(T_marking) > 0 {
		r.T_marking = T_marking
	}
	if len(T_cover) > 0 {
		r.T_cover = T_cover
	}
	if len(T_examining_report) > 0 {
		r.T_examining_report = T_examining_report
	}
	if len(T_original_record) > 0 {
		r.T_original_record = T_original_record
	}
	if len(T_deploy) > 0 {

		var deployList []VerifyTemplate.VerifyTemplateDeploy
		// 将 布点1|布点2|布点3| 格式替换为 [{"T_name":"布点1","T_scope":"布点范围1"},{"T_name":"布点2","T_scope":"布点范围2"}]
		if strings.Contains(T_deploy, "|") {
			deploys := strings.Split(strings.Trim(T_deploy, "|"), "|")
			for _, v := range deploys {
				deployList = append(deployList, VerifyTemplate.VerifyTemplateDeploy{T_name: v})
			}
			deploy, err := json.Marshal(deployList)
			if err != nil {
				logs.Error("JSON 序列化失败:", err)
				return
			}
			T_deploy = string(deploy)
		} else {
			err := json.Unmarshal([]byte(T_deploy), &deployList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
		}
		r.T_deploy = T_deploy
	}
	if T_sort_err == nil {
		r.T_sort = T_sort
	}

	// .......
	if !VerifyTemplate.Update_VerifyTemplate(r, "T_name", "T_sort", "T_scheme", "T_reporting", "T_inspect", "T_marking", "T_cover", "T_deploy", "T_examining_report", "T_original_record") {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "验证模版", "修改", r)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 删除-
func (c *VerifyTemplateController) Del() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")

	r, is := VerifyTemplate.Read_VerifyTemplate(T_VerifyTemplate_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}
	if !VerifyTemplate.Delete_VerifyTemplate(r) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败！"}
		c.ServeJSON()
		return
	}

	mapList, _ := VerifyTemplate.Read_VerifyTemplateMap_List(T_VerifyTemplate_id, 0, 0)
	for _, v := range mapList {
		if vtm, is := VerifyTemplate.Read_VerifyTemplateMap(v.T_id); is {
			VerifyTemplate.Delete_VerifyTemplateMap(vtm)
		}
	}

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版", "删除", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return

}

// 删除-
func (c *VerifyTemplateController) Get() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")

	r, is := VerifyTemplate.Read_VerifyTemplate(T_VerifyTemplate_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: VerifyTemplate.VerifyTemplateToVerifyTemplate_R(r)}
	c.ServeJSON()
	return

}

// 复制-
func (c *VerifyTemplateController) Copy() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")
	T_name := c.GetString("T_name")
	r, is := VerifyTemplate.Read_VerifyTemplate(T_VerifyTemplate_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}

	var_ := VerifyTemplate.VerifyTemplate{
		T_class:  r.T_class,
		T_name:   T_name,
		T_sort:   r.T_sort,
		T_deploy: r.T_deploy,
	}

	new_id, is := VerifyTemplate.Add_VerifyTemplate(var_)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "复制失败!"}
		c.ServeJSON()
		return
	}

	mapList, _ := VerifyTemplate.Read_VerifyTemplateMap_List(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 = VerifyTemplate.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([]VerifyTemplate.VerifyTemplateMap, 0)
	for i, v := range mapList {
		vtm := VerifyTemplate.VerifyTemplateMap{
			T_id:                idList[i],
			T_VerifyTemplate_id: new_id,
			T_name:              v.T_name,
			T_text:              v.T_text,
			T_label:             v.T_label,
			T_source:            v.T_source,
			T_sort:              v.T_sort,
			T_Required:          v.T_Required,
			T_Construction:      v.T_Construction,
			T_flow_sort:         v.T_flow_sort,
			T_max_time:          v.T_max_time,
			T_min_time:          v.T_min_time,
		}

		mapInsertList = append(mapInsertList, vtm)
	}

	_, is = VerifyTemplate.Add_VerifyTemplateMapMulti(mapInsertList)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "复制失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版", "复制", var_)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: new_id}
	c.ServeJSON()
	return
}

/// -----------------------------------------------------------------------------

// 标签列表 -
func (c *VerifyTemplateController) Map_List() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	var r_jsons lib.R_JSONS

	// page, _ := c.GetInt("page")
	//
	//	if page < 1 {
	//		page = 1
	//	}
	//
	// page_z, _ := c.GetInt("page_z")
	//
	//	if page_z < 1 {
	//		page_z = conf.Page_size
	//	}
	T_sort, _ := c.GetInt("T_sort")           // 排序
	T_flow_sort, _ := c.GetInt("T_flow_sort") // 验证流程排序

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")

	var cnt int64
	List, cnt := VerifyTemplate.Read_VerifyTemplateMap_List(T_VerifyTemplate_id, T_sort, T_flow_sort)
	r_jsons.List = List
	r_jsons.Num = int(cnt)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: r_jsons}
	c.ServeJSON()
	return
}

// 多任务获取标签列表 -
func (c *VerifyTemplateController) Map_List_By_TaskIds() {
	// 验证登录
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	type requestBody struct {
		TaskIds []string `json:"task_ids"`
	}

	var body requestBody

	taskIdsParam := c.GetString("task_ids")
	if len(taskIdsParam) > 0 {
		body.TaskIds = lib.SplitStringSeparator(taskIdsParam, ",")
	}
	T_source, _ := c.GetInt("T_source")

	if len(body.TaskIds) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "任务id不能为空!"}
		c.ServeJSON()
		return
	}

	if T_source == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_source Err!"}
		c.ServeJSON()
		return
	}

	cleanTaskIds := make([]string, 0, len(body.TaskIds))
	seenTaskIds := make(map[string]struct{}, len(body.TaskIds))
	for _, id := range body.TaskIds {
		id = strings.TrimSpace(id)
		if len(id) == 0 {
			continue
		}
		if _, ok := seenTaskIds[id]; ok {
			continue
		}
		seenTaskIds[id] = struct{}{}
		cleanTaskIds = append(cleanTaskIds, id)
	}

	if len(cleanTaskIds) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "有效任务id不能为空!"}
		c.ServeJSON()
		return
	}

	tasks, err := Task.Read_Task_List_By_TaskIds(cleanTaskIds)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "查询任务失败!"}
		c.ServeJSON()
		return
	}

	if len(tasks) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "未查询到任务!"}
		c.ServeJSON()
		return
	}

	foundTaskIds := make(map[string]struct{}, len(tasks))
	templateIdList := make([]string, 0)
	templateIdSet := make(map[string]struct{})
	for _, task := range tasks {
		foundTaskIds[task.T_task_id] = struct{}{}
		if len(task.T_VerifyTemplate_id) == 0 {
			continue
		}
		if _, ok := templateIdSet[task.T_VerifyTemplate_id]; ok {
			continue
		}
		templateIdSet[task.T_VerifyTemplate_id] = struct{}{}
		templateIdList = append(templateIdList, task.T_VerifyTemplate_id)
	}

	missingTaskIds := make([]string, 0)
	for _, id := range cleanTaskIds {
		if _, ok := foundTaskIds[id]; !ok {
			missingTaskIds = append(missingTaskIds, id)
		}
	}
	if len(missingTaskIds) > 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("任务不存在: %s", strings.Join(missingTaskIds, ","))}
		c.ServeJSON()
		return
	}

	if len(templateIdList) == 0 {
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: []interface{}{}}
		c.ServeJSON()
		return
	}

	type templateTag struct {
		VerifyTemplate.VerifyTemplateMap_R
		T_value             string `json:"T_value"`
		T_VerifyTemplate_id string `json:"T_VerifyTemplate_id"`
	}

	tagMap := make(map[string]templateTag)
	for _, templateId := range templateIdList {
		tagList := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(templateId, T_source, 0)
		for _, tag := range tagList {
			if tag.T_label == 3 || tag.T_label == 4 {
				continue
			}
			if len(tag.T_id) == 0 {
				continue
			}
			if _, ok := tagMap[tag.T_id]; ok {
				continue
			}
			tagMap[tag.T_id] = templateTag{
				VerifyTemplateMap_R: VerifyTemplate.VerifyTemplateMapToVerifyTemplateMap_R(tag),
				T_VerifyTemplate_id: templateId,
			}
		}
	}

	if len(tagMap) == 0 {
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: []interface{}{}}
		c.ServeJSON()
		return
	}

	tagIds := make([]string, 0, len(tagMap))
	for id := range tagMap {
		tagIds = append(tagIds, id)
	}
	sort.Strings(tagIds)

	result := make([]templateTag, 0, len(tagIds))
	for _, id := range tagIds {
		result = append(result, tagMap[id])
	}

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: result}
	c.ServeJSON()
}

// 标签添加-
func (c *VerifyTemplateController) Map_Add() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")
	T_name := c.GetString("T_name")
	T_text := c.GetString("T_text")
	T_label, _ := c.GetInt("T_label")
	T_source, _ := c.GetInt("T_source")
	T_sort, _ := c.GetInt("T_sort")
	T_Required, _ := c.GetInt("T_Required")
	T_Construction, _ := c.GetInt("T_Construction")
	T_flow_sort, _ := c.GetInt("T_flow_sort")
	T_max_time, _ := c.GetInt("T_max_time")
	T_min_time, _ := c.GetInt("T_min_time")

	var_ := VerifyTemplate.VerifyTemplateMap{
		T_VerifyTemplate_id: T_VerifyTemplate_id,
		T_name:              T_name,
		T_text:              T_text,
		T_label:             T_label,
		T_source:            T_source,
		T_sort:              T_sort,
		T_Required:          T_Required,
		T_Construction:      T_Construction,
		T_flow_sort:         T_flow_sort,
		T_max_time:          T_max_time,
		T_min_time:          T_min_time,
	}

	Id, is := VerifyTemplate.Add_VerifyTemplateMap(var_)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签", "添加", var_)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: Id}
	c.ServeJSON()
	return
}

// 标签修改-
func (c *VerifyTemplateController) Map_Up() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_name := c.GetString("T_name")
	T_text := c.GetString("T_text")
	T_label, T_label_err := c.GetInt("T_label")
	T_sort, T_sort_err := c.GetInt("T_sort")
	T_source, T_source_err := c.GetInt("T_source")
	T_Required, _ := c.GetInt("T_Required")
	T_Construction, _ := c.GetInt("T_Construction")

	T_min_time, T_min_time_err := c.GetInt("T_min_time")
	T_max_time, T_max_time_err := c.GetInt("T_max_time")
	T_flow_sort, T_flow_sort_err := c.GetInt("T_flow_sort")

	T_id := c.GetString("T_id")

	r, is := VerifyTemplate.Read_VerifyTemplateMap(T_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}

	// .......
	if len(T_name) > 0 {
		r.T_name = T_name
	}
	if len(T_text) > 0 {
		r.T_text = T_text
	}
	if T_label_err == nil {
		r.T_label = T_label
	}
	if T_sort_err == nil {
		r.T_sort = T_sort
	}
	if T_source_err == nil {
		r.T_source = T_source
	}

	if T_min_time_err == nil {
		r.T_min_time = T_min_time
	}
	if T_max_time_err == nil {
		r.T_max_time = T_max_time
	}
	if T_flow_sort_err == nil {
		r.T_flow_sort = T_flow_sort
	}
	r.T_Required = T_Required
	r.T_Construction = T_Construction
	if !VerifyTemplate.Update_VerifyTemplateMap(r, "T_name", "T_label", "T_text", "T_sort", "T_source", "T_min_time", "T_max_time", "T_flow_sort", "T_Required", "T_Construction") {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签", "修改", r)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 标签删除-
func (c *VerifyTemplateController) Map_Del() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_id := c.GetString("T_id")

	if r, is := VerifyTemplate.Read_VerifyTemplateMap(T_id); is {
		if !VerifyTemplate.Delete_VerifyTemplateMap(r) {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败！"}
			c.ServeJSON()
			return
		}
		System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签", "删除", r)
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
		c.ServeJSON()
		return
	}

	c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
	c.ServeJSON()
	return
}

/// -----------------------------------------------------------------------------

// 标签数据列表 -
func (c *VerifyTemplateController) Map_Data_List() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")
	T_source, _ := c.GetInt("T_source")

	T_flow, _ := c.GetInt("T_flow") // app 时间流程

	if T_flow == 0 && T_source == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_source Err!"}
		c.ServeJSON()
		return
	}

	T_task_id := c.GetString("T_task_id")
	task, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_task_id 错误!"}
		c.ServeJSON()
		return
	}

	Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(T_VerifyTemplate_id, T_source, T_flow)
	Data := VerifyTemplate.Read_VerifyTemplateMapData_List(T_source, T_task_id, T_VerifyTemplate_id, Map_List)

	type JSONS struct {
		//必须的大写开头
		Code   int16
		Msg    string
		Data   interface{} // 泛型
		T_step int
	}

	c.Data["json"] = JSONS{Code: 200, Msg: "ok!", Data: Data, T_step: task.T_step}
	c.ServeJSON()
	return
}

// 添加标签数据
func (c *VerifyTemplateController) Map_Data_Pu() {
	var err error

	type RequestBody struct {
		User_tokey            string
		T_source              int
		T_task_id             string
		T_VerifyTemplate_id   string
		T_step                int // 进行步骤下标
		T_submit              int // 1-app 2-报告生成
		T_history             int // 0不保存历史 1保存历史
		VerifyTemplateMapData []VerifyTemplate.VerifyTemplateMapData_R
	}

	var body RequestBody
	data := c.Ctx.Input.RequestBody
	err = json.Unmarshal(data, &body)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "json返序列化失败:" + err.Error()}
		c.ServeJSON()
	}

	logs.Println(fmt.Sprintf("%+v", body))

	User_r, User_is := Account.Verification_Admin(body.User_tokey, "")
	if !User_is {
		System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "未登录-保存", body)

		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	task, is := Task.Read_Task(body.T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_task_id 错误!"}
		c.ServeJSON()
		return
	}
	T_reporting_state := task.T_reporting_state
	task.T_step = body.T_step
	// 点击报告生成时保存
	if body.T_submit == 2 && T_reporting_state == 0 {
		task.T_reporting_state = Task.TaskExaminingReportStateClickGenerate
	}
	// app 提交
	if body.T_submit == 1 && task.T_collection_state == Task.TaskCollectionStateWaitSubmit {
		// 手机app提交修改采集状态为已提交
		task.T_collection_state = Task.TaskCollectionStateSubmitted
		task.T_collection_submit_time = time.Now().Format("2006-01-02 15:04:05")
	}

	if !Task.Update_Task(task, "T_step", "T_reporting_state", "T_collection_state", "T_collection_submit_time") {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改任务步骤失败!"}
		c.ServeJSON()
		return
	}

	// 判断旧的模版id与任务id的模版是否一致，如果不一致则复制旧模板数据到新模板
	if task.T_VerifyTemplate_id != body.T_VerifyTemplate_id {
		copy_task := task
		copy_task.T_VerifyTemplate_id = body.T_VerifyTemplate_id
		_, err = CopyMapData(copy_task, task, 0)
		if err != nil {
			logs.Error("复制旧模板数据到新模板失败", err)
		}

	}

	MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)
	for _, v := range body.VerifyTemplateMapData {
		val := VerifyTemplate.VerifyTemplateMapData{
			T_source:               v.T_source,
			T_task_id:              body.T_task_id,
			T_VerifyTemplate_id:    body.T_VerifyTemplate_id,
			T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
			T_Required:             v.T_Required,
			T_Construction:         v.T_Construction,
			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,
		}
		MapDataList = append(MapDataList, val)

		if v.T_label == 16 && len(v.T_value) > 0 {
			// 判断验证模版标签-描述是否存在该值，不存在则添加
			verifyTemplateMap, exist := VerifyTemplate.Read_VerifyTemplateMap(v.T_VerifyTemplateMap_id)
			if exist {
				// 用|分割成列表
				options := lib.SplitStringSeparator(verifyTemplateMap.T_text, "|")

				// 检查是否存在
				found := false
				for _, opt := range options {
					if opt == v.T_value {
						found = true
						break
					}
				}

				if !found {
					verifyTemplateMap.T_text = verifyTemplateMap.T_text + "|" + v.T_value
					VerifyTemplate.Update_VerifyTemplateMap(verifyTemplateMap, "T_text")
				}
			}
		}
	}
	var T_cover int
	if body.T_submit == 1 && T_reporting_state > 0 {
		T_cover = 1
	}
	ids, is := VerifyTemplate.AddOrUpdate_VerifyTemplateMapData_ADD_History(MapDataList, body.T_source, User_r.T_uuid, body.T_submit, T_cover, body.T_history)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "保存失败"}
		c.ServeJSON()
		return
	}

	// 手机app提交，发送消息通知
	if body.T_submit == 1 {
		_, company_r := Account.Read_User_ByT_uuid(task.T_uuid)
		_, admin_r := Account.Read_Admin_ByT_uuid(task.T_collection)
		System.Add_App_News(task.T_reporting, fmt.Sprintf("【%s-%s】数据采集工程师 %s 已提交", company_r.T_name, task.T_name, admin_r.T_name), "")

	}

	// 报告生成，备份数据
	if body.T_submit == 2 {
		var_ := Task.TaskCopy{
			T_task_id: task.T_task_id,
			T_time:    "报告生成数据",
			T_State:   2,
		}

		T_copy_id, is2 := Task.Add_TaskCopy(var_)
		if !is2 {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败!"}
			c.ServeJSON()
			return
		}
		// 创建数据表
		Task.CREATE_TaskDataCopy("default", T_copy_id)
		// 将数据表存档
		Task.TaskData_Arhiving(task.T_task_id, T_copy_id)

	}

	VerifyTemplate.Check_RequiredFields_HaveValue(body.T_task_id)

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "保存", body)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: ids}
	c.ServeJSON()
	return
}

// 批量修改多个任务的标签数据
func (c *VerifyTemplateController) Map_Data_Batch_Update() {
	var err error

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

	type RequestBody struct {
		User_tokey            string
		T_source              int
		T_task_ids            []string // 多个任务ID
		VerifyTemplateMapData []VerifyTemplateMapData_R
	}

	var body RequestBody
	data := c.Ctx.Input.RequestBody
	err = json.Unmarshal(data, &body)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "json返序列化失败:" + err.Error()}
		c.ServeJSON()
		return
	}

	logs.Println(fmt.Sprintf("%+v", body))

	User_r, User_is := Account.Verification_Admin(body.User_tokey, "")
	if !User_is {
		System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "未登录-批量修改", body)

		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	// 验证任务ID列表
	if len(body.T_task_ids) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "任务ID列表不能为空!"}
		c.ServeJSON()
		return
	}

	// 验证标签数据
	if len(body.VerifyTemplateMapData) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "标签数据不能为空!"}
		c.ServeJSON()
		return
	}

	// 验证所有任务是否存在
	tasks, err := Task.Read_Task_List_By_TaskIds(body.T_task_ids)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "查询任务失败:" + err.Error()}
		c.ServeJSON()
		return
	}

	if len(tasks) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "未找到任何任务!"}
		c.ServeJSON()
		return
	}

	// 检查是否有任务不存在
	foundTaskIds := make(map[string]bool)
	for _, task := range tasks {
		foundTaskIds[task.T_task_id] = true
	}

	missingTaskIds := make([]string, 0)
	for _, taskId := range body.T_task_ids {
		if !foundTaskIds[taskId] {
			missingTaskIds = append(missingTaskIds, taskId)
		}
	}

	if len(missingTaskIds) > 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("以下任务不存在: %s", strings.Join(missingTaskIds, ","))}
		c.ServeJSON()
		return
	}

	// 为每个任务批量更新标签数据
	successCount := 0
	failedTasks := make([]string, 0)
	skippedTasks := make([]string, 0) // 标签名称不匹配的任务

	for _, task := range tasks {
		// 根据任务的模版ID查询该模版下的所有标签
		templateMaps, _ := VerifyTemplate.Read_VerifyTemplateMap_List(task.T_VerifyTemplate_id, 0, 0)
		if len(templateMaps) == 0 {
			failedTasks = append(failedTasks, task.T_task_id)
			logs.Error(fmt.Sprintf("任务 %s 的模版ID %s 下没有标签", task.T_task_id, task.T_VerifyTemplate_id))
			continue
		}

		// 创建标签名称到标签ID的映射
		nameToMapId := make(map[string]string)
		for _, tm := range templateMaps {
			nameToMapId[tm.T_name] = tm.T_id
		}

		// 构建该任务的标签数据列表
		MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)
		matchedCount := 0
		unmatchedLabels := make([]string, 0)

		for _, v := range body.VerifyTemplateMapData {
			// 通过标签名称查找对应的标签ID
			mapId, exists := nameToMapId[v.T_name]
			if !exists {
				unmatchedLabels = append(unmatchedLabels, v.T_name)
				logs.Info(fmt.Sprintf("任务 %s 的模版中不存在标签名称: %s", task.T_task_id, v.T_name))
				continue
			}

			// 查找对应的标签信息以获取标签类型（用于特殊逻辑处理）
			var templateMap VerifyTemplate.VerifyTemplateMap_R
			for _, tm := range templateMaps {
				if tm.T_id == mapId {
					templateMap = tm
					break
				}
			}

			val := VerifyTemplate.VerifyTemplateMapData{
				T_source:               v.T_source,
				T_task_id:              task.T_task_id,
				T_VerifyTemplate_id:    task.T_VerifyTemplate_id, // 使用任务自己的模版ID
				T_VerifyTemplateMap_id: mapId,                    // 使用通过名称匹配到的标签ID
				T_Required:             v.T_Required,             // 使用传入的值
				T_Construction:         v.T_Construction,         // 使用传入的值
				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,                // 使用传入的值
			}
			MapDataList = append(MapDataList, val)
			matchedCount++

			// 处理标签类型16的特殊逻辑
			if templateMap.T_label == 16 && len(v.T_value) > 0 {
				verifyTemplateMap, exist := VerifyTemplate.Read_VerifyTemplateMap(mapId)
				if exist {
					options := lib.SplitStringSeparator(verifyTemplateMap.T_text, "|")
					found := false
					for _, opt := range options {
						if opt == v.T_value {
							found = true
							break
						}
					}
					if !found {
						verifyTemplateMap.T_text = verifyTemplateMap.T_text + "|" + v.T_value
						VerifyTemplate.Update_VerifyTemplateMap(verifyTemplateMap, "T_text")
					}
				}
			}
		}

		// 如果没有任何标签匹配，跳过该任务
		if matchedCount == 0 {
			skippedTasks = append(skippedTasks, task.T_task_id)
			logs.Info(fmt.Sprintf("任务 %s 没有匹配的标签，跳过。未匹配的标签: %s", task.T_task_id, strings.Join(unmatchedLabels, ",")))
			continue
		}

		// 批量更新该任务的标签数据（不保存历史，不覆盖）
		_, is := VerifyTemplate.AddOrUpdate_VerifyTemplateMapData_ADD_History(MapDataList, body.T_source, User_r.T_uuid, 2, 1, 0)
		if !is {
			failedTasks = append(failedTasks, task.T_task_id)
			logs.Error(fmt.Sprintf("任务 %s 标签数据更新失败", task.T_task_id))
			continue
		}

		// 检查必填项
		VerifyTemplate.Check_RequiredFields_HaveValue(task.T_task_id)
		successCount++
	}

	// 记录操作日志
	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "批量修改", fmt.Sprintf("任务数量:%d, 成功:%d, 失败:%d, 跳过:%d", len(body.T_task_ids), successCount, len(failedTasks), len(skippedTasks)))

	// 返回结果
	result := map[string]interface{}{
		"total":        len(body.T_task_ids),
		"success":      successCount,
		"failed":       len(failedTasks),
		"skipped":      len(skippedTasks),
		"failedTasks":  failedTasks,
		"skippedTasks": skippedTasks,
	}

	msg := fmt.Sprintf("成功:%d, 失败:%d, 跳过:%d", successCount, len(failedTasks), len(skippedTasks))
	if len(failedTasks) > 0 {
		msg += fmt.Sprintf(" (失败任务: %s)", strings.Join(failedTasks, ","))
	}
	if len(skippedTasks) > 0 {
		msg += fmt.Sprintf(" (跳过任务: %s)", strings.Join(skippedTasks, ","))
	}

	if len(failedTasks) > 0 || successCount == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: msg, Data: result}
	} else {
		c.Data["json"] = lib.JSONS{Code: 200, Msg: msg, Data: result}
	}
	c.ServeJSON()
	return
}

// 相同模版id复制标签数据
func (c *VerifyTemplateController) Map_Data_Copy2() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_source, _ := c.GetInt("T_source")

	T_flow, _ := c.GetInt("T_flow")

	if T_flow == 0 && T_source == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_source Err!"}
		c.ServeJSON()
		return
	}

	T_copy_task_id := c.GetString("T_copy_task_id")
	copy_task, is := Task.Read_Task(T_copy_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_copy_task_id 错误!"}
		c.ServeJSON()
		return
	}
	T_paste_task_id := c.GetString("T_paste_task_id")
	paste_task, is := Task.Read_Task(T_paste_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_paste_task_id 错误!"}
		c.ServeJSON()
		return
	}

	if copy_task.T_VerifyTemplate_id != paste_task.T_VerifyTemplate_id {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "仅支持相同模版间复制!"}
		c.ServeJSON()
		return
	}

	list := VerifyTemplate.Read_MapData_List(T_source, T_copy_task_id, copy_task.T_VerifyTemplate_id)

	MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)
	for _, v := range list {
		val := VerifyTemplate.VerifyTemplateMapData{
			T_source:               T_source,
			T_task_id:              paste_task.T_task_id,
			T_VerifyTemplate_id:    paste_task.T_VerifyTemplate_id,
			T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
			T_Required:             v.T_Required,
			T_Construction:         v.T_Construction,

			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,
		}
		MapDataList = append(MapDataList, val)
	}
	var ids []int64
	ids, is = VerifyTemplate.AddOrUpdate_VerifyTemplateMapData_ADD_History(MapDataList, T_source, User_r.T_uuid, 0, 0, 0)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "保存失败"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "复制", MapDataList)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: ids}
	c.ServeJSON()
	return
}

// 通过标签名称复制标签数据
func (c *VerifyTemplateController) Map_Data_Copy() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_source, _ := c.GetInt("T_source")

	T_flow, _ := c.GetInt("T_flow")

	if T_flow == 0 && T_source == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_source Err!"}
		c.ServeJSON()
		return
	}

	T_copy_task_id := c.GetString("T_copy_task_id")
	copy_task, is := Task.Read_Task(T_copy_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_copy_task_id 错误!"}
		c.ServeJSON()
		return
	}
	T_paste_task_id := c.GetString("T_paste_task_id")
	paste_task, is := Task.Read_Task(T_paste_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_paste_task_id 错误!"}
		c.ServeJSON()
		return
	}

	ids, err := CopyMapData(copy_task, paste_task, T_source)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: err.Error()}
		c.ServeJSON()
		return
	}

	VerifyTemplate.Check_RequiredFields_HaveValue(T_paste_task_id)

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "通过标签名称复制", fmt.Sprintf("copy_task_id：%s | paste_task_id：%s", T_copy_task_id, T_paste_task_id))

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: ids}
	c.ServeJSON()
	return
}

// 添加标签数据
func (c *VerifyTemplateController) Map_Data_History_List() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	T_task_id := c.GetString("T_task_id")
	T_source, _ := c.GetInt("T_source")
	task, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_task_id 错误!"}
		c.ServeJSON()
		return
	}

	AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())

	UseVerifyTemplateMapDataHistoryTime, _ := lib.TimeStrToTime(conf.UseVerifyTemplateMapDataHistoryTime)
	var Data []VerifyTemplate.VerifyTemplateMapDataHistory_History_List_Res
	if len(conf.UseVerifyTemplateMapDataHistoryTime) > 0 && task.CreateTime.After(UseVerifyTemplateMapDataHistoryTime) {
		Data = VerifyTemplate.Read_VerifyTemplateMapDataHistory_History_List2(T_task_id, T_source, AdminMap)
	} else {
		Data = VerifyTemplate.Read_VerifyTemplateMapDataHistory_History_List(T_task_id, T_source, AdminMap)
	}

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: Data}
	c.ServeJSON()
	return
}

// 标签数据列表 -
func (c *VerifyTemplateController) Map_Data_History_Data_List() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_time := c.GetString("T_time")
	if len(T_time) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "请选择时间点!"}
		c.ServeJSON()
		return
	}
	T_source, _ := c.GetInt("T_source")

	if T_source == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_source Err!"}
		c.ServeJSON()
		return
	}

	T_task_id := c.GetString("T_task_id")
	task, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_task_id 错误!"}
		c.ServeJSON()
		return
	}

	Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(task.T_VerifyTemplate_id, T_source, 0)
	Data := VerifyTemplate.Read_VerifyTemplateMapDataHistory_List(T_source, T_task_id, task.T_VerifyTemplate_id, T_time, Map_List)

	type JSONS struct {
		//必须的大写开头
		Code   int16
		Msg    string
		Data   interface{} // 泛型
		T_step int
	}

	c.Data["json"] = JSONS{Code: 200, Msg: "ok!", Data: Data, T_step: task.T_step}
	c.ServeJSON()
	return
}

// 清除数据
func (c *VerifyTemplateController) Map_Data_Clear_Value() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")
	T_VerifyTemplateMap_id := c.GetString("T_VerifyTemplateMap_id")

	T_task_id := c.GetString("T_task_id")
	_, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_task_id 错误!"}
		c.ServeJSON()
		return
	}

	VerifyTemplate.Clear_VerifyTemplateMapData_T_value(T_task_id, T_VerifyTemplate_id, T_VerifyTemplateMap_id)

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "清除数据", fmt.Sprintf("T_task_id:%s T_VerifyTemplate_id:%s T_VerifyTemplateMap_id:%s", T_task_id, T_VerifyTemplate_id, T_VerifyTemplateMap_id))

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 历史数据恢复
func (c *VerifyTemplateController) Map_Data_History_Recover() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_time := c.GetString("T_time")
	if len(T_time) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "请选择时间点!"}
		c.ServeJSON()
		return
	}
	T_source, _ := c.GetInt("T_source")

	if T_source == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_source Err!"}
		c.ServeJSON()
		return
	}

	T_task_id := c.GetString("T_task_id")
	task, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_task_id 错误!"}
		c.ServeJSON()
		return
	}

	HistoryList := VerifyTemplate.Read_MapDataHistory_List(T_source, T_task_id, task.T_VerifyTemplate_id, T_time)

	list := VerifyTemplate.Read_MapData_List(T_source, T_task_id, task.T_VerifyTemplate_id)
	HistoryListMap := make(map[string]VerifyTemplate.VerifyTemplateMapDataHistory)
	for _, data := range HistoryList {
		HistoryListMap[data.T_VerifyTemplateMap_id] = data
	}

	MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)
	for _, v := range list {
		if len(v.T_value) > 0 {
			continue
		}
		if HistoryListMap[v.T_VerifyTemplateMap_id].T_value == "" {
			continue
		}
		val := VerifyTemplate.VerifyTemplateMapData{
			T_source:               T_source,
			T_task_id:              task.T_task_id,
			T_VerifyTemplate_id:    task.T_VerifyTemplate_id,
			T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
			T_Required:             v.T_Required,
			T_Construction:         v.T_Construction,

			T_flow_sort: v.T_flow_sort,
			T_max_time:  v.T_max_time,
			T_min_time:  v.T_min_time,

			T_value: HistoryListMap[v.T_VerifyTemplateMap_id].T_value,
		}
		MapDataList = append(MapDataList, val)
	}
	var ids []int64
	ids, is = VerifyTemplate.AddOrUpdate_VerifyTemplateMapData(MapDataList)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "保存失败"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "恢复", MapDataList)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: ids}
	c.ServeJSON()
	return
}

// 覆盖数据
func (c *VerifyTemplateController) Map_Data_Cover() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_cover, _ := c.GetInt("T_cover") // 1覆盖 0不覆盖

	T_time := c.GetString("T_time")
	if len(T_time) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "请选择时间点!"}
		c.ServeJSON()
		return
	}
	T_source, _ := c.GetInt("T_source")

	if T_source == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_source Err!"}
		c.ServeJSON()
		return
	}

	T_task_id := c.GetString("T_task_id")
	task, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_task_id 错误!"}
		c.ServeJSON()
		return
	}
	var ids []int64
	if T_cover == 1 {
		HistoryList := VerifyTemplate.Read_MapDataHistory_List(T_source, T_task_id, task.T_VerifyTemplate_id, T_time)

		list := VerifyTemplate.Read_MapData_List(T_source, T_task_id, task.T_VerifyTemplate_id)
		HistoryListMap := make(map[string]VerifyTemplate.VerifyTemplateMapDataHistory)
		for _, data := range HistoryList {
			HistoryListMap[data.T_VerifyTemplateMap_id] = data
		}

		MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)
		for _, v := range list {
			if len(v.T_value) > 0 {
				continue
			}
			if HistoryListMap[v.T_VerifyTemplateMap_id].T_value == "" {
				continue
			}
			val := VerifyTemplate.VerifyTemplateMapData{
				T_source:               T_source,
				T_task_id:              task.T_task_id,
				T_VerifyTemplate_id:    task.T_VerifyTemplate_id,
				T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
				T_Required:             v.T_Required,
				T_Construction:         v.T_Construction,

				T_flow_sort: v.T_flow_sort,
				T_max_time:  v.T_max_time,
				T_min_time:  v.T_min_time,

				T_value: HistoryListMap[v.T_VerifyTemplateMap_id].T_value,
			}
			MapDataList = append(MapDataList, val)
		}

		ids, is = VerifyTemplate.AddOrUpdate_VerifyTemplateMapData(MapDataList)
		if !is {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "保存失败"}
			c.ServeJSON()
			return
		}
		System.Add_UserLogs_T(User_r.T_uuid, "验证模版标签数据", "覆盖", MapDataList)
	}

	task.T_cover = 0
	task.T_backup = ""
	Task.Update_Task(task, "T_cover", "T_backup")

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: ids}
	c.ServeJSON()
	return
}

func (c *VerifyTemplateController) Class_List() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	logs.Debug("经销商id", User_r.T_Distributor_id)
	if len(User_r.T_Distributor_id) > 0 {
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: Distributor.Read_DistributorVerifyTemplateClass_List(User_r.T_Distributor_id)}
		c.ServeJSON()
		return
	}

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: VerifyTemplate.Read_VerifyTemplateClass_List()}
	c.ServeJSON()
	return
}

func (c *VerifyTemplateController) Class_Add() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_name := c.GetString("T_name")
	T_fid, _ := c.GetInt("T_fid")

	var_ := VerifyTemplate.VerifyTemplateClass{
		T_name:  T_name,
		T_fid:   T_fid,
		T_State: 1,
	}

	Id, err := VerifyTemplate.Add_VerifyTemplateClass(var_)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(User_r.T_uuid, "模版分类", "添加", var_)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: Id}
	c.ServeJSON()
	return
}

func (c *VerifyTemplateController) Class_Up() {
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_id, _ := c.GetInt("T_id")
	T_name := c.GetString("T_name")

	R_VerifyTemplateToolClass, err := VerifyTemplate.Read_VerifyTemplateClass_ById(T_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "T_id Err!"}
		c.ServeJSON()
		return
	}

	if len(T_name) > 0 {
		R_VerifyTemplateToolClass.T_name = T_name
	}

	if is := VerifyTemplate.Update_VerifyTemplateClass(R_VerifyTemplateToolClass, "T_name"); !is {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "修改失败"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(User_r.T_uuid, "模版分类", "修改", R_VerifyTemplateToolClass)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

func (c *VerifyTemplateController) Class_Del() {
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_id, _ := c.GetInt("T_id")
	R_VerifyTemplateToolClass, err := VerifyTemplate.Read_VerifyTemplateClass_ById(T_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "T_id Err!"}
		c.ServeJSON()
		return
	}

	ids := VerifyTemplate.ReadVerifyTemplateClassIds_T_path(R_VerifyTemplateToolClass.T_path)

	if is := VerifyTemplate.Delete_VerifyTemplateClass_ByIds(ids); !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs(User_r.T_uuid, "模版分类", "删除", strconv.Itoa(T_id))

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 复制验证模版-分类-标签
func (c *VerifyTemplateController) Class_Copy() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_id, _ := c.GetInt("T_id") // 要复制的信息采集分类id
	T_name := c.GetString("T_name")

	// 查询要复制的信息采集分类id
	R_VerifyTemplateClass, err := VerifyTemplate.Read_VerifyTemplateClass_ById(T_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "T_id Err!"}
		c.ServeJSON()
		return
	}
	if len(T_name) > 0 && T_name != R_VerifyTemplateClass.T_name {
		R_VerifyTemplateClass.T_name = T_name
	} else {
		R_VerifyTemplateClass.T_name = R_VerifyTemplateClass.T_name + "_副本"
	}

	_, err = VerifyTemplate.CopyVerifyTemplateClassTree(R_VerifyTemplateClass.T_path, R_VerifyTemplateClass.T_fid, R_VerifyTemplateClass.T_name)

	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "复制验证模版分类失败"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(User_r.T_uuid, "验证模版分类", "复制", T_id)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

func CopyMapData(copy_task, paste_task Task.Task, T_source int) (ids []int64, err error) {
	copy_task_Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(copy_task.T_VerifyTemplate_id, T_source, 0)
	copy_task_Data := VerifyTemplate.Read_VerifyTemplateMapData_List(T_source, copy_task.T_task_id, copy_task.T_VerifyTemplate_id, copy_task_Map_List)

	Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(paste_task.T_VerifyTemplate_id, T_source, 0)
	Data := VerifyTemplate.Read_VerifyTemplateMapData_List(T_source, paste_task.T_task_id, paste_task.T_VerifyTemplate_id, Map_List)

	copyDataMap := make(map[string]string)
	for _, data := range copy_task_Data {
		copyDataMap[data.T_name] = data.T_value
	}

	MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)
	for _, v := range Data {
		// 已有值则不复制
		if len(v.T_value) > 0 {
			continue
		}
		if copyDataMap[v.T_name] == "" {
			continue
		}
		val := VerifyTemplate.VerifyTemplateMapData{
			T_source:               v.T_source,
			T_task_id:              paste_task.T_task_id,
			T_VerifyTemplate_id:    paste_task.T_VerifyTemplate_id,
			T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
			T_Required:             v.T_Required,
			T_Construction:         v.T_Construction,

			T_flow_sort: v.T_flow_sort,
			T_max_time:  v.T_max_time,
			T_min_time:  v.T_min_time,

			T_value: copyDataMap[v.T_name],
		}
		MapDataList = append(MapDataList, val)
	}

	ids, is := VerifyTemplate.AddOrUpdate_VerifyTemplateMapData_ADD_History(MapDataList, 0, "", 0, 0, 0)
	if !is {
		return ids, errors.New("保存复制数据失败")
	}
	return nil, err
}

// 导出所有模板的标签名称 - 每个模板一个Sheet
func (c *VerifyTemplateController) Export_Labels() {
	// 验证登录
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	// 读取所有模板分类
	classList := VerifyTemplate.Read_VerifyTemplateClass_List()

	// 收集所有模板
	type tpl struct {
		Id         string
		Name       string
		TemplateId string
		ClassName  string
	}
	var tplList []tpl
	var collectTpl func(list []VerifyTemplate.VerifyTemplateClass)
	collectTpl = func(list []VerifyTemplate.VerifyTemplateClass) {
		for _, cls := range list {
			// 当前分类下的模板
			vlist, _ := VerifyTemplate.Read_VerifyTemplate_List(cls.Id, "", 0, 9999)
			for _, v := range vlist {
				tplList = append(tplList, tpl{Id: v.T_VerifyTemplate_id, Name: v.T_name, TemplateId: v.T_VerifyTemplate_id, ClassName: cls.T_name})
			}
			// 递归子分类
			if len(cls.Children) > 0 {
				collectTpl(cls.Children)
			}
		}
	}
	collectTpl(classList)

	// 创建excel
	f := excelize.NewFile()
	sheetName := "Sheet1"
	idx, _ := f.GetSheetIndex(sheetName)

	f.SetActiveSheet(idx)

	// 表头
	f.SetCellValue(sheetName, "A1", "分类名称")
	f.SetCellValue(sheetName, "B1", "模版名称")
	f.SetCellValue(sheetName, "C1", "标签名称")

	// 设置列宽
	f.SetColWidth(sheetName, "A", "A", 30)
	f.SetColWidth(sheetName, "B", "B", 40)
	f.SetColWidth(sheetName, "C", "C", 40)

	line := 1

	// 写入模板与对应标签
	for _, t := range tplList {
		mapList, _ := VerifyTemplate.Read_VerifyTemplateMap_List(t.Id, 0, 0)
		if len(mapList) == 0 {
			line++
			row := line
			f.SetCellValue(sheetName, fmt.Sprintf("A%d", row), t.ClassName)
			f.SetCellValue(sheetName, fmt.Sprintf("B%d", row), t.Name+fmt.Sprintf("[%s]", t.TemplateId))
			continue
		}

		startRow := line + 1
		for idxLabel, m := range mapList {
			line++
			row := line
			if idxLabel == 0 {
				f.SetCellValue(sheetName, fmt.Sprintf("A%d", row), t.ClassName)
				f.SetCellValue(sheetName, fmt.Sprintf("B%d", row), t.Name)
			}
			f.SetCellValue(sheetName, fmt.Sprintf("C%d", row), m.T_name)
		}
		if len(mapList) > 1 {
			f.MergeCell(sheetName, fmt.Sprintf("A%d", startRow), fmt.Sprintf("A%d", line))
			f.MergeCell(sheetName, fmt.Sprintf("B%d", startRow), fmt.Sprintf("B%d", line))
		}
	}

	// 设置居中样式
	styleCenter, styleErr := f.NewStyle(&excelize.Style{
		Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
	})
	if styleErr != nil {
		logs.Error("NewStyle Err:", styleErr)
	} else {
		f.SetCellStyle(sheetName, "A1", fmt.Sprintf("C%d", line), styleCenter)
	}

	// 生成文件
	lib.Create_Dir("./ofile")
	timeStr := time.Now().Format("20060102150405")
	filePath := "ofile/" + timeStr + ".xlsx"
	if err := f.SaveAs(filePath); err != nil {
		logs.Error(lib.FuncName(), err)
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "文件保存失败!"}
		c.ServeJSON()
		return
	}

	// 上传到七牛
	if !lib.Pload_qiniu(filePath, filePath) {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "oss!"}
		c.ServeJSON()
		return
	}

	// 删除本地文件
	err := os.Remove(filePath)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: "https://bzdcoldverifyoss.baozhida.cn/" + filePath}
	c.ServeJSON()
	return
}

// 导出分类和模版名称（带T_VerifyTemplate_id）
func (c *VerifyTemplateController) Export_Class_Template() {
	// 验证登录
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	// 读取所有模板分类
	classList := VerifyTemplate.Read_VerifyTemplateClass_List()

	// 按分类收集模板，使用map存储：分类名称 -> 模板列表
	type tpl struct {
		Name       string
		TemplateId string
	}
	classTemplates := make(map[string][]tpl)

	var collectTpl func(list []VerifyTemplate.VerifyTemplateClass)
	collectTpl = func(list []VerifyTemplate.VerifyTemplateClass) {
		for _, cls := range list {
			// 当前分类下的模板
			vlist, _ := VerifyTemplate.Read_VerifyTemplate_List(cls.Id, "", 0, 9999)
			if len(vlist) > 0 {
				var templates []tpl
				for _, v := range vlist {
					templates = append(templates, tpl{
						Name:       v.T_name,
						TemplateId: v.T_VerifyTemplate_id,
					})
				}
				classTemplates[cls.T_name] = templates
			}
			// 递归子分类
			if len(cls.Children) > 0 {
				collectTpl(cls.Children)
			}
		}
	}
	collectTpl(classList)

	// 创建excel
	f := excelize.NewFile()
	sheetName := "Sheet1"
	idx, _ := f.GetSheetIndex(sheetName)

	f.SetActiveSheet(idx)

	// 找到所有分类中模板数量最多的，作为最大行数
	maxRows := 1 // 至少有一行表头
	classNames := make([]string, 0, len(classTemplates))
	for className, templates := range classTemplates {
		classNames = append(classNames, className)
		if len(templates)+1 > maxRows {
			maxRows = len(templates) + 1
		}
	}

	// Excel列名转换函数：1->A, 2->B, ..., 26->Z, 27->AA, 28->AB, ...
	toExcelColumn := func(n int) string {
		result := ""
		for n > 0 {
			n--
			result = string(rune('A'+n%26)) + result
			n /= 26
		}
		return result
	}

	// 第一行写入分类名称
	for colIndex, className := range classNames {
		colName := toExcelColumn(colIndex + 1)
		cell := fmt.Sprintf("%s1", colName)
		f.SetCellValue(sheetName, cell, className)
		// 设置列宽
		f.SetColWidth(sheetName, colName, colName, 40)
	}

	// 从第二行开始，按列写入每个分类下的模版
	for row := 2; row <= maxRows; row++ {
		for colIndex, className := range classNames {
			templates := classTemplates[className]
			colName := toExcelColumn(colIndex + 1)
			cell := fmt.Sprintf("%s%d", colName, row)
			// 如果该分类还有模版，则写入
			templateIndex := row - 2
			if templateIndex < len(templates) {
				t := templates[templateIndex]
				f.SetCellValue(sheetName, cell, t.Name+fmt.Sprintf("[%s]", t.TemplateId))
			}
		}
	}

	// 设置居中样式
	styleCenter, styleErr := f.NewStyle(&excelize.Style{
		Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
	})
	if styleErr != nil {
		logs.Error("NewStyle Err:", styleErr)
	} else {
		lastCol := toExcelColumn(len(classNames))
		f.SetCellStyle(sheetName, "A1", fmt.Sprintf("%s%d", lastCol, maxRows), styleCenter)
	}

	// 生成文件
	lib.Create_Dir("./ofile")
	timeStr := time.Now().Format("20060102150405")
	filePath := "ofile/" + timeStr + "_class_template.xlsx"
	if err := f.SaveAs(filePath); err != nil {
		logs.Error(lib.FuncName(), err)
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "文件保存失败!"}
		c.ServeJSON()
		return
	}

	// 上传到七牛
	if !lib.Pload_qiniu(filePath, filePath) {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "oss!"}
		c.ServeJSON()
		return
	}

	// 删除本地文件
	err := os.Remove(filePath)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: "https://bzdcoldverifyoss.baozhida.cn/" + filePath}
	c.ServeJSON()
	return
}