ColdVerify_local/controllers/TaskHandle.go

package controllers

import (
	"ColdVerify_local/lib"
	"ColdVerify_local/logs"
	"ColdVerify_local/models/Device"
	"ColdVerify_local/models/Task"
	"ColdVerify_local/models/VerifyTemplate"
	"fmt"
	beego "github.com/beego/beego/v2/server/web"
	"github.com/beego/beego/v2/server/web/context"
	"math"
	"net/http"
	"sort"
	"strings"
	"time"
)

type TaskDataHandleController struct {
	beego.Controller
}

/*
同区域数据缺失
*/

// 自动添加缺失终端，取关联绑定终端平均复制
func (c *TaskDataHandleController) SSE_Automatically_add_missing_terminal() {

	T_task_id := c.GetString("T_task_id") //  v26nplogbwt1
	println("T_task_id:", T_task_id)
	c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream")
	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"})

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"})
		return
	}

	DeviceClassList_r := Device.Read_DeviceClassList_List_id(Task_r.T_class)
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "终端总共：" + lib.To_string(len(DeviceClassList_r)) + " 正在检查自检探头..."})
	for _, class_ := range DeviceClassList_r {
		_, cnt := Task.Read_TaskData_ById_List(Task_r.T_task_id, class_.T_sn, class_.T_id, "", "", 0, 1)
		if cnt == 0 {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "找到" + class_.T_id + class_.T_remark + " 自检探头"})
			// 获取 备注 下面关联设备，数量
			var DeviceClassListT_remark_r_list_MAX int64
			DeviceClassListT_remark_r_list_MAX = 0 //最大值
			DeviceClassListT_remark_r := Device.Read_DeviceClassList_List_id_T_remark(class_.T_class, class_.T_remark)
			for _, DeviceClassListT_remark_r_list := range DeviceClassListT_remark_r {
				_, cnt = Task.Read_TaskData_ById_List(Task_r.T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "", "", 0, 9999)
				logs.Println(DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "数量：", cnt)
				if DeviceClassListT_remark_r_list_MAX < cnt {
					DeviceClassListT_remark_r_list_MAX = cnt
				}
			}
			// 筛选 符合的数量 终端
			SN_List_sn := 9
			SN_List_s := "" // 2023282551724643,003|2023282534778895,004|
			SN_List_xn := 9
			SN_List_x := "" // 2023282551724643,003|2023282534778895,004|
			SN_List := ""
			//SN_List_num := 0 // 数量  只能两个
			CopyTime := ""  //复制的起点 2025-01-07 15:18:00
			StartTime := "" // 2025-01-07 15:18:00
			EndTime := ""   //2025-01-07 21:17:00
			for _, DeviceClassListT_remark_r_list := range DeviceClassListT_remark_r {
				List_data, cnt := Task.Read_TaskData_ById_List(Task_r.T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "", "", 0, 9999)
				if len(List_data) == 0 {
					//lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: DeviceClassListT_remark_r_list.T_id+"没有找到对应数据!"})
					continue
				}
				if DeviceClassListT_remark_r_list_MAX == cnt {
					logs.Println(DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "数量：", cnt)
					CopyTime = List_data[len(List_data)-1].T_time
					StartTime = List_data[len(List_data)-1].T_time
					EndTime = List_data[0].T_time

					absc := int(math.Abs(float64(lib.To_int(DeviceClassListT_remark_r_list.T_id) - lib.To_int(class_.T_id))))

					if absc < SN_List_sn {
						SN_List_s = DeviceClassListT_remark_r_list.T_sn + "," + DeviceClassListT_remark_r_list.T_id + "|"
						SN_List_sn = absc
						continue
					}
					if absc < SN_List_xn {
						SN_List_x = DeviceClassListT_remark_r_list.T_sn + "," + DeviceClassListT_remark_r_list.T_id + "|"
						SN_List_xn = absc
						continue
					}

					//SN_List_num++
					//if SN_List_num >= 2 {
					//	break // 数量  只能两个
					//}
				}
			}
			logs.Println("复制参数：", SN_List, CopyTime, StartTime, EndTime)
			if len(SN_List_x) == 0 || len(SN_List_s) == 0 {
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "[" + class_.T_remark + "]中没有找到 至少2条 完整可用数据"})
				return
			}

			SN_List = SN_List_s + SN_List_x

			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: class_.T_sn + "|" + class_.T_id + "开始平均复制到" + SN_List})

			// 开始平均复制到
			CopySN := class_.T_sn
			CopyID := class_.T_id

			copyTime, _ := lib.TimeStrToTime(CopyTime)
			endTime, _ := lib.TimeStrToTime(EndTime)
			startTime, _ := lib.TimeStrToTime(StartTime)
			// 时间间隔 s
			T_saveT := 60
			CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04:05")

			SN_List_Split := strings.Split(strings.Trim(SN_List, "|"), "|")
			sn_id1 := strings.Split(SN_List_Split[0], ",")

			sn1, id_str1 := sn_id1[0], sn_id1[1]
			sn_id2 := strings.Split(SN_List_Split[1], ",")

			sn2, id_str2 := sn_id2[0], sn_id2[1]
			List1, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn1, id_str1, StartTime, EndTime, 0, 9999)
			List2, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn2, id_str2, StartTime, EndTime, 0, 9999)
			num := len(List1)
			if len(List2) < len(List1) {
				num = len(List2)
			}
			var list []Task.TaskData_
			ct := copyTime
			for i := 0; i < num; i++ {
				if List1[i].T_time != List2[i].T_time {
					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: fmt.Sprintf("%s【%s】、%s【%s】时间不一致", List1[i].T_id, List1[i].T_time, List2[i].T_id, List2[i].T_time)})
					return
				}
				T_t := (List1[i].T_t + List2[i].T_t) / 2
				T_rh := (List1[i].T_rh + List2[i].T_rh) / 2
				list = append(list, Task.TaskData_{
					T_sn:   CopySN,
					T_id:   CopyID,
					T_t:    T_t,
					T_rh:   T_rh,
					T_time: ct.Format("2006-01-02 15:04:05"),
				})
				ct = ct.Add(time.Second * time.Duration(T_saveT))
			}
			Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, CopySN, CopyID, CopyTime, CopyEndTime)
			for i, taskData := range list {
				Task.InsertTaskData(Task_r.T_task_id, taskData)

				if i%100 == 0 {
					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("%d/%d", i, len(list))})
				}
			}

		}

	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 自动添加缺失数据，取关联绑定终端平均复制
func (c *TaskDataHandleController) SSE_Automatically_add_missing_data() {

	T_task_id := c.GetString("T_task_id") //  v26nplogbwt1

	c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream")
	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"})

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"})
		return
	}
	// 时间间隔 s
	T_saveT := 60

	// 获取 备注 下面关联设备，数量
	var Devicedata_list_MAX int64
	Devicedata_list_MAX = 0 //最大值
	DeviceClassList_list := Device.Read_DeviceClassList_List_id(Task_r.T_class)
	for _, DeviceClassListT_remark_r_list := range DeviceClassList_list {
		_, cnt := Task.Read_TaskData_ById_List(Task_r.T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "", "", 0, 9999)

		if Devicedata_list_MAX < cnt {
			Devicedata_list_MAX = cnt
		}
	}
	logs.Println("数据标准数量：", Devicedata_list_MAX)
	// 选择 数据缺失的终端
	for _, DeviceClassList_r := range DeviceClassList_list {
		list, cnt := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, DeviceClassList_r.T_sn, DeviceClassList_r.T_id, "", "", 0, 9999)
		if Devicedata_list_MAX != cnt {

			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: DeviceClassList_r.T_id + " 终端自检数据 ,自检：" + lib.To_string(Devicedata_list_MAX-cnt) + " "})
			for i := 0; i < len(list)-1; i++ {
				current := list[i].T_time
				next := list[i+1].T_time
				ct, _ := time.Parse("2006-01-02 15:04:05", current)
				nt, _ := time.Parse("2006-01-02 15:04:05", next)
				interval := nt.Unix() - ct.Unix()
				//logs.Debug("时间间隔：", interval, "保存时间：", saveTime)
				//fmt.Println("当前：", current, "下一个：", next)
				if int(interval) > T_saveT {
					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "找到自检点 " + current + " ~ " + next + " 开始自检"})

					// -------------------- 开始 平均复制到  --------------------

					// 获取 备注 下面关联设备，数量
					var DeviceClassListT_remark_r_list_MAX int64
					DeviceClassListT_remark_r_list_MAX = 0 //最大值
					DeviceClassListT_remark_r := Device.Read_DeviceClassList_List_id_T_remark(DeviceClassList_r.T_class, DeviceClassList_r.T_remark)
					for _, DeviceClassListT_remark_r_list := range DeviceClassListT_remark_r {
						_, cnt = Task.Read_TaskData_ById_List(Task_r.T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "", "", 0, 9999)
						logs.Println(DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "数量：", cnt)
						if DeviceClassListT_remark_r_list_MAX < cnt {
							DeviceClassListT_remark_r_list_MAX = cnt
						}
					}
					// 筛选 符合的数量 终端
					SN_List_sn := 9
					SN_List_s := "" // 2023282551724643,003|2023282534778895,004|
					SN_List_xn := 9
					SN_List_x := "" // 2023282551724643,003|2023282534778895,004|
					SN_List := ""   // 2023282551724643,003|2023282534778895,004|
					//SN_List_num := 0     // 数量  只能两个
					CopyTime := current  //复制的起点 2025-01-07 15:18:00
					StartTime := current // 2025-01-07 15:18:00
					EndTime := next      //2025-01-07 21:17:00
					for _, DeviceClassListT_remark_r_list := range DeviceClassListT_remark_r {
						List_data, cnt := Task.Read_TaskData_ById_List(Task_r.T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "", "", 0, 9999)
						if DeviceClassListT_remark_r_list_MAX == cnt {
							logs.Println(DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "数量：", cnt)
							//SN_List += DeviceClassListT_remark_r_list.T_sn + "," + DeviceClassListT_remark_r_list.T_id + "|"
							//CopyTime = List_data[len(List_data)-1].T_time
							//StartTime = List_data[len(List_data)-1].T_time
							EndTime = List_data[0].T_time

							absc := int(math.Abs(float64(lib.To_int(DeviceClassListT_remark_r_list.T_id) - lib.To_int(DeviceClassList_r.T_id))))

							if absc < SN_List_sn {
								SN_List_s = DeviceClassListT_remark_r_list.T_sn + "," + DeviceClassListT_remark_r_list.T_id + "|"
								SN_List_sn = absc
								continue
							}
							if absc < SN_List_xn {
								SN_List_x = DeviceClassListT_remark_r_list.T_sn + "," + DeviceClassListT_remark_r_list.T_id + "|"
								SN_List_xn = absc
								continue
							}

						}
					}
					logs.Println("复制参数：", SN_List, CopyTime, StartTime, EndTime)
					if len(SN_List_x) == 0 || len(SN_List_s) == 0 {
						lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "[" + DeviceClassList_r.T_remark + "] 中没有找到 至少2条 完整可用数据"})
						return
					}
					SN_List = SN_List_s + SN_List_x

					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: DeviceClassList_r.T_sn + "|" + DeviceClassList_r.T_id + "开始平均复制到" + SN_List})

					// 开始平均复制到
					CopySN := DeviceClassList_r.T_sn
					CopyID := DeviceClassList_r.T_id

					copyTime, _ := lib.TimeStrToTime(CopyTime)
					endTime, _ := lib.TimeStrToTime(EndTime)
					startTime, _ := lib.TimeStrToTime(StartTime)

					CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04:05")

					SN_List_Split := strings.Split(strings.Trim(SN_List, "|"), "|")
					sn_id1 := strings.Split(SN_List_Split[0], ",")

					sn1, id_str1 := sn_id1[0], sn_id1[1]
					sn_id2 := strings.Split(SN_List_Split[1], ",")

					sn2, id_str2 := sn_id2[0], sn_id2[1]
					List1, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn1, id_str1, StartTime, EndTime, 0, 9999)
					List2, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn2, id_str2, StartTime, EndTime, 0, 9999)
					num := len(List1)
					if len(List2) < len(List1) {
						num = len(List2)
					}
					var list []Task.TaskData_
					ct := copyTime
					for i := 0; i < num; i++ {
						if List1[i].T_time != List2[i].T_time {
							lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: fmt.Sprintf("%s【%s】、%s【%s】时间不一致", List1[i].T_id, List1[i].T_time, List2[i].T_id, List2[i].T_time)})
							return
						}
						T_t := (List1[i].T_t + List2[i].T_t) / 2
						T_rh := (List1[i].T_rh + List2[i].T_rh) / 2
						list = append(list, Task.TaskData_{
							T_sn:   CopySN,
							T_id:   CopyID,
							T_t:    T_t,
							T_rh:   T_rh,
							T_time: ct.Format("2006-01-02 15:04:05"),
						})
						ct = ct.Add(time.Second * time.Duration(T_saveT))
					}
					Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, CopySN, CopyID, CopyTime, CopyEndTime)
					for i, taskData := range list {
						Task.InsertTaskData(Task_r.T_task_id, taskData)

						if i%100 == 0 {
							lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("%d/%d", i, len(list))})
						}
					}

				}
			}

		}
	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 数据持续时间    x   分钟 没有变化
func (c *TaskDataHandleController) SSE_Continuously_unchanged_data() {

	T_task_id := c.GetString("T_task_id")     //  v26nplogbwt1
	T_timeout, _ := c.GetInt("T_timeout", 30) //  持续时间

	c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream")
	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"})

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"})
		return
	}

	// 获取 备注 下面关联设备，数量
	var Devicedata_list_MAX int64
	Devicedata_list_MAX = 0 //最大值
	DeviceClassList_list := Device.Read_DeviceClassList_List_id(Task_r.T_class)
	for _, DeviceClassListT_remark_r_list := range DeviceClassList_list {
		_, cnt := Task.Read_TaskData_ById_List(Task_r.T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "", "", 0, 9999)

		if Devicedata_list_MAX < cnt {
			Devicedata_list_MAX = cnt
		}
	}
	logs.Println("数据标准数量：", Devicedata_list_MAX)
	// 选择 数据缺失的终端
	for _, DeviceClassList_r := range DeviceClassList_list {
		TaskData_list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, DeviceClassList_r.T_sn, DeviceClassList_r.T_id, "", "", 0, 9999)

		var t_data float32
		t_data = 0
		t_data_num := 0

		current := ""
		next := ""
		for i := 0; i < len(TaskData_list)-1; i++ {
			if t_data == TaskData_list[i].T_t {
				if t_data_num == 0 {
					current = TaskData_list[i].T_time

				}
				t_data_num += 1
				continue

			} else {
				if t_data_num > T_timeout {
					next = TaskData_list[i].T_time

					CopyFromPositionAverage(c.Ctx.ResponseWriter, Task_r.T_task_id, DeviceClassList_r.T_class, DeviceClassList_r.T_remark, DeviceClassList_r.T_sn, DeviceClassList_r.T_id, current, next)
				}
				// 清空标致
				t_data = TaskData_list[i].T_t
				t_data_num = 0
				continue
			}

		}

	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 平均复制到
func CopyFromPositionAverage(c *context.Response, T_task_id string, T_class int, T_remark, T_sn, T_id, current, next string) {
	fmt.Println("平均复制到 CopyFromPositionAverage：", T_task_id, T_class, T_remark, T_sn, T_id, current, next)

	lib.SseWriteJSON(c, lib.JSONSSE{State: 0, Msg: "找到 " + T_id + " 无数据变化, 时间 " + current + " ~ " + next})

	// -------------------- 开始 平均复制到  --------------------
	// 时间间隔 s
	T_saveT := 60
	// 获取 备注 下面关联设备，数量
	var DeviceClassListT_remark_r_list_MAX int64
	DeviceClassListT_remark_r_list_MAX = 0 //最大值
	DeviceClassListT_remark_r := Device.Read_DeviceClassList_List_id_T_remark(T_class, T_remark)
	for _, DeviceClassListT_remark_r_list := range DeviceClassListT_remark_r {
		_, cnt := Task.Read_TaskData_ById_List(T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, current, next, 0, 9999)
		logs.Println(DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "数量：", cnt)
		if DeviceClassListT_remark_r_list_MAX < cnt {
			DeviceClassListT_remark_r_list_MAX = cnt
		}
	}
	// 筛选 符合的数量 终端
	SN_List := ""        // 2023282551724643,003|2023282534778895,004|
	SN_List_num := 0     // 数量  只能两个
	CopyTime := current  //复制的起点 2025-01-07 15:18:00
	StartTime := current // 2025-01-07 15:18:00
	EndTime := next      //2025-01-07 21:17:00
	for _, DeviceClassListT_remark_r_list := range DeviceClassListT_remark_r {
		_, cnt := Task.Read_TaskData_ById_List(T_task_id, DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, current, next, 0, 9999)
		if DeviceClassListT_remark_r_list_MAX == cnt {
			logs.Println(DeviceClassListT_remark_r_list.T_sn, DeviceClassListT_remark_r_list.T_id, "数量：", cnt)
			SN_List += DeviceClassListT_remark_r_list.T_sn + "," + DeviceClassListT_remark_r_list.T_id + "|"
			//CopyTime = List_data[len(List_data)-1].T_time
			//StartTime = List_data[len(List_data)-1].T_time
			//EndTime = List_data[0].T_time
			SN_List_num++
			if SN_List_num >= 2 {
				break // 数量  只能两个
			}
		}
	}
	logs.Println("复制参数：", SN_List, CopyTime, StartTime, EndTime)
	if SN_List_num != 2 {
		lib.SseWriteJSON(c, lib.JSONSSE{State: 2, Msg: "[" + T_remark + "] 中没有找到 至少2条 完整可用数据"})
		return
	}
	lib.SseWriteJSON(c, lib.JSONSSE{State: 0, Msg: T_sn + "|" + T_id + "开始平均复制到" + SN_List})

	// 开始平均复制到
	CopySN := T_sn
	CopyID := T_id

	copyTime, _ := lib.TimeStrToTime(CopyTime)
	endTime, _ := lib.TimeStrToTime(EndTime)
	startTime, _ := lib.TimeStrToTime(StartTime)

	CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04:05")

	SN_List_Split := strings.Split(strings.Trim(SN_List, "|"), "|")
	sn_id1 := strings.Split(SN_List_Split[0], ",")

	sn1, id_str1 := sn_id1[0], sn_id1[1]
	sn_id2 := strings.Split(SN_List_Split[1], ",")

	sn2, id_str2 := sn_id2[0], sn_id2[1]
	List1, _ := Task.Read_TaskData_ById_List_AES(T_task_id, sn1, id_str1, StartTime, EndTime, 0, 9999)
	List2, _ := Task.Read_TaskData_ById_List_AES(T_task_id, sn2, id_str2, StartTime, EndTime, 0, 9999)
	num := len(List1)
	if len(List2) < len(List1) {
		num = len(List2)
	}

	fmt.Println("num:", num)
	var TaskData_list []Task.TaskData_
	ct := copyTime
	for TaskData_i := 0; TaskData_i < num; TaskData_i++ {
		if List1[TaskData_i].T_time != List2[TaskData_i].T_time {
			lib.SseWriteJSON(c, lib.JSONSSE{State: 2, Msg: fmt.Sprintf("%s【%s】、%s【%s】时间不一致", List1[TaskData_i].T_id, List1[TaskData_i].T_time, List2[TaskData_i].T_id, List2[TaskData_i].T_time)})
			return
		}
		T_t := (List1[TaskData_i].T_t + List2[TaskData_i].T_t) / 2
		T_rh := (List1[TaskData_i].T_rh + List2[TaskData_i].T_rh) / 2
		TaskData_list = append(TaskData_list, Task.TaskData_{
			T_sn:   CopySN,
			T_id:   CopyID,
			T_t:    T_t,
			T_rh:   T_rh,
			T_time: ct.Format("2006-01-02 15:04:05"),
		})
		ct = ct.Add(time.Second * time.Duration(T_saveT))
	}
	fmt.Println("TaskData_list:", len(TaskData_list))
	Task.DeleteTaskDataByTimeRange(T_task_id, CopySN, CopyID, CopyTime, CopyEndTime)
	for taskData_i, taskData := range TaskData_list {
		Task.InsertTaskData(T_task_id, taskData)

		if taskData_i%100 == 0 {
			lib.SseWriteJSON(c, lib.JSONSSE{State: 0, Msg: fmt.Sprintf("%d/%d", taskData_i, len(TaskData_list))})
		}
	}

}

// 绑定点与终端比对  （绑定点数据自检）
func (c *TaskDataHandleController) SSE_Comparison_between_binding_points_and_terminals() {

	T_task_id := c.GetString("T_task_id")            //  v26nplogbwt1
	T_deviation, _ := c.GetFloat("T_deviation", 1.0) //  持续时间

	c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream")
	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"})

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"})
		return
	}

	// -------------------- 温湿度绑定点1 --------------------
	温湿度绑定点1_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点1")
	if len(温湿度绑定点1_list) != 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温湿度绑定点1 中找到 " + lib.To_string(len(温湿度绑定点1_list)) + "条，只允许 一条数据！"})
		return
	}
	监测终端01_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "监测终端01")
	if len(监测终端01_list) != 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "监测终端01 中找到 " + lib.To_string(len(监测终端01_list)) + "条，只允许 一条数据！"})
		return
	}
	温度分布特性的测试与分析_开始时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）开始时间")
	温度分布特性的测试与分析_结束时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）结束时间")
	if len(温度分布特性的测试与分析_开始时间) == 0 || len(温度分布特性的测试与分析_结束时间) == 0 {
		温度分布特性的测试与分析_开始时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）开始时间")
		温度分布特性的测试与分析_结束时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）结束时间")
	}
	if len(温度分布特性的测试与分析_开始时间) == 0 || len(温度分布特性的测试与分析_结束时间) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "请检查 温度分布特性的测试与分析时间！"})
		return
	}
	fmt.Println("温湿度绑定点1   数据准备：", 温湿度绑定点1_list[0].T_id, 监测终端01_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)

	var 温湿度绑定点1vga, 监测终端01vga, vgaca float64
	温湿度绑定点1vga = Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点1_list[0].T_sn, 温湿度绑定点1_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
	监测终端01vga = Task.Read_TaskData_AVG(T_task_id, 监测终端01_list[0].T_sn, 监测终端01_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
	vgaca = math.Round((监测终端01vga-温湿度绑定点1vga)*100) / 100.0

	for T_deviation < math.Abs(vgaca) {
		// 缩放
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行缩放 数据！温湿度绑定点1 平均值:" +
			lib.To_string(温湿度绑定点1vga) + "℃ 监测终端01vga 平均值" + lib.To_string(监测终端01vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})

		Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, 温湿度绑定点1_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, 0.95)

		// 偏移
		温湿度绑定点1vga = Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点1_list[0].T_sn, 温湿度绑定点1_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		监测终端01vga = Task.Read_TaskData_AVG(T_task_id, 监测终端01_list[0].T_sn, 监测终端01_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		vgaca = math.Round((监测终端01vga-温湿度绑定点1vga)*100) / 100.0
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行偏移 数据！温湿度绑定点1 平均值:" +
			lib.To_string(温湿度绑定点1vga) + "℃ 监测终端01vga 平均值" + lib.To_string(监测终端01vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})
		Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, 温湿度绑定点1_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, math.Round(((监测终端01vga-温湿度绑定点1vga)*0.8)*100)/100.0)

		温湿度绑定点1vga = Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点1_list[0].T_sn, 温湿度绑定点1_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		监测终端01vga = Task.Read_TaskData_AVG(T_task_id, 监测终端01_list[0].T_sn, 监测终端01_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		vgaca = math.Round((监测终端01vga-温湿度绑定点1vga)*100) / 100.0

	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "数据满足要求！温湿度绑定点1 平均值:" + lib.To_string(温湿度绑定点1vga) + "℃ 监测终端01vga 平均值" + lib.To_string(监测终端01vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ ！"})

	// -------------------- 温湿度绑定点2 --------------------

	温湿度绑定点2_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点2")
	if len(温湿度绑定点2_list) != 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "温湿度绑定点2 没找到，跳过 温湿度绑定点2"})
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})
		return
	}
	监测终端02_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "监测终端02")
	if len(监测终端02_list) != 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "监测终端02 中找到 " + lib.To_string(len(监测终端02_list)) + "条，布点终端异常！"})
		return
	}

	fmt.Println("温湿度绑定点2  数据准备：", 温湿度绑定点2_list[0].T_id, 监测终端02_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)

	var 温湿度绑定点2vga, 监测终端02vga float64
	温湿度绑定点2vga = Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点2_list[0].T_sn, 温湿度绑定点2_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
	监测终端02vga = Task.Read_TaskData_AVG(T_task_id, 监测终端02_list[0].T_sn, 监测终端02_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
	vgaca = math.Round((监测终端02vga-温湿度绑定点2vga)*100) / 100.0

	for T_deviation < math.Abs(vgaca) {
		// 缩放
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行缩放 数据！温湿度绑定点2 平均值:" +
			lib.To_string(温湿度绑定点2vga) + "℃ 监测终端02vga 平均值" + lib.To_string(监测终端02vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})

		Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, 温湿度绑定点2_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, 0.95)

		// 偏移
		温湿度绑定点2vga = Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点2_list[0].T_sn, 温湿度绑定点2_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		监测终端02vga = Task.Read_TaskData_AVG(T_task_id, 监测终端02_list[0].T_sn, 监测终端02_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		vgaca = math.Round((监测终端02vga-温湿度绑定点2vga)*100) / 100.0
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行偏移 数据！温湿度绑定点2 平均值:" +
			lib.To_string(温湿度绑定点2vga) + "℃ 监测终端02vga 平均值" + lib.To_string(监测终端02vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})
		Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, 温湿度绑定点2_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, math.Round(((监测终端02vga-温湿度绑定点2vga)*0.8)*100)/100.0)

		温湿度绑定点2vga = Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点2_list[0].T_sn, 温湿度绑定点2_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		监测终端02vga = Task.Read_TaskData_AVG(T_task_id, 监测终端02_list[0].T_sn, 监测终端02_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
		vgaca = math.Round((监测终端02vga-温湿度绑定点2vga)*100) / 100.0

	}
	//
	//lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "数据满足要求！温湿度绑定点2 平均值:" + lib.To_string(温湿度绑定点2vga) + "℃ 监测终端02vga 平均值" + lib.To_string(监测终端02vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ ！"})
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 绑定点与冷热点比对  （冷热点数据自检）
func (c *TaskDataHandleController) SSE_Compare_binding_points_with_cold_and_hot_spots() {

	T_task_id := c.GetString("T_task_id")            //  v26nplogbwt1
	T_deviation, _ := c.GetFloat("T_deviation", 1.0) //  持续时间

	c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream")
	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"})

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"})
		return
	}

	// ------------------
	温度分布特性的测试与分析_开始时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）开始时间")
	温度分布特性的测试与分析_结束时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）结束时间")
	if len(温度分布特性的测试与分析_开始时间) == 0 || len(温度分布特性的测试与分析_结束时间) == 0 {
		温度分布特性的测试与分析_开始时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）开始时间")
		温度分布特性的测试与分析_结束时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）结束时间")
	}
	// 均匀性布点   产品存放区域测点
	部点终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "均匀性布点")
	部点终端_list = append(部点终端_list, Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "产品存放区域测点")...)
	if len(部点终端_list) <= 2 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "均匀性布点，产品存放区域测点 太少了，至少两条以上！"})
		return
	}
	type AVGClassList struct {
		T_id  string
		T_vga float64
	}
	var AVGClassList_r []AVGClassList
	for _, i2 := range 部点终端_list {
		AVGClassList_r = append(AVGClassList_r, AVGClassList{T_id: i2.T_id, T_vga: Task.Read_TaskData_AVG(T_task_id, i2.T_sn, i2.T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)})
	}
	// 使用 sort.Slice 对切片进行排序
	sort.Slice(AVGClassList_r, func(i, j int) bool {
		return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga // 降序排序
		// 如果需要降序排序，可以使用：return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga
	})
	fmt.Println("AVGClassList_r:", AVGClassList_r)

	// -------  温湿度绑定点
	温湿度绑定点1_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点1")
	if len(温湿度绑定点1_list) != 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温湿度绑定点1 中找到 " + lib.To_string(len(温湿度绑定点1_list)) + "条，布点终端异常！"})
		return
	}
	温湿度绑定点2_list_is := true
	温湿度绑定点2_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "温湿度绑定点2")
	if len(温湿度绑定点2_list) != 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "温湿度绑定点2 没找到，将 温湿度绑定点1 设置低点"})
		温湿度绑定点2_list = 温湿度绑定点1_list
		温湿度绑定点2_list_is = false
	}
	温湿度绑定点1vga := Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点1_list[0].T_sn, 温湿度绑定点1_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)
	温湿度绑定点2vga := Task.Read_TaskData_AVG(T_task_id, 温湿度绑定点2_list[0].T_sn, 温湿度绑定点2_list[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)

	if 温湿度绑定点1vga == 温湿度绑定点2vga {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "温湿度绑定点1 与 温湿度绑定点2 平均值相等，将 进行上下偏移处理！"})
		温湿度绑定点1vga += T_deviation / 2
		温湿度绑定点2vga -= T_deviation / 2
		T_deviation /= 2
	}

	var 温湿度绑定点vga_H, 温湿度绑定点vga_L AVGClassList
	if 温湿度绑定点1vga > 温湿度绑定点2vga {
		温湿度绑定点vga_H.T_id = 温湿度绑定点1_list[0].T_id
		温湿度绑定点vga_H.T_vga = 温湿度绑定点1vga
		温湿度绑定点vga_L.T_id = 温湿度绑定点2_list[0].T_id
		温湿度绑定点vga_L.T_vga = 温湿度绑定点2vga
	} else {
		温湿度绑定点vga_L.T_id = 温湿度绑定点1_list[0].T_id
		温湿度绑定点vga_L.T_vga = 温湿度绑定点1vga
		温湿度绑定点vga_H.T_id = 温湿度绑定点2_list[0].T_id
		温湿度绑定点vga_H.T_vga = 温湿度绑定点2vga
	}

	fmt.Println("温湿度绑定点:", 温湿度绑定点vga_H, 温湿度绑定点vga_L)

	// -------------------- 温湿度绑定点vga_H --------------------
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "------ 进行 高点处理 ------"})

	var vgaca float64

	vgaca = math.Round((温湿度绑定点vga_H.T_vga-AVGClassList_r[0].T_vga)*100) / 100.0

	for T_deviation < math.Abs(vgaca) {
		// 缩放
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行缩放 数据！热点" + lib.To_string(AVGClassList_r[0].T_id) + " 平均值:" + lib.To_string(AVGClassList_r[0].T_vga) +
			"℃ 高点 " + lib.To_string(温湿度绑定点vga_H.T_id) + " 平均值" + lib.To_string(温湿度绑定点vga_H.T_vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})

		Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, AVGClassList_r[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, 0.95)

		// 偏移
		// 均匀性布点   产品存放区域测点
		AVGClassList_r = AVGClassList_r[:0] // 清空切片
		for _, i2 := range 部点终端_list {
			AVGClassList_r = append(AVGClassList_r, AVGClassList{T_id: i2.T_id, T_vga: Task.Read_TaskData_AVG(T_task_id, i2.T_sn, i2.T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)})
		}
		// 使用 sort.Slice 对切片进行排序
		sort.Slice(AVGClassList_r, func(i, j int) bool {
			return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga // 降序排序
			// 如果需要降序排序，可以使用：return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga
		})
		fmt.Println("AVGClassList_r:", AVGClassList_r)
		vgaca = math.Round((温湿度绑定点vga_H.T_vga-AVGClassList_r[0].T_vga)*100) / 100.0

		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行偏移 数据！热点" + lib.To_string(AVGClassList_r[0].T_id) + " 平均值:" + lib.To_string(AVGClassList_r[0].T_vga) +
			"℃ 高点 " + lib.To_string(温湿度绑定点vga_H.T_id) + " 平均值" + lib.To_string(温湿度绑定点vga_H.T_vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})

		Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, AVGClassList_r[0].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, math.Round(((vgaca)*0.8)*100)/100.0)

		// 均匀性布点   产品存放区域测点
		AVGClassList_r = AVGClassList_r[:0] // 清空切片
		for _, i2 := range 部点终端_list {
			AVGClassList_r = append(AVGClassList_r, AVGClassList{T_id: i2.T_id, T_vga: Task.Read_TaskData_AVG(T_task_id, i2.T_sn, i2.T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)})
		}
		// 使用 sort.Slice 对切片进行排序
		sort.Slice(AVGClassList_r, func(i, j int) bool {
			return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga // 降序排序
			// 如果需要降序排序，可以使用：return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga
		})
		fmt.Println("AVGClassList_r:", AVGClassList_r)
		vgaca = math.Round((温湿度绑定点vga_H.T_vga-AVGClassList_r[0].T_vga)*100) / 100.0

	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "热点 数据满足要求！热点" + lib.To_string(AVGClassList_r[0].T_id) + " 平均值:" + lib.To_string(AVGClassList_r[0].T_vga) +
		"℃ 高点 " + lib.To_string(温湿度绑定点vga_H.T_id) + " 平均值" + lib.To_string(温湿度绑定点vga_H.T_vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ "})

	// -------------------- 温湿度绑定点vga_L --------------------
	if !温湿度绑定点2_list_is {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "低点跳过处理！"})
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "------ 进行 低点处理 ------"})

	vgaca = math.Round((温湿度绑定点vga_L.T_vga-AVGClassList_r[len(AVGClassList_r)-1].T_vga)*100) / 100.0
	for T_deviation < math.Abs(vgaca) {
		// 缩放
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行缩放 数据！冷点" + lib.To_string(AVGClassList_r[len(AVGClassList_r)-1].T_id) + " 平均值:" + lib.To_string(AVGClassList_r[len(AVGClassList_r)-1].T_vga) +
			"℃ 低点 " + lib.To_string(温湿度绑定点vga_L.T_id) + " 平均值" + lib.To_string(温湿度绑定点vga_L.T_vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})

		Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, AVGClassList_r[len(AVGClassList_r)-1].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, 0.95)

		// 偏移
		// 均匀性布点   产品存放区域测点
		AVGClassList_r = AVGClassList_r[:0] // 清空切片
		for _, i2 := range 部点终端_list {
			AVGClassList_r = append(AVGClassList_r, AVGClassList{T_id: i2.T_id, T_vga: Task.Read_TaskData_AVG(T_task_id, i2.T_sn, i2.T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)})
		}
		// 使用 sort.Slice 对切片进行排序
		sort.Slice(AVGClassList_r, func(i, j int) bool {
			return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga // 降序排序
			// 如果需要降序排序，可以使用：return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga
		})
		fmt.Println("AVGClassList_r:", AVGClassList_r)
		vgaca = math.Round((温湿度绑定点vga_L.T_vga-AVGClassList_r[len(AVGClassList_r)-1].T_vga)*100) / 100.0

		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行偏移 数据！冷点" + lib.To_string(AVGClassList_r[len(AVGClassList_r)-1].T_id) + " 平均值:" + lib.To_string(AVGClassList_r[len(AVGClassList_r)-1].T_vga) +
			"℃ 低点 " + lib.To_string(温湿度绑定点vga_L.T_id) + " 平均值" + lib.To_string(温湿度绑定点vga_L.T_vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ 设置：" + lib.To_string(T_deviation) + "℃"})

		Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, AVGClassList_r[len(AVGClassList_r)-1].T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间, math.Round(((vgaca)*0.8)*100)/100.0)

		// 均匀性布点   产品存放区域测点
		AVGClassList_r = AVGClassList_r[:0] // 清空切片
		for _, i2 := range 部点终端_list {
			AVGClassList_r = append(AVGClassList_r, AVGClassList{T_id: i2.T_id, T_vga: Task.Read_TaskData_AVG(T_task_id, i2.T_sn, i2.T_id, 温度分布特性的测试与分析_开始时间, 温度分布特性的测试与分析_结束时间)})
		}
		// 使用 sort.Slice 对切片进行排序
		sort.Slice(AVGClassList_r, func(i, j int) bool {
			return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga // 降序排序
			// 如果需要降序排序，可以使用：return AVGClassList_r[i].T_vga > AVGClassList_r[j].T_vga
		})
		fmt.Println("AVGClassList_r:", AVGClassList_r)
		vgaca = math.Round((温湿度绑定点vga_L.T_vga-AVGClassList_r[len(AVGClassList_r)-1].T_vga)*100) / 100.0

	}
	//lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "冷点 数据满足要求！冷点" + lib.To_string(AVGClassList_r[len(AVGClassList_r)-1].T_id) + " 平均值:" + lib.To_string(AVGClassList_r[len(AVGClassList_r)-1].T_vga) +
	//	"℃ 低点 " + lib.To_string(温湿度绑定点vga_L.T_id) + " 平均值" + lib.To_string(温湿度绑定点vga_L.T_vga) + "℃ 数据偏差： " + lib.To_string(vgaca) + "℃ "})
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 区间数据校正  （布点区域数据自检）
func (c *TaskDataHandleController) SSE_Interval_data_correction() {

	T_task_id := c.GetString("T_task_id") //  v26nplogbwt1

	c.Ctx.ResponseWriter.Header().Set("Content-Type", "text/event-stream")
	c.Ctx.ResponseWriter.Header().Set("Cache-Control", "no-cache")
	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "任务开始......"})

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取任务信息失败!"})
		return
	}

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

	结束时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "开空开")
	if len(结束时间) == 0 {
		结束时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "开满开")
	}
	if len(结束时间) == 0 {
		结束时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）结束时间")
	}
	if len(结束时间) == 0 {
		结束时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）结束时间")
	}
	if len(结束时间) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到结束时间 标签！"})
		return
	}
	温度控制范围最小值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最小值")))
	温度控制范围最高值 := float64(lib.To_float32(VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度控制范围最高值")))
	if 温度控制范围最小值 == 0 || 温度控制范围最高值 == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "温度控制范围 标签值不正确！"})
		return
	}
	// 均匀性布点   产品存放区域测点
	部点终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "均匀性布点")
	部点终端_list = append(部点终端_list, Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "产品存放区域测点")...)
	if len(部点终端_list) <= 2 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "均匀性布点，产品存放区域测点 太少了，至少两条以上！"})
		return
	}

	//List_data, _ := Task.Read_TaskData_ById_List(Task_r.T_task_id, 部点终端_list[0].T_sn, 部点终端_list[0].T_id, "", "", 0, 9999)
	//开始时间 := List_data[len(List_data) - 1].T_time

	开始时间 := VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（空载）开始时间")
	if len(开始时间) == 0 {
		开始时间 = VerifyTemplate.Read_VerifyTemplateMapData_T_name(Task_r.T_task_id, Task_r.T_VerifyTemplate_id, "温度分布特性的测试与分析（满载）开始时间")
	}
	if len(开始时间) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "未找到开始时间 标签！"})
		return
	}

	type AVGClassList struct {
		T_id  string
		T_max float64
		T_min float64
	}
	var AVGClassList_r []AVGClassList
	for _, i2 := range 部点终端_list {
		T_max := Task.Read_TaskData_max(T_task_id, i2.T_sn, i2.T_id, 开始时间, 结束时间)
		T_min := Task.Read_TaskData_min(T_task_id, i2.T_sn, i2.T_id, 开始时间, 结束时间)
		AVGClassList_r = append(AVGClassList_r, AVGClassList{T_id: i2.T_id, T_max: T_max, T_min: T_min})
	}
	fmt.Println("AVGClassList_r:", AVGClassList_r)

	fmt.Println("数据准备:", 开始时间, 结束时间, 温度控制范围最小值, 温度控制范围最高值)

	// -------  温湿度绑定点
	AVGClassList_is := true

	// -------------------- 温湿度绑定点vga_H --------------------
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "--- 进行处理 数据！---"})
	for AVGClassList_is {
		AVGClassList_is = false
		// 准备数据
		AVGClassList_r = AVGClassList_r[:0]
		for _, i2 := range 部点终端_list {
			T_max := Task.Read_TaskData_max(T_task_id, i2.T_sn, i2.T_id, 开始时间, 结束时间)
			T_min := Task.Read_TaskData_min(T_task_id, i2.T_sn, i2.T_id, 开始时间, 结束时间)
			AVGClassList_r = append(AVGClassList_r, AVGClassList{T_id: i2.T_id, T_max: T_max, T_min: T_min})
		}

		for _, AVGClassList_i := range AVGClassList_r {
			var vgaca float64
			if AVGClassList_i.T_max > 温度控制范围最高值 {
				AVGClassList_is = true

				vgaca = math.Round((温度控制范围最高值-AVGClassList_i.T_max)*100) / 100.0
				// 缩放
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最大值:" + lib.To_string(AVGClassList_i.T_max) +
					"℃  " + " 数据偏差： " + lib.To_string(vgaca) + "℃ 设置高：" + lib.To_string(温度控制范围最高值) + "℃"})
				Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, AVGClassList_i.T_id, 开始时间, 结束时间, 0.95)
				Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, AVGClassList_r[0].T_id, 开始时间, 结束时间, math.Round(((vgaca)*0.8)*100)/100.0)

			}
			if AVGClassList_i.T_min < 温度控制范围最小值 {
				AVGClassList_is = true

				vgaca = math.Round((温度控制范围最小值-AVGClassList_i.T_min)*100) / 100.0
				// 缩放
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "进行处理 数据！" + lib.To_string(AVGClassList_i.T_id) + " 最小值:" + lib.To_string(AVGClassList_i.T_min) +
					"℃  " + " 数据偏差： " + lib.To_string(vgaca) + "℃ 设置小：" + lib.To_string(温度控制范围最小值) + "℃"})
				Task.UpdateTaskDataTemperatureAndHumidityByGeometric_id(T_task_id, AVGClassList_i.T_id, 开始时间, 结束时间, 0.95)
				vgaca += float64(AVGClassList_i.T_min) - (AVGClassList_i.T_min * 0.95)

				Task.UpdateTaskDataTemperatureAndHumidityByGeometricAVG(T_task_id, AVGClassList_i.T_id, 开始时间, 结束时间, math.Round(((vgaca)*1.2)*100)/100.0)

			}
		}
		if AVGClassList_is {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 0, Msg: "------ 还有 数据需要修改 ------"})
		}

	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: "完成！"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 数据等比咧缩放      温度 湿度比列
//func DataGeometricScale(T_task_id,SN_List_s,StartTime,EndTime string,Temperature,Humidity float64) {
//
//	SN_List := strings.Split(strings.Trim(SN_List_s, "|"), "|")
//
//	for _, v := range SN_List {
//		sn_id := strings.Split(v, ",")
//		if len(sn_id) != 2 {
//			continue
//		}
//		sn, id := sn_id[0], sn_id[1]
//
//
//
//	}
//
//	return
//}