ColdVerify_local/controllers/TaskData.go

package controllers

import (
	"ColdVerify_local/Nats"
	"ColdVerify_local/Nats/NatsServer"
	"ColdVerify_local/conf"
	"ColdVerify_local/lib"
	"ColdVerify_local/logs"
	"ColdVerify_local/models/Certificate"
	"ColdVerify_local/models/Device"
	"ColdVerify_local/models/System"
	"ColdVerify_local/models/Task"
	"errors"
	"fmt"
	"github.com/beego/beego/v2/client/orm"
	beego "github.com/beego/beego/v2/server/web"
	"github.com/signintech/gopdf"
	"github.com/vmihailenco/msgpack/v5"
	"github.com/xuri/excelize/v2"
	"gonum.org/v1/plot"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
	"math"
	"net/http"
	"os"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
)

type TaskDataController struct {
	beego.Controller
}

// 列表 -
func (c *TaskDataController) TaskData_List() {

	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
	}

	Time_start := c.GetString("Time_start")
	Time_end := c.GetString("Time_end")
	T_sn := c.GetString("T_sn")
	T_id := c.GetString("T_id")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	dcList, err := NatsServer.Device_Class_List(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取设备列表失败!"}
		c.ServeJSON()
		return
	}
	// 保存布局编号和校准证书对应关系
	var deviceCertificateMap = make(map[string]string) // t_id, T_Certificate_sn
	for _, v := range dcList {
		deviceCertificateMap[v.T_id] = v.T_Certificate_sn
	}
	var cnt int64
	List, cnt := Task.Read_TaskData_ById_List(Task_r.T_task_id, T_sn, T_id, Time_start, Time_end, page, page_z)
	for i := 0; i < len(List); i++ {
		List[i].T_Certificate_sn = deviceCertificateMap[List[i].T_id]
	}
	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 *TaskDataController) TaskData_Temperature_Pdf() {

	Time_start := c.GetString("Time_start")
	Time_end := c.GetString("Time_end")
	T_snid := c.GetString("T_snid")
	T_task_id := c.GetString("T_task_id")

	err := c.TaskData_Pdf(Time_start, Time_end, T_task_id, T_snid, Task.Temperature)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: err.Error()}
		c.ServeJSON()
		return
	}
}
func (c *TaskDataController) TaskData_Humidity_Pdf() {

	Time_start := c.GetString("Time_start")
	Time_end := c.GetString("Time_end")
	T_snid := c.GetString("T_snid")
	T_task_id := c.GetString("T_task_id")
	err := c.TaskData_Pdf(Time_start, Time_end, T_task_id, T_snid, Task.Humidity)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: err.Error()}
		c.ServeJSON()
		return
	}

}
func (c *TaskDataController) TaskData_Pdf(Time_start, Time_end, T_task_id, T_snid, T_type string) (err error) {

	Time_start_b := Time_start
	Time_end_b := Time_end

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		return errors.New("获取任务信息失败!")
	}
	if Task_r.T_collection_state == 2 {
		return errors.New("数据采集中，请稍后!")
	}
	user, err := NatsServer.Read_User(Task_r.T_uuid)
	var T_snid_list []string
	if len(T_snid) > 0 {
		T_snid_list = strings.Split(strings.Trim(T_snid, "|"), "|")
	}

	pdf := &gopdf.GoPdf{}
	pdf.Start(gopdf.Config{PageSize: gopdf.Rect{W: 595.28, H: 841.89}}) //595.28, 841.89 = A4

	err = pdf.AddTTFFont("wts", "static/fonts/MiSans-Medium.ttf")
	if err != nil {
		return
	}
	err = pdf.SetFont("wts", "", 10)
	if err != nil {
		return
	}

	dataMap := make(map[string]string)
	timeMap := make(map[string]bool)
	idWidthMap := make(map[string]float64)
	dataListMap := make(map[string][]Task.TaskData_)
	T_snid_list1 := []string{}
	T_snid_list2 := []string{}

	for _, v := range T_snid_list {
		sn_id := strings.Split(v, ",")
		if len(sn_id) == 2 {
			List, _ := Task.Read_TaskData_ById_List(Task_r.T_task_id, sn_id[0], sn_id[1], Time_start, Time_end, 0, 9999)
			if len(List) == 0 {
				continue
			}
			idw, _ := pdf.MeasureTextWidth(sn_id[1])
			if !lib.IsNumeric(sn_id[1]) {
				//IsNotNumeric = true
				T_snid_list1 = append(T_snid_list1, v)
				if len(Task_r.T_BindDeviceDataStartTime) > 0 {
					Time_start = Task_r.T_BindDeviceDataStartTime
				}
				if len(Task_r.T_BindDeviceDataEndTime) > 0 {
					Time_end = Task_r.T_BindDeviceDataEndTime
				}
			} else {
				T_snid_list2 = append(T_snid_list2, v)
			}
			if idw > 20 {
				idWidthMap[sn_id[1]] = idw + 12
			} else {
				idWidthMap[sn_id[1]] = 30.3
			}
			sort.Slice(List, func(i, j int) bool {
				return List[i].T_time < List[j].T_time
			})
			dataListMap[sn_id[1]] = List
			for _, data := range List {
				k := fmt.Sprintf("%s,%s", data.T_time, data.T_id)
				if T_type == Task.Temperature {
					dataMap[k] = fmt.Sprintf("%.1f", data.T_t)
				}
				if T_type == Task.Humidity {
					dataMap[k] = fmt.Sprintf("%.1f", data.T_rh)
				}
				if _, ok := timeMap[data.T_time]; !ok {
					timeMap[data.T_time] = true
				}
			}
		}
		Time_start = Time_start_b
		Time_end = Time_end_b
	}

	var timeList []string
	for k, _ := range timeMap {
		timeList = append(timeList, k)
	}
	sort.Slice(timeList, func(i, j int) bool {
		return timeList[i] < timeList[j]
	})

	err = pdf.SetFont("wts", "", 15)
	if err != nil {
		return
	}

	pdf.SetGrayFill(0.5)

	pdf.SetMargins(0, 20, 0, 20)
	pdf.AddPage()
	imgH, _ := gopdf.ImageHolderByPath("./ofile/logo.jpg")
	err = pdf.ImageByHolder(imgH, 10, 10, &gopdf.Rect{W: 93, H: 32})
	name := user.T_name

	var y float64 = 40
	textw, _ := pdf.MeasureTextWidth(name)
	pdf.SetX((595 / 2) - (textw / 2))
	pdf.SetY(y)
	pdf.Text(name)

	y += 20
	T_type_name := ""
	if T_type == Task.Temperature {
		T_type_name = "温度"
	}
	if T_type == Task.Humidity {
		T_type_name = "湿度"
	}
	title := Task_r.T_name + T_type_name + "验证数据"
	textw, _ = pdf.MeasureTextWidth(title)
	pdf.SetX((595 / 2) - (textw / 2))
	pdf.SetY(y)
	pdf.Text(title)

	err = pdf.SetFont("wts", "", 12)
	if err != nil {
		return
	}
	if len(timeList) > 0 {
		y += 20
		timeStr := fmt.Sprintf("%s - %s", timeList[0], timeList[len(timeList)-1])
		textw, _ = pdf.MeasureTextWidth(timeStr)
		pdf.SetX((595 / 2) - (textw / 2))
		pdf.SetY(y)
		pdf.Text(timeStr)
	}

	err = pdf.SetFont("wts", "", 10)
	if err != nil {
		return
	}

	y += 20
	var x float64 = 10
	var w float64 = 120
	sort.Slice(T_snid_list1, func(i, j int) bool {
		return extractSecondElement(T_snid_list1[i]) < extractSecondElement(T_snid_list1[j])
	})
	for _, v := range T_snid_list1 {
		sn_id := strings.Split(v, ",")
		id := sn_id[1]
		dataList2, _ := dataListMap[id]

		err = pdf.SetFont("wts", "", 15)
		if err != nil {
			return
		}
		var textH float64 = 20 // if text height is 25px.
		y += 20
		pdf.SetNewY(y, textH)
		y = pdf.GetY()
		if y > 790 {
			pdf.AddPage()
			y = 20
		}

		textw, _ = pdf.MeasureTextWidth(id)
		pdf.SetX((595 / 2) - (textw / 2))
		pdf.SetY(y)
		pdf.Text(id)
		y += 10

		err = pdf.SetFont("wts", "", 10)
		if err != nil {
			return
		}
		pdf.SetNewY(y, textH)
		y = pdf.GetY()
		if y < 790 {
			x = 10
			for i := 0; i < 4; i++ {
				w = 113.8
				lib.RectFillColor(pdf, "时间", 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
				x += w
				w = 30
				lib.RectFillColor(pdf, T_type_name, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
				x += w
			}
			y += 20
		} else {
			pdf.AddPage()
			y = 20
			x = 10
			for i := 0; i < 4; i++ {
				w = 113.8
				lib.RectFillColor(pdf, "时间", 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
				x += w
				w = 30
				lib.RectFillColor(pdf, T_type_name, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
				x += w
			}
			y += 20
		}
		for i := 0; i < len(dataList2); i++ {
			temp := i % 4
			x = 10 + 143.8*float64(temp)
			w = 113.8

			lib.RectFillColor(pdf, dataList2[i].T_time, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
			x += w
			w = 30
			if T_type == Task.Temperature {
				lib.RectFillColor(pdf, fmt.Sprintf("%.1f", dataList2[i].T_t), 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
			}
			if T_type == Task.Humidity {
				lib.RectFillColor(pdf, fmt.Sprintf("%.1f", dataList2[i].T_rh), 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
			}
			if temp == 3 {
				y += 20
				pdf.SetNewY(y, textH)
				y = pdf.GetY()
				// 每页添加表头
				if y == 20 {
					x = 10
					for k := 0; k < 4; k++ {
						w = 113.8
						lib.RectFillColor(pdf, "时间", 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
						x += w
						w = 30
						lib.RectFillColor(pdf, T_type_name, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
						x += w
					}
					y += 20
				}
			}
		}
		y += 25

	}

	y += 20
	sort.Slice(T_snid_list2, func(i, j int) bool {
		return extractSecondElement(T_snid_list2[i]) < extractSecondElement(T_snid_list2[j])
	})
	chunks := splitData(T_snid_list2, 454.5, idWidthMap)
	for _, list := range chunks {
		x = 10
		w = 120.7
		lib.RectFillColor(pdf, "时间", 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
		x += w
		w = 30.3
		for _, v2 := range list {
			sn_id2 := strings.Split(v2, ",")
			id2 := sn_id2[1]
			w = idWidthMap[id2]
			lib.RectFillColor(pdf, id2, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
			x += w
		}
		y += 20

		for _, t := range timeList {
			x = 10
			var textH float64 = 20 // if text height is 25px.
			pdf.SetNewY(y, textH)
			y = pdf.GetY()
			if y == 20 {
				w = 120.7
				lib.RectFillColor(pdf, "时间", 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
				x += w
				w = 30.3
				for _, v2 := range list {
					sn_id2 := strings.Split(v2, ",")
					id2 := sn_id2[1]
					w = idWidthMap[id2]
					lib.RectFillColor(pdf, id2, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
					x += w
				}
				y += 20
				x = 10
			}
			w = 120.7
			lib.RectFillColor(pdf, t, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
			x += w
			w = 30.3
			for _, v := range list {
				sn_id := strings.Split(v, ",")
				id := sn_id[1]
				data := dataMap[fmt.Sprintf("%s,%s", t, id)]
				w = idWidthMap[id]
				lib.RectFillColor(pdf, data, 12, x, y, w, 20, 255, 255, 255, lib.AlignCenter, lib.ValignMiddle)
				x += w
			}
			y += 20

		}
		y += 20
	}
	filename := time.Now().Format("20060102150405") + ".pdf"
	timeStr := "ofile/" + T_type_name + filename

	err = pdf.WritePdf(timeStr)
	if err != nil {
		return
	}

	defer func() {
		//删除目录
		os.Remove(timeStr)
	}()

	c.Ctx.Output.Download(timeStr)
	return nil
}

// Function to extract the second element after splitting by comma
func extractSecondElement(s string) string {
	parts := strings.Split(s, ",")
	if len(parts) >= 2 {
		return parts[1]
	}
	return s // return original string if splitting doesn't give expected parts
}

func splitData(data []string, threshold float64, idWidthMap map[string]float64) [][]string {
	var result [][]string
	var currentBatch []string
	var currentSum float64

	for _, item := range data {
		sn_id := strings.Split(item, ",")
		if len(sn_id) == 2 {
			wd := idWidthMap[sn_id[1]]
			if currentSum+wd > threshold+0.1 {
				// 当前批次超过阈值，切分
				result = append(result, currentBatch)
				// 重置当前批次和当前总和
				currentBatch = []string{}
				currentSum = 0
			}
			currentBatch = append(currentBatch, item)
			currentSum += wd
		}
	}

	// 添加最后一批
	if len(currentBatch) > 0 {
		result = append(result, currentBatch)
	}

	return result
}

// 列表 -
func (c *TaskDataController) TaskDataClass_List() {
	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_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	List := Task.Read_TaskData_ById_ClassList(Task_r.T_task_id)

	dcList, err := NatsServer.Device_Class_List(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取设备列表失败!"}
		c.ServeJSON()
		return
	}
	// 保存布局编号和校准证书对应关系
	var deviceCertificateMap = make(map[string]int) // t_id, T_Certificate_sn
	for _, v := range dcList {
		deviceCertificateMap[v.T_id] = v.T_terminal
	}

	for i := 0; i < len(List); i++ {
		if terminal, ok := deviceCertificateMap[List[i].T_id]; ok {
			List[i].T_terminal = terminal
		}

	}

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

func (c *TaskDataController) TaskDataClass_Edit() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	T_task_id := c.GetString("T_task_id")
	T_sn := c.GetString("T_sn")
	T_id := c.GetString("T_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	sn, err := Task.Read_TaskData_ByT_id(Task_r.T_task_id, T_id)
	if err != nil && !errors.Is(err, orm.ErrNoRows) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败！"}
		c.ServeJSON()
		return
	}
	if len(sn) > 0 && sn != T_sn {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("编号[%s]已被sn[%s]关联，请修改后重试！", T_id, sn)}
		c.ServeJSON()
		return
	}
	err = NatsServer.Edit_DeviceClassList(T_task_id, T_sn, T_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: err.Error()}
		c.ServeJSON()
		return
	}
	err = Task.Update_TaskData_ByT_sn(Task_r.T_task_id, T_sn, T_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(T_uuid, "本地版-任务分类", "修改分类数据"+Task_r.T_name, Task_r.T_task_id+"|"+T_sn+"|"+T_id)

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

func (c *TaskDataController) TaskDataClass_Del() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")
	T_sn := c.GetString("T_sn")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	err = Task.Delete_TaskData_ByT_sn(Task_r.T_task_id, T_sn)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(T_uuid, "本地版-任务分类", "删除分类数据"+Task_r.T_name, Task_r.T_task_id+"|"+T_sn)

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

// 添加-
func (c *TaskDataController) TaskData_AddS() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	//T_sn|T_id|T_t|T_rh|T_time?

	T_Data := c.GetString("T_Data")
	if len(T_Data) < 5 {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "err T_Data!"}
		c.ServeJSON()
		return
	}

	T_Data_list := strings.Split(T_Data, "?")
	println(len(T_Data_list), "len(T_Data_list)")
	var T_Data_list_x = 0

	Task.UpdateAUTO_INCREMENT(conf.Local_AliasName, Task_r.T_task_id)

	snMaps := make(map[string]string)

	for _, v := range T_Data_list {
		// 132|132|23.9|72.1|2023-04-30 07:03:00
		if len(v) < 5 {
			println(v, "len(v) < 5")
			continue
		}
		v_list := strings.Split(v, "|")
		id, sn := strings.Trim(v_list[1], " "), strings.Trim(v_list[0], " ")
		sn1, ok := snMaps[id]
		if !ok {
			snMaps[id] = sn
		} else if sn1 != sn {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("编号[%s]已被sn[%s]关联，请修改后重试！", id, sn1)}
			c.ServeJSON()
			return
		}
	}

	for T_id, T_sn := range snMaps {
		sn, err := Task.Read_TaskData_ByT_id(Task_r.T_task_id, T_id)
		if err != nil && !errors.Is(err, orm.ErrNoRows) {
			continue
		}
		if len(sn) > 0 && sn != T_sn {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("编号[%s]已被sn[%s]关联，请修改后重试！", T_id, sn)}
			c.ServeJSON()
			return
		}

		id, err := Task.Read_TaskData_ByT_sn(Task_r.T_task_id, T_sn)
		if err != nil && !errors.Is(err, orm.ErrNoRows) {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败！"}
			c.ServeJSON()
			return
		}
		if len(id) > 0 && id != T_id {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("sn[%s]已被编号[%s]关联，请修改后重试！", T_sn, id)}
			c.ServeJSON()
			return
		}

		// 同步设备到线上
		err = NatsServer.Add_DeviceClassList(T_task_id, T_sn, T_id)
		if err != nil {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: err.Error()}
			c.ServeJSON()
			return
		}

	}

	for _, v := range T_Data_list {
		// 132|132|23.9|72.1|2023-04-30 07:03:00
		if len(v) < 5 {
			println(v, "len(v) < 5")
			continue
		}
		v_list := strings.Split(v, "|")
		t, _ := lib.ReplaceSeconds(v_list[4])
		is := Task.Add_TaskData(Task_r.T_task_id, v_list[0], v_list[1], v_list[2], v_list[3], t)
		if is {
			T_Data_list_x += 1
		}
	}

	System.Add_UserLogs_T(T_uuid, "本地版-任务数据", "添加数据"+Task_r.T_name, Task_r.T_task_id+"结果："+string(len(T_Data_list))+"/"+string(T_Data_list_x)+"|=> "+T_Data)

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

func (c *TaskDataController) TaskData_AddS_Excel() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	Task.UpdateAUTO_INCREMENT(conf.Local_AliasName, Task_r.T_task_id)

	// 获取上传的文件
	file, _, err := c.GetFile("file")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "文件上传失败!"}
		c.ServeJSON()
		return
	}

	// 解析 Excel 文件
	xlFile, err := excelize.OpenReader(file)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "文件解析失败!"}
		c.ServeJSON()
		return
	}

	rows, err := xlFile.GetRows(xlFile.GetSheetName(0))
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取工作表失败!"}
		c.ServeJSON()
		return
	}
	var T_Data_list_x int
	snMaps := make(map[string]string)
	var valueStrings []string
	for k, val := range rows {
		// 跳过第一行
		if k == 0 {
			continue
		}
		if len(val) < 5 {
			println(val, "len(v) < 5")
			continue
		}
		fmt.Println(val)
		id, sn := val[1], val[0]
		sn1, ok := snMaps[id]
		if !ok {
			snMaps[id] = sn
		} else if sn1 != sn {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("编号[%s]已被sn[%s]关联，请修改后重试！", id, sn1)}
			c.ServeJSON()
			return
		}
		t, _ := lib.ReplaceSeconds(val[4])
		valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", val[0], val[1], val[2], val[3], t))
		//T_Data_list_x += 1
	}

	for T_id, T_sn := range snMaps {

		sn, err := Task.Read_TaskData_ByT_id(Task_r.T_task_id, T_id)
		if err != nil && !errors.Is(err, orm.ErrNoRows) {
			continue
		}
		if len(sn) > 0 && sn != T_sn {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("编号[%s]已被sn[%s]关联，请修改后重试！", T_id, sn)}
			c.ServeJSON()
			return
		}

		id, err := Task.Read_TaskData_ByT_sn(Task_r.T_task_id, T_sn)
		if err != nil && !errors.Is(err, orm.ErrNoRows) {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败！"}
			c.ServeJSON()
			return
		}
		if len(id) > 0 && id != T_id {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("sn[%s]已被编号[%s]关联，请修改后重试！", T_sn, id)}
			c.ServeJSON()
			return
		}
	}

	// 删除重复数据
	_, err = Task.DeleteDeduplicate(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "导入失败"}
		c.ServeJSON()
		return
	}
	// 创建唯一索引
	err = Task.Create_Unique_Index(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "导入失败"}
		c.ServeJSON()
		return
	}

	pageSize := 10000                          // 每页的条数
	totalPages := len(valueStrings) / pageSize // 总页数

	// 遍历每一页
	for page := 1; page <= totalPages+1; page++ {

		// 计算当前页的起始索引和结束索引
		startIndex := (page - 1) * pageSize
		if startIndex > len(valueStrings) {
			startIndex = len(valueStrings)
		}
		endIndex := page * pageSize

		// 边界判断，如果结束索引超过列表长度，则将结束索引设置为列表最后一个元素的索引加一
		if endIndex > len(valueStrings) {
			endIndex = len(valueStrings)
		}

		fmt.Printf("startIndex %d endIndex %d\n", startIndex, endIndex)

		// 获取当前页的数据
		currentList := valueStrings[startIndex:endIndex]
		err = Task.Adds_TaskData(T_task_id, currentList)
		if err == nil {
			T_Data_list_x += len(currentList)
		}

	}

	//err = Task.Adds_TaskData(T_task_id, valueStrings)

	// 删除唯一索引
	Task.Delete_Unique_Index(T_task_id)

	System.Add_UserLogs_T(T_uuid, "本地版-任务数据", "添加数据"+Task_r.T_name, Task_r.T_task_id+"结果："+strconv.Itoa(T_Data_list_x))

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

// 添加-
func (c *TaskDataController) TaskData_Add() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_sn := c.GetString("T_sn")
	T_id := c.GetString("T_id")
	T_t, _ := c.GetFloat("T_t")
	T_rh, _ := c.GetFloat("T_rh")
	T_time := c.GetString("T_time")
	if len(T_sn) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_sn 不能为空!"}
		c.ServeJSON()
		return
	}
	if len(T_id) == 0 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_id 不能为空!"}
		c.ServeJSON()
		return
	}

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	Task.UpdateAUTO_INCREMENT(conf.Local_AliasName, Task_r.T_task_id)

	sn, err := Task.Read_TaskData_ByT_id(Task_r.T_task_id, T_id)
	if err != nil && !errors.Is(err, orm.ErrNoRows) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败！"}
		c.ServeJSON()
		return
	}
	if len(sn) > 0 && sn != T_sn {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("编号[%s]已被sn[%s]关联，请修改后重试！", T_id, sn)}
		c.ServeJSON()
		return
	}
	id, err := Task.Read_TaskData_ByT_sn(Task_r.T_task_id, T_sn)
	if err != nil && !errors.Is(err, orm.ErrNoRows) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败！"}
		c.ServeJSON()
		return
	}
	if len(id) > 0 && id != T_id {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("sn[%s]已被编号[%s]关联，请修改后重试！", T_sn, id)}
		c.ServeJSON()
		return
	}
	// 同步设备到线上,添加终端，不在本地添加数据
	if T_t == 0 && T_rh == 0 {
		err = NatsServer.Add_DeviceClassList(T_task_id, T_sn, T_id)
		if err != nil {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: err.Error()}
			c.ServeJSON()
			return
		}
		taskData := Task.Read_TaskData_first(T_task_id, "", "")
		T_t = float64(taskData.T_t)
		T_rh = float64(taskData.T_rh)
		T_time = taskData.T_time
	}
	is := Task.Add_TaskData(Task_r.T_task_id, T_sn, T_id, fmt.Sprintf("%.2f", T_t), fmt.Sprintf("%.2f", T_rh), T_time)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(T_uuid, "本地版-任务数据", "添加数据"+Task_r.T_name, Task_r.T_task_id+"|"+T_sn+"|"+T_id+"|"+fmt.Sprintf("%.2f", T_t)+"|"+fmt.Sprintf("%.2f", T_rh)+T_time)

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

// 修改-
func (c *TaskDataController) TaskData_Up() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	Id, err := c.GetInt("Id")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}
	T_t, err := c.GetFloat("T_t")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_t 错误!"}
		c.ServeJSON()
		return
	}
	T_rh, err := c.GetFloat("T_rh")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_rh 错误!"}
		c.ServeJSON()
		return
	}
	T_time := c.GetString("T_time")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	is := Task.Up_TaskData(Task_r.T_task_id, strconv.Itoa(Id), fmt.Sprintf("%.2f", T_t), fmt.Sprintf("%.2f", T_rh), T_time)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(T_uuid, "本地版-任务数据", "修改数据"+Task_r.T_name, Task_r.T_task_id+"|"+strconv.Itoa(Id)+"|"+fmt.Sprintf("%.2f", T_t)+"|"+fmt.Sprintf("%.2f", T_rh)+T_time)

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

// 删除-
func (c *TaskDataController) TaskData_Del() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

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

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	is := Task.Del_TaskData(Task_r.T_task_id, strconv.Itoa(Id))
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(T_uuid, "本地版-任务数据", "删除"+Task_r.T_name, Task_r.T_task_id+"|"+strconv.Itoa(Id))

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

// 删除-
func (c *TaskDataController) TaskData_Del_t_id() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	Id := c.GetString("Id")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	is := Task.Del_TaskData_t_id(Task_r.T_task_id, Id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(T_uuid, "本地版-任务数据", "删除"+Task_r.T_name, Task_r.T_task_id+"|"+Id)

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

// 列表 - 接口
func (c *TaskDataController) Export_Data_Excel() {

	Time_start := c.GetString("Time_start")
	Time_end := c.GetString("Time_end")
	T_sn_str := c.GetString("T_sn_list") //865901058809339,865901058815849,865901058818991,865901058810568
	//T_id, err := c.GetInt("T_id")
	//if err != nil {
	//	T_id = -1
	//
	//}

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	T_sn_list := strings.Split(T_sn_str, ",")
	DeviceSensor_data_list := []Task.TaskData_{}
	for _, v := range T_sn_list {
		DeviceSensor_data, _ := Task.Read_TaskData_ById_List(Task_r.T_task_id, v, "", Time_start, Time_end, 1, 9999)
		DeviceSensor_data_list = append(DeviceSensor_data_list, DeviceSensor_data...)
	}

	f := excelize.NewFile() // 设置单元格的值
	// 这里设置表头
	f.SetCellValue("Sheet1", "A1", "编号")
	f.SetCellValue("Sheet1", "B1", "SN")
	f.SetCellValue("Sheet1", "C1", "温度℃")
	f.SetCellValue("Sheet1", "D1", "湿度%")
	f.SetCellValue("Sheet1", "E1", "记录时间")
	// 设置列宽
	f.SetColWidth("Sheet1", "A", "A", 7)
	f.SetColWidth("Sheet1", "B", "B", 20)
	f.SetColWidth("Sheet1", "C", "C", 10)
	f.SetColWidth("Sheet1", "D", "D", 10)
	f.SetColWidth("Sheet1", "E", "E", 22)

	line := 1

	// 循环写入数据
	for _, v := range DeviceSensor_data_list {
		line++
		f.SetCellValue("Sheet1", fmt.Sprintf("A%d", line), v.T_id)
		f.SetCellValue("Sheet1", fmt.Sprintf("B%d", line), v.T_sn)
		f.SetCellValue("Sheet1", fmt.Sprintf("C%d", line), strconv.FormatFloat(float64(v.T_t), 'f', 1, 64))
		f.SetCellValue("Sheet1", fmt.Sprintf("D%d", line), strconv.FormatFloat(float64(v.T_rh), 'f', 1, 64))
		f.SetCellValue("Sheet1", fmt.Sprintf("E%d", line), v.T_time)

	}
	fmt.Println("DeviceSensor_data:", len(DeviceSensor_data_list))

	lib.Create_Dir("./ofile")

	timeStr := time.Now().Format("20060102150405")
	// 保存文件
	if err := f.SaveAs("ofile/" + timeStr + ".xlsx"); err != nil {
		fmt.Println(err)
	}

	if !lib.Pload_qiniu("ofile/"+timeStr+".xlsx", "ofile/"+timeStr+".xlsx") {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "oss!"}
		c.ServeJSON()
		return
	}
	//删除目录
	err = os.Remove("ofile/" + timeStr + ".xlsx")
	if err != nil {
		fmt.Println(err)
	}

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

func (c *TaskDataController) Check() {
	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	type R_JSONS struct {
		T_sn               string // SN
		T_id               string // 编号
		T_unm              int    // 数据量
		T_time_interval    int64  // 时间间隔
		Time_start         string // 开始
		Time_end           string //  结束
		Result             int    //  200 OK, 201 可以补 , 202 不能补
		Result_str         string //  提示内容
		Result_Time_start  string //  2022-8-05 21:01
		Result_Time_defect int64  //  缺失时间间隔
	}

	var r_jsons []R_JSONS

	List := Task.Read_TaskData_ById_ClassList(Task_r.T_task_id)
	for _, v := range List {
		var r_json R_JSONS
		r_json.T_sn = v.T_sn
		r_json.T_id = v.T_id
		r_json.Result = 200

		DeviceSensor_data := Task.Read_TaskData_ById_List_(Task_r.T_task_id, v.T_sn)
		r_json.T_unm = len(DeviceSensor_data)

		if r_json.T_unm > 2 {
			r_json.T_id = DeviceSensor_data[0].T_id
			r_json.Time_end = DeviceSensor_data[len(DeviceSensor_data)-1].T_time
			r_json.Time_start = DeviceSensor_data[0].T_time

			formatTime_a, _ := time.Parse("2006-1-2 15:04", DeviceSensor_data[0].T_time)
			formatTime_b, _ := time.Parse("2006-1-2 15:04", DeviceSensor_data[1].T_time)
			formatTime_x := formatTime_b.Unix() - formatTime_a.Unix()
			r_json.T_time_interval = formatTime_x
			println("formatTime_x:", v.T_id, v.T_sn, formatTime_x)
			if formatTime_x > 60*30 || formatTime_x < 60 {
				r_json.Result = 202
				r_json.Result_str = "数据异常（数据的第一个时间与第二个时间相差 " + strconv.FormatInt(formatTime_x, 10) + "秒）,必须大于60秒，小于30分钟"
				r_jsons = append(r_jsons, r_json)
				continue
			}
			for data_i := 2; data_i < len(DeviceSensor_data); data_i++ {
				formatTime_a = formatTime_b
				formatTime_b, _ = time.Parse("2006-1-2 15:04", DeviceSensor_data[data_i].T_time)
				formatTime_ := formatTime_b.Unix() - formatTime_a.Unix()
				println("formatTime_x-:", formatTime_)
				if formatTime_ < formatTime_x {
					r_json.Result = 202
					r_json.Result_str = "开始时间：" + DeviceSensor_data[data_i-1].T_time + "  离下一条时间间隔:" + strconv.FormatInt(formatTime_, 10) + "秒，间隔小于时间间隔，不能自动补充"
					break
				}
				if formatTime_x != formatTime_ {
					if formatTime_ > 60*30 {
						r_json.Result = 202
						r_json.Result_str = "开始时间：" + DeviceSensor_data[data_i-1].T_time + "  离下一条时间间隔:" + strconv.FormatInt(formatTime_, 10) + "秒，相差时间大于30分钟，不能自动补充"
						break
					}
					r_json.Result = 201
					r_json.Result_str = "开始时间：" + DeviceSensor_data[data_i-1].T_time + "  离下一条时间间隔:" + strconv.FormatInt(formatTime_, 10) + "秒"
					r_json.Result_Time_start = DeviceSensor_data[data_i-1].T_time
					r_json.Result_Time_defect = formatTime_
					println(r_json.Result_str)
					break
				}

			}
		} else {
			r_json.Result = 202
			r_json.Result_str = "数据量太少 必须大于 2条以上！"
		}

		r_jsons = append(r_jsons, r_json)
	}

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

func (c *TaskDataController) Check_Asyn() {
	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	type R_JSONS struct {
		T_sn               string // SN
		T_id               string // 编号
		T_unm              int    // 数据量
		T_time_interval    int64  // 时间间隔
		Time_start         string // 开始
		Time_end           string //  结束
		Result             int    //  200 OK, 201 可以补 , 202 不能补
		Result_str         string //  提示内容
		Result_Time_start  string //  2022-8-05 21:01
		Result_Time_defect int64  //  缺失时间间隔
	}
	List := Task.Read_TaskData_ById_ClassList(Task_r.T_task_id)

	r_jsons := make([]R_JSONS, len(List))
	var limitMaxNum = 10
	var chData = make(chan int, limitMaxNum)
	var jobGroup sync.WaitGroup
	var tasknum = len(List)

	for i := 0; i < tasknum; i++ {
		chData <- 1
		jobGroup.Add(1)
		go func(index int, wg *sync.WaitGroup, res *[]R_JSONS) {
			defer wg.Done()
			var r_json R_JSONS
			r_json.T_sn = List[index].T_sn
			r_json.T_id = List[index].T_id

			r_json.Result = 200

			DeviceSensor_data := Task.Read_TaskData_ById_List_(Task_r.T_task_id, List[index].T_sn)
			r_json.T_unm = len(DeviceSensor_data)

			if r_json.T_unm > 2 {
				r_json.T_id = DeviceSensor_data[0].T_id
				r_json.Time_end = DeviceSensor_data[len(DeviceSensor_data)-1].T_time
				r_json.Time_start = DeviceSensor_data[0].T_time

				formatTime_a, _ := time.Parse("2006-1-2 15:04", DeviceSensor_data[0].T_time)
				formatTime_b, _ := time.Parse("2006-1-2 15:04", DeviceSensor_data[1].T_time)
				formatTime_x := formatTime_b.Unix() - formatTime_a.Unix()
				r_json.T_time_interval = formatTime_x
				println("formatTime_x:", List[index].T_id, List[index].T_sn, formatTime_x)
				if formatTime_x > 60*30 || formatTime_x < 60 {
					r_json.Result = 202
					r_json.Result_str = "数据异常（数据的第一个时间与第二个时间相差 " + strconv.FormatInt(formatTime_x, 10) + "秒）,必须大于60秒，小于30分钟"
					*res = append(*res, r_json)
					<-chData
					return
				}

				for data_i := 2; data_i < len(DeviceSensor_data); data_i++ {
					formatTime_a = formatTime_b
					formatTime_b, _ = time.Parse("2006-1-2 15:04", DeviceSensor_data[data_i].T_time)
					formatTime_ := formatTime_b.Unix() - formatTime_a.Unix()
					if formatTime_ < formatTime_x {
						println("formatTime_x-:", formatTime_)
						r_json.Result = 202
						r_json.Result_str = "开始时间：" + DeviceSensor_data[data_i-1].T_time + "  离下一条时间间隔:" + strconv.FormatInt(formatTime_, 10) + "秒，间隔小于时间间隔，不能自动补充"
						break
					}
					if formatTime_x != formatTime_ {
						if formatTime_ > 60*30 {
							println("formatTime_x-:", formatTime_)
							r_json.Result = 202
							r_json.Result_str = "开始时间：" + DeviceSensor_data[data_i-1].T_time + "  离下一条时间间隔:" + strconv.FormatInt(formatTime_, 10) + "秒，相差时间大于30分钟，不能自动补充"
							break
						}
						r_json.Result = 202
						r_json.Result_str = "开始时间：" + DeviceSensor_data[data_i-1].T_time + "  离下一条时间间隔:" + strconv.FormatInt(formatTime_, 10) + "秒"
						r_json.Result_Time_start = DeviceSensor_data[data_i-1].T_time
						r_json.Result_Time_defect = formatTime_
						println(r_json.Result_str)
						break
					}
				}

			} else {
				r_json.Result = 202
				r_json.Result_str = "数据量太少 必须大于 2条以上！"
			}
			*res = append(*res, r_json)
			<-chData
		}(i, &jobGroup, &r_jsons)
	}
	//使用Wait等待所有任务执行完毕
	jobGroup.Wait()
	jsonsMap := map[string]R_JSONS{}
	resp := make([]R_JSONS, 0)

	for _, json := range r_jsons {
		jsonsMap[json.T_id] = json
	}

	for _, v := range List {
		resp = append(resp, jsonsMap[v.T_id])
	}

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

// 打包数据本地数据
func (c *TaskDataController) TaskData_Import_TaskData() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")
	_, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if err = lib.Create_Dir(conf.Sql_Temp_Dir); err != nil {
		logs.Println("创建sql临时文件失败")
	}
	sql_file := fmt.Sprintf("%sZ_TaskData_%s.sql", conf.Sql_Temp_Dir, T_task_id)
	org, err := Task.Dump_TaskData(T_task_id, conf.MysqlServer2_Username, conf.MysqlServer2_Password, conf.MysqlServer2_UrlPort, conf.MysqlServer2_Database, sql_file)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "z_task_data_" + T_task_id + "线上数据导出失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(T_uuid, "本地版-任务数据-打包本地数据", "导出线上数据Z_TaskData_"+T_task_id, org)

	i := 0
	flag := false
	Task.CREATE_TaskData(conf.Local_AliasName, T_task_id)
	for i < 10 {
		Task.Truncate_TaskData(conf.Local_AliasName, T_task_id)
		org, err = Task.Insert_TaskData(conf.MysqlServer_Username, conf.MysqlServer_Password, conf.MysqlServer_UrlPort, conf.MysqlServer_Database, sql_file)
		if err != nil {
			logs.Println("任务数据-打包本地数据", "线下导入数据Z_TaskData_"+T_task_id, err.Error())
		} else {
			if Task.Check_TaskData_Num(T_task_id) {
				System.Add_UserLogs_T(T_uuid, "本地版-任务数据-打包本地数据", "线下导入数据Z_TaskData_"+T_task_id, org)
				flag = true
				break
			}
		}
		i++
	}
	// 重试10次后仍然没有成功导入数据
	if !flag {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "z_task_data_" + T_task_id + "线下导入数据失败!"}
		c.ServeJSON()
		return
	}

	//删除导出的sql文件
	_ = os.Remove(sql_file)

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

} // 重置 SN数据
func (c *TaskDataController) CopyTaskDataSN() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")
	T_task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	To_T_task_id := c.GetString("To_T_task_id")
	To_T_task_r, err := Task.Read_Task(To_T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	StartTime := c.GetString("StartTime") + ":00"
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime") + ":00"
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id_str := sn_id[0], sn_id[1]
		_, is := Device.Read_DeviceClassList_T_class_T_sn(To_T_task_r.T_class, sn)
		if !is {
			dc, is_ := Device.Read_DeviceClassList_T_class_T_sn(T_task_r.T_class, sn)
			if is_ {
				dcr := Device.DeviceClassList{
					T_class:          To_T_task_r.T_class,
					T_id:             dc.T_id,
					T_sn:             dc.T_sn,
					T_failure_time:   dc.T_failure_time,
					T_pdf:            dc.T_pdf,
					T_Certificate_sn: dc.T_Certificate_sn,
					T_remark:         dc.T_remark,
					T_State:          1,
				}
				Device.Add_DeviceClassList(dcr)
			}
		}
		Task.Import_Task_Back(sn, id_str, T_task_id, To_T_task_id, StartTime, EndTime)

	}
	System.Add_UserLogs_T(T_uuid, "复制任务数据", fmt.Sprintf("复制任务数据(%s->%s)[%s|%s]", T_task_id, To_T_task_id, StartTime, EndTime), SN_List)

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

}

// 复制到
func (c *TaskDataController) Import_TaskData_SN() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	T_sn := c.GetString("T_sn")
	System.Add_UserLogs_T(T_uuid, "重置 SN数据", "Z_TaskData_"+T_task_id, T_sn)
	DeviceClass_r, is := Device.Read_DeviceClassList_T_class_T_sn(Task_r.T_class, T_sn)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: T_sn + " 没找到!"}
		c.ServeJSON()
		return
	}
	开始时间 := ""
	结束时间 := ""

	部点终端_list := Device.Read_DeviceClassList_List_id(Task_r.T_class)
	for _, v := range 部点终端_list {
		List_data, _ := Task.Read_TaskData_ById_List(Task_r.T_task_id, v.T_sn, v.T_id, "", "", 0, 9999)

		if len(List_data) < 10 {
			continue
		}
		开始时间 = List_data[len(List_data)-1].T_time
		结束时间 = List_data[0].T_time

	}
	if len(开始时间) == 0 || 开始时间 == "null" {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据 没找到 一条可用的!"}
		c.ServeJSON()
		return
	}

	Task.Import_TaskData_Back(T_sn, DeviceClass_r.T_id, Task_r.T_task_id, 开始时间, 结束时间)

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

}

// 更新线上数据
func (c *TaskDataController) TaskData_Up_TaskData() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if err = lib.Create_Dir(conf.Sql_Temp_Dir); err != nil {
		logs.Println("创建sql临时文件失败")
	}
	sql_file := fmt.Sprintf("%sZ_TaskData_%s.sql", conf.Sql_Temp_Dir, T_task_id)
	org, err := Task.Dump_TaskData(T_task_id, conf.MysqlServer_Username, conf.MysqlServer_Password, conf.MysqlServer_UrlPort, conf.MysqlServer_Database, sql_file)
	if err != nil {
		logs.Println(T_uuid, "任务数据-更新线上数据", "导出线下数据Z_TaskData_"+T_task_id, err.Error())
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "z_task_data_" + T_task_id + "线下数据导出失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(T_uuid, "本地版-任务数据-更新线上数据", "线上导入数据Z_TaskData_"+T_task_id, org)

	i := 0
	flag := false
	for i < 10 {
		Task.Truncate_TaskData(conf.Server_AliasName, T_task_id)
		org, err = Task.Insert_TaskData(conf.MysqlServer2_Username, conf.MysqlServer2_Password, conf.MysqlServer2_UrlPort, conf.MysqlServer2_Database, sql_file)
		if err != nil {
			logs.Println(T_uuid, "任务数据-更新线上数据", "线上导入数据Z_TaskData_"+T_task_id, err.Error())
		} else {
			if Task.Check_TaskData_Num(T_task_id) {
				System.Add_UserLogs_T(T_uuid, "本地版-任务数据-更新线上数据", "线上导入数据Z_TaskData_"+T_task_id, org)
				flag = true
				break
			}
		}
		i++
	}
	// 重试10次后仍然没有成功导入数据
	if !flag {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "z_task_data_" + T_task_id + "线上导入数据失败!"}
		c.ServeJSON()
		return
	}

	//删除导出的sql文件
	_ = os.Remove(sql_file)

	// 线上数据更新后 将当前任务 交付审核 标志 为 1
	Task_r.T_delivery_state = 1
	err = NatsServer.Update_Task(Task_r)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	// 向线上用户日志表写入数据
	System.Add_UserLogs_T(T_uuid, "本地版-任务", "修改", Task_r)

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

}

// 更新线上数据后台执行
func (c *TaskDataController) TaskData_Up_TaskData_Back() {
	// 获取登录用户的uuid
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")

	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}

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

	exist := Task.CheckTableExist(conf.Local_AliasName, T_task_id)
	if !exist {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "本地数据不存在!"}
		c.ServeJSON()
		return
	}

	// 采集中
	Task_r.T_delivery_state = 2
	err = NatsServer.Update_Task(Task_r)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "提交失败!"}
		c.ServeJSON()
		return
	}

	data := Nats.Up_TaskData_Back{
		T_uuid: T_uuid,
		Task:   Task_r,
	}
	b, _ := msgpack.Marshal(&data)
	_ = lib.Nats.Publish("ColdVerify_Local_Up_TaskData", b)

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

}

// CopyFromPosition 数据拷贝
func (c *TaskDataController) CopyFromPosition() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	startTime, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	endTime, ok := lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	CopyTime := c.GetString("CopyTime")
	copyTime, ok := lib.TimeStrToTime(CopyTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04")
	// 时间间隔 分钟
	T_saveT, _ := c.GetInt("T_saveT")

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id_str := sn_id[0], sn_id[1]
		List, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, StartTime, EndTime, 0, 9999)
		Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, sn, id_str, CopyTime, CopyEndTime)
		ct := copyTime
		var valueStrings []string
		for _, data := range List {
			valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", data.T_sn, data.T_id, data.T_t, data.T_rh, ct.Format("2006-01-02 15:04")))
			ct = ct.Add(time.Second * time.Duration(T_saveT))
		}
		err = Task.Batch_Adds_TaskData(T_task_id, valueStrings)
		if err != nil {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据复制失败!" + err.Error()}
			c.ServeJSON()
			return
		}

	}
	System.Add_UserLogs_T(T_uuid, "数据复制", fmt.Sprintf("数据复制(%s)[%s|%s]，复制时间:%s，,时间间隔:%d", T_task_id, StartTime, EndTime, CopyTime, T_saveT), SN_List)

	c.Data["json"] = lib.JSONS{200, "数据复制已完成！", nil}
	c.ServeJSON()
	return
}

// RepairSensorData 数据补漏
func (c *TaskDataController) RepairSensorData() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	// 时间间隔 秒
	saveTime, _ := c.GetInt("T_saveT")

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	num := 0
	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id_str := sn_id[0], sn_id[1]
		list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, StartTime, EndTime, 0, 9999)
		for i := 0; i < len(list)-1; i++ {
			current := list[i].T_time
			next := list[i+1].T_time
			c, _ := time.Parse("2006-01-02 15:04", current)
			n, _ := time.Parse("2006-01-02 15:04", next)
			interval := n.Unix() - c.Unix()
			//logs.Debug("时间间隔：", interval, "保存时间：", saveTime)
			//fmt.Println("当前：", current, "下一个：", next)
			if int(interval) > saveTime {
				ttInterval := list[i+1].T_t - list[i].T_t
				ttt := list[i].T_t // 温度临时变量
				trhInterval := list[i+1].T_rh - list[i].T_rh
				trht := list[i].T_rh //湿度临时变量
				count := (int(interval) - saveTime) / saveTime
				if int(interval)%saveTime != 0 {
					count++
				}
				num += count
				for k := 0; k < count; k++ {
					t := c.Add(time.Second * time.Duration(saveTime)).Format("2006-01-02 15:04") //时间临时变量
					ttt += ttInterval / float32(count)
					trht += trhInterval / float32(count)
					Task.InsertTaskData(Task_r.T_task_id, Task.TaskData_{
						T_sn:   list[i].T_sn,
						T_id:   list[i].T_id,
						T_t:    ttt,
						T_rh:   trht,
						T_time: t,
					})
					c = c.Add(time.Second * time.Duration(saveTime))
				}
			}
		}
	}
	System.Add_UserLogs_T(T_uuid, "数据补漏", fmt.Sprintf("数据补漏(%s)[%s|%s]，时间间隔:%d", T_task_id, StartTime, EndTime, saveTime), SN_List)

	c.Data["json"] = lib.JSONS{200, fmt.Sprintf("补漏完成！共补漏%d条数据", num), nil}
	c.ServeJSON()
	return
}

// DataSensorDataTrend 数据趋势
func (c *TaskDataController) DataSensorDataTrend() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}

	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	// 时间间隔 秒
	saveTime, _ := c.GetInt("T_saveT")

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id_str := sn_id[0], sn_id[1]
		list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, StartTime, EndTime, 0, 9999)
		if len(list) == 0 {
			continue
		}

		Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, sn, id_str, StartTime, EndTime)
		first := list[0]
		last := list[len(list)-1]

		current, _ := time.Parse("2006-01-02 15:04", first.T_time)
		next, _ := time.Parse("2006-01-02 15:04", last.T_time)
		interval := next.Sub(current).Seconds() / float64(saveTime)
		ttInterval := (last.T_t - first.T_t) / float32(interval)
		trhInterval := (last.T_rh - first.T_rh) / float32(interval)
		tt := first.T_t
		ttrh := first.T_rh

		var valueStrings []string
		for current.Unix() <= next.Unix() {
			tt += ttInterval
			ttrh += trhInterval
			ttime := current.Format("2006-01-02 15:04")
			valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", first.T_sn, id_str, tt, ttrh, ttime))
			current = current.Add(time.Second * time.Duration(saveTime))
		}

		err = Task.Batch_Adds_TaskData(T_task_id, valueStrings)
		if err != nil {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据复制失败!" + err.Error()}
			c.ServeJSON()
			return
		}

	}
	System.Add_UserLogs_T(T_uuid, "数据趋势", fmt.Sprintf("数据趋势(%s)[%s|%s]，时间间隔:%d", T_task_id, StartTime, EndTime, saveTime), SN_List)

	c.Data["json"] = lib.JSONS{200, "设置趋势操作成功", nil}
	c.ServeJSON()
	return
}

// UpdateRand 数据随机
func (c *TaskDataController) UpdateRand() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	TemperatureMin, _ := c.GetInt("TemperatureMin") // 温度
	TemperatureMax, _ := c.GetInt("TemperatureMax")
	HumidityMax, _ := c.GetInt("HumidityMax") // 湿度
	HumidityMin, _ := c.GetInt("HumidityMin")

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id := sn_id[0], sn_id[1]
		Task.UpdateTaskDataTemperatureAndHumidityRandom(Task_r.T_task_id, sn, id, StartTime, EndTime, TemperatureMax, TemperatureMin, HumidityMax, HumidityMin)
	}
	System.Add_UserLogs_T(T_uuid, "数据随机", fmt.Sprintf("数据随机(%s)[%s|%s]，温度[%d-%d]，湿度[%d-%d]", T_task_id, StartTime, EndTime, TemperatureMin, TemperatureMax, HumidityMax, HumidityMin), SN_List)

	//反馈成功
	c.Data["json"] = lib.JSONS{200, "调整随机偏移值成功!", nil}
	c.ServeJSON()
	return
}

// UpdateFix 更新固定值
func (c *TaskDataController) UpdateFix() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	FixTemperature := c.GetString("FixTemperature")
	FixHumidity := c.GetString("FixHumidity")
	//2.得到数据进行统一设置访问修改
	humidity, _ := strconv.ParseFloat(FixHumidity, 64)
	temperature, _ := strconv.ParseFloat(FixTemperature, 64)

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	//3.循环更新数据
	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id := sn_id[0], sn_id[1]
		Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, sn, id, StartTime, EndTime, temperature, humidity)
	}
	System.Add_UserLogs_T(T_uuid, "更新固定值", fmt.Sprintf("更新固定值(%s)[%s|%s]，温度[%f]，湿度[%f]", T_task_id, StartTime, EndTime, temperature, humidity), SN_List)

	//4.反馈成功
	c.Data["json"] = lib.JSONS{200, "调整固定偏移值成功！", nil}
	c.ServeJSON()
}

// DataSensorDataSmooth 数据平滑
func (c *TaskDataController) DataSensorDataSmooth() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	tRange, _ := c.GetFloat("tRange")
	hRange, _ := c.GetFloat("hRange")

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	var count int
	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn := sn_id[0]
		id_str := sn_id[1]
		list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, StartTime, EndTime, 0, 9999)
		for i := 1; i < len(list); i++ {
			n := list[i-1]
			old := list[i]
			newO := list[i]
			//变化差
			var tInterval = old.T_t - n.T_t
			var hInterval = old.T_rh - n.T_rh
			fmt.Println("温度：", n.T_t, "温度next：", old.T_t, "差值：", n.T_t-old.T_t)
			if tRange != 0 {
				if tInterval > float32(tRange) {
					newO.T_t = n.T_t + float32(tRange)
				} else if tInterval < -float32(tRange) {
					newO.T_t = n.T_t - float32(tRange)
				}
			}
			if hRange != 0 {
				if hInterval > float32(hRange) {
					newO.T_rh = n.T_rh + float32(hRange)
				} else if hInterval < -float32(hRange) {
					newO.T_rh = n.T_rh - float32(hRange)
				}
			}
			if old.T_rh != newO.T_rh || old.T_t != newO.T_t {
				fmt.Println("原始数据：", old, "新数据：", newO)
				list[i] = newO
				Task.UpdateTaskData(Task_r.T_task_id, sn, id_str, old, newO)
				count++
			}
		}
	}
	System.Add_UserLogs_T(T_uuid, "数据平滑", fmt.Sprintf("数据平滑(%s)[%s|%s]，温度[%f]，湿度[%f]", T_task_id, StartTime, EndTime, tRange, hRange), SN_List)

	c.Data["json"] = lib.JSONS{200, "操作成功处理" + fmt.Sprint(count) + "条数据", nil}
	c.ServeJSON()
}

// CopyFromPosition 数据拷贝平均值
func (c *TaskDataController) CopyFromPositionAverageSN() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	CopyTime := c.GetString("CopyTime")
	CopySN := c.GetString("CopySN")
	CopyID := c.GetString("CopyID")
	copyTime, ok := lib.TimeStrToTime(CopyTime)
	// 时间间隔 s
	T_saveT, _ := c.GetInt("T_saveT")
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}

	T_switch_t, _ := c.GetBool("T_switch_t", true)
	T_switch_h, _ := c.GetBool("T_switch_h", true)

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")
	if len(SN_List) != 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "SN_List Err!"}
		c.ServeJSON()
		return
	}
	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}
	sn_id1 := strings.Split(SN_List[0], ",")
	if len(sn_id1) != 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "SN_List Err!"}
		c.ServeJSON()
		return
	}
	sn1, id_str1 := sn_id1[0], sn_id1[1]
	sn_id2 := strings.Split(SN_List[1], ",")
	if len(sn_id2) != 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "SN_List Err!"}
		c.ServeJSON()
		return
	}
	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
	CopyEndTime := ct
	for i := 0; i < num; i++ {
		if List1[i].T_time != List2[i].T_time {
			c.Data["json"] = lib.JSONS{202, fmt.Sprintf("%s【%s】、%s【%s】时间不一致", List1[i].T_id, List1[i].T_time, List2[i].T_id, List2[i].T_time), nil}
			c.ServeJSON()
			return
			//ct = ct.Add(time.Second * time.Duration(T_saveT))
			//continue
		}
		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"),
		})
		CopyEndTime = ct
		ct = ct.Add(time.Second * time.Duration(T_saveT))
	}

	Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, CopySN, CopyID, CopyTime, CopyEndTime.Format("2006-01-02 15:04"))

	go func(TaskDataList []Task.TaskData_, task_id string) {
		for _, taskData := range TaskDataList {
			Task.InsertTaskData_TH(task_id, T_switch_t, T_switch_h, taskData)
		}
	}(list, Task_r.T_task_id)

	System.Add_UserLogs_T(T_uuid, "数据复制平均值", fmt.Sprintf("数据复制(%s)[%s|%s]，复制时间:%s，,时间间隔:%d", T_task_id, StartTime, EndTime, CopyTime, T_saveT), SN_List)

	c.Data["json"] = lib.JSONS{200, "数据复制已提交后台处理！", nil}
	c.ServeJSON()
	return
}

// CopyFromPosition 数据拷贝
func (c *TaskDataController) CopyFromPositionSN() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	startTime, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	endTime, ok := lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	CopyTime := c.GetString("CopyTime")
	copyTime, ok := lib.TimeStrToTime(CopyTime)
	CopySN := c.GetString("CopySN")
	CopyID := c.GetString("CopyID")
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	CopyEndTime := copyTime.Add(endTime.Sub(startTime)).Format("2006-01-02 15:04")
	// 时间间隔 分钟
	T_saveT, _ := c.GetInt("T_saveT")

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")
	if len(SN_List) != 1 {
		c.Data["json"] = lib.JSONS{202, "SN_List Err！", nil}
		c.ServeJSON()
		return
	}
	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	sn_id := strings.Split(SN_List[0], ",")
	if len(sn_id) != 2 {
		c.Data["json"] = lib.JSONS{202, "SN_List Err！", nil}
		c.ServeJSON()
		return
	}
	sn, id_str := sn_id[0], sn_id[1]
	List, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, sn, id_str, StartTime, EndTime, 0, 9999)
	Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, CopySN, CopyID, CopyTime, CopyEndTime)
	ct := copyTime
	var valueStrings []string
	for _, data := range List {
		valueStrings = append(valueStrings, fmt.Sprintf("('%s','%s',%v,%v,'%s')", CopySN, CopyID, data.T_t, data.T_rh, ct.Format("2006-01-02 15:04")))
		ct = ct.Add(time.Second * time.Duration(T_saveT))
	}
	err = Task.Batch_Adds_TaskData(T_task_id, valueStrings)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据拷贝失败!" + err.Error()}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(T_uuid, "数据拷贝", fmt.Sprintf("数据拷贝(%s)[%s|%s]，拷贝时间:%s，,时间间隔:%d", T_task_id, StartTime, EndTime, CopyTime, T_saveT), SN_List)

	c.Data["json"] = lib.JSONS{200, "数据拷贝已完成！", nil}
	c.ServeJSON()
	return
}

// DataRemoveDuplicates 数据去重
func (c *TaskDataController) DataRemoveDuplicates() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	// 删除重复数据
	var count int64
	count, err = Task.DeleteDeduplicate(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "导入失败"}
		c.ServeJSON()
		return
	}

	System.Add_UserLogs_T(T_uuid, "数据去重", fmt.Sprintf("数据平滑(%s)[%d]条", T_task_id, count), nil)

	c.Data["json"] = lib.JSONS{200, "操作成功处理" + fmt.Sprint(count) + "条数据", nil}
	c.ServeJSON()
}

// 数据偏移到区间内
func (c *TaskDataController) DataSkewingInterval() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	TemperatureMin, _ := c.GetFloat("TemperatureMin") // 温度
	TemperatureMax, _ := c.GetFloat("TemperatureMax")
	Tmin, Tmax := TemperatureMin, TemperatureMax

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}
	errMsg := []string{}

	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id := sn_id[0], sn_id[1]
		min, max := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, sn, id, StartTime, EndTime)
		if min < Tmin && max > Tmax {
			errMsg = append(errMsg, fmt.Sprintf("【%s】最低温度[%.2f]低于给定的最低温度[%.2f]，并且最高温度[%.2f]高于给定的最高温度[%.2f]，无法偏移！", id, min, Tmin, max, Tmax))
			continue
		}
		if min > Tmin && max < Tmax {
			continue
			//errMsg = append(errMsg, fmt.Sprintf("【%s】最低温度[%.2f]高于给定最低温度[%.2f]，并且最高温度[%.2f]低于给定最高温度[%.2f],无须偏移！", id, min, Tmin, max, Tmax))
		}

		// 判断是否能向上偏移
		if min < Tmin && max < Tmax && (Tmin-min+max) > Tmax {
			errMsg = append(errMsg, fmt.Sprintf("【%s】偏移后最高温度[%.2f]将高于给定的最高温度[%.2f]，无法偏移！", id, Tmin-min+max, Tmax))
			continue
		}

		if max > Tmax && min > Tmin && (min-(max-Tmax)) < Tmin {
			errMsg = append(errMsg, fmt.Sprintf("【%s】偏移后最低温度[%.2f]将低于给定的最低温度[%.2f]，无法偏移！", id, min-(max-Tmax), Tmin))
			continue
		}
		// 向上偏移
		if min < Tmin && max < Tmax && (Tmin-min+max) <= Tmax {
			Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, sn, id, StartTime, EndTime, Tmin-min, 0)
			continue
		}
		// 向下偏移
		if max > Tmax && min > Tmin && (min-(max-Tmax)) >= Tmin {
			Task.UpdateTaskDataTemperatureAndHumidity(Task_r.T_task_id, sn, id, StartTime, EndTime, -(max - Tmax), 0)
			continue
		}

	}
	System.Add_UserLogs_T(T_uuid, "数据偏移到给定范围", fmt.Sprintf("数据偏移到给定范围(%s)[%s|%s]，温度[%f-%f]", T_task_id, StartTime, EndTime, TemperatureMin, TemperatureMax), SN_List)
	if len(errMsg) > 0 {
		c.Data["json"] = lib.JSONS{202, "", errMsg}
		c.ServeJSON()
		return
	}
	//反馈成功
	c.Data["json"] = lib.JSONS{200, "调整区间偏移值成功!", nil}
	c.ServeJSON()
	return
}

// 等比缩放
func (c *TaskDataController) DataGeometricScale() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}
	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	Temperature, _ := c.GetFloat("Temperature") // 温度比列
	Humidity, _ := c.GetFloat("Humidity")       // 适度比列

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}
	errMsg := []string{}

	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id := sn_id[0], sn_id[1]
		Task.UpdateTaskDataTemperatureAndHumidityByGeometric(Task_r.T_task_id, sn, id, StartTime, EndTime, Temperature, Humidity)

	}
	System.Add_UserLogs_T(T_uuid, "数据等比缩放", fmt.Sprintf("数据等比缩放(%s)[%s|%s]，温度[%f-%f]", T_task_id, StartTime, EndTime, Temperature, Humidity), SN_List)
	if len(errMsg) > 0 {
		c.Data["json"] = lib.JSONS{202, "", errMsg}
		c.ServeJSON()
		return
	}
	//反馈成功
	c.Data["json"] = lib.JSONS{200, "数据等比缩放成功!", nil}
	c.ServeJSON()
	return
}

// DataBatchDelete 批量删除
func (c *TaskDataController) DataBatchDelete() {
	T_uuid, _ := lib.GetAdminT_Uuid(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	//if !b_ {
	//	c.Data["json"] = lib.JSONS{Code: 201, Msg: "User_tokey Err!"}
	//	c.ServeJSON()
	//	return
	//}

	StartTime := c.GetString("StartTime")
	_, ok := lib.TimeStrToTime(StartTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}
	EndTime := c.GetString("EndTime")
	_, ok = lib.TimeStrToTime(EndTime)
	if !ok {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
		c.ServeJSON()
		return
	}

	SN_List := strings.Split(strings.Trim(c.GetString("SN_List"), "|"), "|")

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	for _, v := range SN_List {
		sn_id := strings.Split(v, ",")
		if len(sn_id) != 2 {
			continue
		}
		sn, id_str := sn_id[0], sn_id[1]

		Task.DeleteTaskDataByTimeRange(Task_r.T_task_id, sn, id_str, StartTime, EndTime)
	}
	System.Add_UserLogs_T(T_uuid, "批量删除", fmt.Sprintf("批量删除(%s)[%s|%s]", T_task_id, StartTime, EndTime), SN_List)

	c.Data["json"] = lib.JSONS{200, "批量删除操作成功", nil}
	c.ServeJSON()
	return
}

// 存档列表
func (c *TaskDataController) TaskDataCopy_List() {

	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_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	var cnt int64
	List, cnt := Task.Read_TaskCopy_List(Task_r.T_task_id, 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 *TaskDataController) TaskDataCopy_Add() {

	T_task_id := c.GetString("T_task_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	var_ := Task.TaskCopy{
		T_task_id: T_task_id,
		T_time:    time.Now().Format("2006-01-02 15:04:05"),
		T_State:   1,
	}

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

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

}

// 编辑存档
func (c *TaskDataController) TaskDataCopy_Edit() {

	T_copy_id := c.GetString("T_copy_id")
	T_name := c.GetString("T_name")
	r, err := Task.Read_TaskCopy(T_copy_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_copy_id 错误!"}
		c.ServeJSON()
		return
	}

	r.T_time = T_name
	if !Task.Update_TaskCopy(r, "T_time") {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: T_copy_id}
	c.ServeJSON()
	return

}

// 删除存档
func (c *TaskDataController) TaskDataCopy_Del() {

	T_copy_id := c.GetString("T_copy_id")
	r, err := Task.Read_TaskCopy(T_copy_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_copy_id 错误!"}
		c.ServeJSON()
		return
	}
	if r.T_State == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "生成报告数据，禁止删除!"}
		c.ServeJSON()
		return
	}

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

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

}

// 存档恢复
func (c *TaskDataController) TaskDataCopy_Recover() {
	T_task_id := c.GetString("T_task_id")
	T_copy_id := c.GetString("T_copy_id")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}
	_, err = Task.Read_TaskCopy(T_copy_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_copy_id 错误!"}
		c.ServeJSON()
		return
	}

	is := Task.TaskData_Recover(T_task_id, T_copy_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
		c.ServeJSON()
		return
	}

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

}

// 查询图片生成状态
func (c *TaskDataController) TaskData_JPGState() {

	T_task_id := c.GetString("T_task_id")
	jpg, is := Task.Redis_TaskDataJPG_Get(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "暂无图片正在生成"}
		c.ServeJSON()
		return
	}
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: jpg}
	c.ServeJSON()
	return
}

func (c *TaskDataController) TaskData_JPG() {
	StartTime := c.GetString("StartTime")
	if len(StartTime) > 0 {
		_, ok := lib.TimeStrToTime(StartTime)
		if !ok {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
			c.ServeJSON()
			return
		}
	}

	EndTime := c.GetString("EndTime")
	if len(EndTime) > 0 {
		_, ok := lib.TimeStrToTime(EndTime)
		if !ok {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "时间格式错误!"}
			c.ServeJSON()
			return
		}
	}

	TemperatureMin, _ := c.GetFloat("TemperatureMin") // 最低温度
	TemperatureMax, _ := c.GetFloat("TemperatureMax") // 最高温度

	T_task_id := c.GetString("T_task_id")
	SN_List := c.GetString("SN_List")
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}
	Task.Redis_TaskDataJPG_Del(T_task_id)

	// 生成图片
	go TaskDataJPG(StartTime, EndTime, T_task_id, SN_List, TemperatureMin, TemperatureMax)

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

// 存档生成图片
func TaskDataJPG(StartTime, EndTime, T_task_id, snList string, TemperatureMin, TemperatureMax float64) {
	Task.Redis_TaskDataJPG_Set(T_task_id, Task.TaskDataJPG{
		State: 1,
		Msg:   "图片生成中",
		Url:   "",
	})
	msg := ""
	state := 2
	url := ""

	SN_List := strings.Split(strings.Trim(snList, "|"), "|")
	if len(snList) == 0 {
		List := Task.Read_TaskData_ById_ClassList(T_task_id)
		for _, v := range List {
			SN_List = append(SN_List, fmt.Sprintf("%s,%s", v.T_sn, v.T_id))
		}
	}
	id_List := []string{}
	sn_List := []string{}
	if len(snList) > 0 {
		for _, v := range SN_List {
			sn_id := strings.Split(v, ",")
			if len(sn_id) != 2 {
				return
			}
			id_List = append(id_List, fmt.Sprintf("'%s'", sn_id[1]))
			sn_List = append(sn_List, fmt.Sprintf("'%s'", sn_id[0]))
		}
	}
	ymin, ymax, minTime, maxTime := Task.Read_TaskData_T_Min_Max_Time_Min_Max(T_task_id, sn_List, id_List, StartTime, EndTime)
	xmin, xmax := float64(minTime.Unix()), float64(maxTime.Unix())
	// 创建一个新的绘图
	p := plot.New()

	// 设置绘图标题和标签
	p.Title.Text = "温度折线图"
	//p.Legend.ThumbnailWidth = 5 * vg.Inch
	p.X.Label.Text = "时间"
	p.Y.Label.Text = "温度"

	// 添加最高，最低标准线 用红色虚线标识
	p.Add(lib.HorizontalLine(xmin, xmax, TemperatureMin))

	p.Add(lib.HorizontalLine(xmin, xmax, TemperatureMax))

	var chData = make(chan int, 10)
	var jobGroup sync.WaitGroup

	// 创建温度线
	for i := 0; i < len(SN_List); i++ {
		chData <- 1
		jobGroup.Add(1)
		go func(index int) {
			//go func(index int, wg *sync.WaitGroup, p *plot.Plot) {
			defer func() {
				<-chData        // 完成时chan取出1个
				jobGroup.Done() // 完成时将等待组值减1
			}()

			sn_id := strings.Split(SN_List[index], ",")
			if len(sn_id) != 2 {
				return
			}
			sn, id := sn_id[0], sn_id[1]

			list, _ := Task.Read_TaskData_ById_List_AES(T_task_id, sn, id, StartTime, EndTime, 0, 9999)
			if len(list) == 0 {
				return
			}

			pts := make(plotter.XYs, len(list))
			for j, d := range list {
				t, _ := lib.TimeStrToTime(d.T_time)
				pts[j].X = float64(t.Unix())
				pts[j].Y = float64(d.T_t)
			}

			line, err := plotter.NewLine(pts)
			if err != nil {
				return
			}
			line.Color = lib.RandomColor(index)
			p.Add(line)
		}(i)
	}
	jobGroup.Wait()

	if ymax < 8 {
		ymax = 8
	}
	if ymin > 0 {
		ymin = 0
	}
	p.Y.Min, p.Y.Max = ymin, ymax

	p.X.Min, p.X.Max = xmin, xmax
	p.Y.Tick.Marker = lib.CommaTicks{}
	p.X.Tick.Marker = lib.TimeTicks{}
	p.X.Tick.Label.Rotation = math.Pi / 5
	p.X.Tick.Label.YAlign = draw.YCenter
	p.X.Tick.Label.XAlign = draw.XRight

	filename := "jpg" + time.Now().Format("20060102150405")
	// 保存文件
	if err := p.Save(10*vg.Inch, 4*vg.Inch, "ofile/"+filename+".jpg"); err != nil {
		state = 3
		msg = "图片生成失败"
		logs.Error(lib.FuncName(), "生成图片失败", err)
	}
	if !lib.Pload_qiniu("ofile/"+filename+".jpg", "ofile/"+filename+".jpg") {
		state = 3
		msg = "图片上传七牛云失败"
		logs.Error(lib.FuncName(), "上传七牛云失败")
	}
	//删除目录
	os.Remove("ofile/" + filename + ".jpg")
	if len(msg) == 0 {
		msg = "图片生成成功"
		url = "https://bzdcoldverifyoss.baozhida.cn/" + "ofile/" + filename + ".jpg"
	}

	Task.Redis_TaskDataJPG_Set(T_task_id, Task.TaskDataJPG{
		State: state,
		Msg:   msg,
		Url:   url,
	})

}

func (c *TaskDataController) Certificate_List() {

	var r_jsons lib.R_JSONS

	T_task_id := c.GetString("T_task_id")
	T_sn := c.GetString("T_sn")
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = conf.Page_size
	}
	Task_r, err := Task.Read_Task(T_task_id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取任务信息失败!"}
		c.ServeJSON()
		return
	}
	if Task_r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "数据采集中，请稍后!"}
		c.ServeJSON()
		return
	}

	List, cnt := Certificate.Read_Certificate_List(T_task_id, T_sn, page, page_z)

	r_jsons.List = List
	r_jsons.Page = page
	r_jsons.Page_size = page_z
	r_jsons.Num = int(cnt)

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

/*
===========================
				自动填写标签
========================
*/

// 自动填写标签数据 标签列表
func (c *TaskDataController) ListJson() {
	mySlice := []string{ // 20250310
		//"柜内所有测点",
		"均匀性布点",
		"产品存放区域测点",
		"作业出入口总测点",
		"风机布点总测点",
		"库内除风机出风口、回风口外总测点",
		"库内除风机出风口、回风口、特殊位置布点、作业口外总测点",
		"车内除风机出风口、回风口外总测点",
		"报告编号",
		"数据分析时间",
		"实施计划月份",
		"计划验证实施时间",
		"监测终端01",
		"监测终端安装编号01",
		"监测终端02",
		"监测终端安装编号02",
		"培训讲师",
		"培训时间",
		"冷藏柜内部最高温",
		"冷藏柜内部最低温",
		"冷藏柜外部环境测点最高温",
		"冷藏柜外部环境测点最低温",
		"内部环境分割线最低温",
		"内部环境分割线最高温",
		"静态第一次开箱注释",
		"静态第二次开箱注释",
		"静态第三次开箱注释",
		"动态第一次开箱注释",
		"动态第二次开箱注释",
		"动态第三次开箱注释",
		"第一次开箱注释",
		"第二次开箱注释",
		"第三次开箱注释",
		"保温箱温度设定值",
		"风机温度设定值",
		"保温箱准备开始时间",
		"冰排预冷保温箱准备结束时间",
		"第一次开门开始时间",
		"第一次开门结束时间",
		"满载第一次关门温度恢复时间",
		"空载第一次关门温度恢复时间",
		"满载第二次关门温度恢复时间",
		"空载第二次关门温度恢复时间",
		"满载第三次关门温度恢复时间",
		"空载第三次关门温度恢复时间",
		"满载开门最长需要多少分钟恢复",
		"空载开门最长需要多少分钟恢复",
		"冷藏库作业口外部环境分割线最低温",
		"冷藏库作业口外部环境分割线最高温",
		"冷藏库外部环境测点最高温",
		"冷藏库外部环境测点最低温",
		"冷藏库内部最高温",
		"冷藏库内部最低温",
		"冷藏车外部环境测点最高温",
		"冷藏车外部环境测点最低温",
		"冷藏车内部最高温",
		"冷藏车内部最低温",
		"验证测试期间当地天气情况曲线图",
		"当地历史气温数据查询曲线图",
		"预冷开始时间",
		"预冷结束时间",
		"运行确认及偏差处理（满载）开始时间",
		"运行确认及偏差处理（空载）开始时间",
		"运行确认及偏差处理（满载）结束时间",
		"运行确认及偏差处理（空载）结束时间",
		"温度自动监测设备放置位置开始时间",
		"温度自动监测设备放置位置结束时间",
		"冰排释冷开始时间",
		"冰排释冷结束时间",
		"最长保温时限开始时间",
		"最长保温时限结束时间",
		"温度分布特性开始时间",
		"温度分布特性结束时间",
		"冰排释冷分割线最高温",
		"冰排释冷分割线最低温",
		"外部环境分割线最高温",
		"外部环境分割线最低温",
		"监测系统配置的测点终端参数及安装位置确认（满载）开始时间",
		"监测系统配置的测点终端参数及安装位置确认（满载）结束时间",
		"监测系统配置的测点终端参数及安装位置确认（空载）开始时间",
		"监测系统配置的测点终端参数及安装位置确认（空载）结束时间",
		"满载测试结束风机停止时间",
		"空载测试结束风机停止时间",
		"满载风机启动时间点",
		"空载风机启动时间点",
		"满载风机停止时间点",
		"空载风机停止时间点",
		"满载风机启动时间点注释",
		"满载风机停止时间点注释",
		"满载测试结束风机停止时间注释",
		"空载风机启动时间点注释",
		"空载风机停止时间点注释",
		"空载测试结束风机停止时间注释",
		"温控设备运行参数及使用状况测试（满载）开始时间",
		"温控设备运行参数及使用状况测试（空载）开始时间",
		"温控设备运行参数及使用状况测试（满载）结束时间",
		"温控设备运行参数及使用状况测试（空载）结束时间",
		"（满载）温度偏差均匀度波动度分析时间区间",
		"（空载）温度偏差均匀度波动度分析时间区间",
		"温度分布特性的测试与分析（满载）开始时间",
		"温度分布特性的测试与分析（空载）开始时间",
		"温度分布特性的测试与分析（满载）结束时间",
		"温度分布特性的测试与分析（空载）结束时间",
	}

	// 现场测试结束时间放在最后
	mySlice = append(mySlice, "现场测试结束时间")

	c.Data["json"] = mySlice
	c.ServeJSON() // 使用 ServeJSON
}

/*  ----------------------------------------------------------------------------------- */

func (c *TaskDataController) A满载测试结束风机停止时间() {

	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")

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

	均匀性布点 := c.GetString("均匀性布点") //  v26nplogbwt1
	if len(均匀性布点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 均匀性布点 失败!"})
		return
	}
	产品存放区域测点 := c.GetString("产品存放区域测点") //  v26nplogbwt1
	if len(产品存放区域测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 产品存放区域测点 失败!"})
		return
	}
	均匀性布点 = 均匀性布点 + "|" + 产品存放区域测点

	开始时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）开始时间") //  v26nplogbwt1
	if len(开始时间) == 0 || 开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）开始时间 失败!"})
		return
	}
	结束时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）结束时间") //  v26nplogbwt1
	if len(结束时间) == 0 || 结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）结束时间 失败!"})
		return
	}

	// 获取数据波动最大的三条
	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 均匀性布点, "", 开始时间, 结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)

	list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 开始时间, 结束时间)
	fmt.Println("list:", list)
	CalculateHumps_list := Task.CalculateHumps(list)

	if len(CalculateHumps_list) < 5 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到连续5个循环 !"})
		return
	}
	fmt.Println("CalculateHumps_list:", CalculateHumps_list)
	//start := CalculateHumps_list[6].Start // 驼峰开始
	//peak := CalculateHumps_list[0]["peak"].(Task.TaskData) // 驼峰最高
	var end Task.TaskData_AVG
	if len(CalculateHumps_list) == 5 {
		end = CalculateHumps_list[4].End
	} else {
		end = CalculateHumps_list[5].End // 驼峰结束
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: end.T_time})

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

func (c *TaskDataController) A空载测试结束风机停止时间() {

	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")

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

	均匀性布点 := c.GetString("均匀性布点") //  v26nplogbwt1
	if len(均匀性布点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 均匀性布点 失败!"})
		return
	}
	产品存放区域测点 := c.GetString("产品存放区域测点") //  v26nplogbwt1
	if len(产品存放区域测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 产品存放区域测点 失败!"})
		return
	}
	均匀性布点 = 均匀性布点 + "|" + 产品存放区域测点

	开始时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）开始时间") //  v26nplogbwt1
	if len(开始时间) == 0 || 开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）开始时间 失败!"})
		return
	}
	结束时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）结束时间") //  v26nplogbwt1
	if len(结束时间) == 0 || 结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）结束时间 失败!"})
		return
	}

	// 获取数据波动最大的三条
	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 均匀性布点, "", 开始时间, 结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)
	list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 开始时间, 结束时间)
	CalculateHumps_list := Task.CalculateHumps(list)

	var end Task.TaskData_AVG
	if len(CalculateHumps_list) == 5 {
		end = CalculateHumps_list[4].End
	} else {
		end = CalculateHumps_list[5].End // 驼峰结束
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: end.T_time})

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

func (c *TaskDataController) A满载风机停止时间点() {

	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")

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

	均匀性布点 := c.GetString("均匀性布点") //  v26nplogbwt1
	if len(均匀性布点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 均匀性布点 失败!"})
		return
	}
	产品存放区域测点 := c.GetString("产品存放区域测点") //  v26nplogbwt1
	if len(产品存放区域测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 产品存放区域测点 失败!"})
		return
	}
	均匀性布点 = 均匀性布点 + "|" + 产品存放区域测点

	开始时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）开始时间") //  v26nplogbwt1
	if len(开始时间) == 0 || 开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）开始时间 失败!"})
		return
	}
	结束时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）结束时间") //  v26nplogbwt1
	if len(结束时间) == 0 || 结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）结束时间 失败!"})
		return
	}

	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 均匀性布点, "", 开始时间, 结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)
	list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 开始时间, 结束时间)
	CalculateHumps_list := Task.CalculateHumps(list)

	if len(CalculateHumps_list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到连续1个循环 !"})
		return
	}
	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
	//peak := CalculateHumps_list[0]["peak"].(Task.TaskData) // 驼峰最高
	end := CalculateHumps_list[0].End // 驼峰结束
	fmt.Println(end)
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: end.T_time})

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

func (c *TaskDataController) A空载风机停止时间点() {

	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")

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

	均匀性布点 := c.GetString("均匀性布点") //  v26nplogbwt1
	if len(均匀性布点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 均匀性布点 失败!"})
		return
	}
	产品存放区域测点 := c.GetString("产品存放区域测点") //  v26nplogbwt1
	if len(产品存放区域测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 产品存放区域测点 失败!"})
		return
	}
	均匀性布点 = 均匀性布点 + "|" + 产品存放区域测点

	开始时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）开始时间") //  v26nplogbwt1
	if len(开始时间) == 0 || 开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）开始时间 失败!"})
		return
	}
	结束时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）结束时间") //  v26nplogbwt1
	if len(结束时间) == 0 || 结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）结束时间 失败!"})
		return
	}

	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 均匀性布点, "", 开始时间, 结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)
	list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 开始时间, 结束时间)
	CalculateHumps_list := Task.CalculateHumps(list)

	if len(CalculateHumps_list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到连续1个循环 !"})
		return
	}
	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
	//peak := CalculateHumps_list[0]["peak"].(Task.TaskData) // 驼峰最高
	end := CalculateHumps_list[0].End // 驼峰结束

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: end.T_time})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A空载风机启动时间点() {

	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")

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

	均匀性布点 := c.GetString("均匀性布点") //  v26nplogbwt1
	if len(均匀性布点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 均匀性布点 失败!"})
		return
	}
	产品存放区域测点 := c.GetString("产品存放区域测点") //  v26nplogbwt1
	if len(产品存放区域测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 产品存放区域测点 失败!"})
		return
	}
	均匀性布点 = 均匀性布点 + "|" + 产品存放区域测点

	开始时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）开始时间") //  v26nplogbwt1
	if len(开始时间) == 0 || 开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）开始时间 失败!"})
		return
	}
	结束时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）结束时间") //  v26nplogbwt1
	if len(结束时间) == 0 || 结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）结束时间 失败!"})
		return
	}

	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 均匀性布点, "", 开始时间, 结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)
	list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 开始时间, 结束时间)
	CalculateHumps_list := Task.CalculateHumps(list)

	if len(CalculateHumps_list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到连续1个循环 !"})
		return
	}
	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
	peak := CalculateHumps_list[0].Peak // 驼峰最高
	//end := CalculateHumps_list[0]["end"].(Task.TaskData)    // 驼峰结束

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: peak.T_time})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A满载风机启动时间点() {

	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")

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

	均匀性布点 := c.GetString("均匀性布点") //  v26nplogbwt1
	if len(均匀性布点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 均匀性布点 失败!"})
		return
	}
	产品存放区域测点 := c.GetString("产品存放区域测点") //  v26nplogbwt1
	if len(产品存放区域测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 产品存放区域测点 失败!"})
		return
	}
	均匀性布点 = 均匀性布点 + "|" + 产品存放区域测点

	开始时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）开始时间") //  v26nplogbwt1
	if len(开始时间) == 0 || 开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）开始时间 失败!"})
		return
	}
	结束时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）结束时间") //  v26nplogbwt1
	if len(结束时间) == 0 || 结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）结束时间 失败!"})
		return
	}

	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 均匀性布点, "", 开始时间, 结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)
	list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 开始时间, 结束时间)
	CalculateHumps_list := Task.CalculateHumps(list)

	if len(CalculateHumps_list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到连续1个循环 !"})
		return
	}
	//start := CalculateHumps_list[0]["start"].(Task.TaskData)  // 驼峰开始
	peak := CalculateHumps_list[0].Peak // 驼峰最高
	//end := CalculateHumps_list[0]["end"].(Task.TaskData)    // 驼峰结束

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: peak.T_time})

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

func (c *TaskDataController) A冷藏柜内部最高温() {

	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")

	时间 := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A冷藏柜内部最低温() {

	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")

	时间 := c.GetString("温度控制范围最小值") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最小值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A第一次开门结束时间() {

	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")

	时间 := c.GetString("开空结") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		时间 = c.GetString("开满结") //  v26nplogbwt1
		if len(时间) == 0 || 时间 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 开空结 或 开满结 失败!"})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A第一次开门开始时间() {

	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")
	c.Ctx.ResponseWriter.Header().Set("Connection", "keep-alive")

	时间 := c.GetString("开空开") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		时间 = c.GetString("开满开") //  v26nplogbwt1
		if len(时间) == 0 || 时间 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 开空开 或 开满开 失败!"})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A空载测试结束风机停止时间注释() {

	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")

	时间 := c.GetString("空载测试结束风机停止时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 空载测试结束风机停止时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A空载风机停止时间点注释() {

	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")

	时间 := c.GetString("空载风机停止时间点") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 空载风机停止时间点 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A空载风机启动时间点注释() {

	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")

	时间 := c.GetString("空载风机启动时间点") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 空载风机启动时间点 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A满载测试结束风机停止时间注释() {

	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")

	时间 := c.GetString("满载测试结束风机停止时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 满载测试结束风机停止时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A满载风机停止时间点注释() {

	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")

	时间 := c.GetString("满载风机停止时间点") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 满载风机停止时间点 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A柜内所有测点() {

	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")

	时间 := c.GetString("均匀性布点") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 均匀性布点 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A均匀性布点() {

	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")

	时间 := c.GetString("柜内所有测点") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A产品存放区域测点() {

	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")

	时间 := c.GetString("柜内所有测点") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A满载风机启动时间点注释() {

	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")

	时间 := c.GetString("满载风机启动时间点") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 满载风机启动时间点 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A运行确认及偏差处理空载开始时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点") //  v26nplogbwt1
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("库内所有测点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("车内所有测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜/库/车内所有测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 柜内所有测点, "", 现场测试开始时间, 现场测试结束时间, 0, 9999)
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点|现场测试开始时间-现场测试结束时间 当前 温度数据 失败!"})
		return
	}

	//情况1 现场测试开始时间的温度低于温度控制范围最高值，直接取现场测试开始时间
	firstTimeData := Task.GetFirstTimeData(list)
	超过温度控制范围最高值 := false
	for _, v := range firstTimeData {
		if v.T_t > 温度控制范围最高值 {
			超过温度控制范围最高值 = true
		}
	}
	if !超过温度控制范围最高值 {
		// 当发现数字开始上升时，结束递减状态
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: firstTimeData[0].T_time})
		return
	}

	// 情况2 现场测试开开始时间温度高于温度控制范围最高值，取温度下降至“温度控制范围最高值”以下的第一个终端，该终端下降至最低点，并出现上升0.2℃的时间点

	groupMap := make(map[string][]Task.TaskData_)
	for _, r := range list {
		groupMap[r.T_id] = append(groupMap[r.T_id], r)
	}

	var latest *Task.TaskData_

	for _, group := range groupMap {
		candidate := Task.FindFirstDecreasingTendency(group, 温度控制范围最高值-0.1)
		if candidate != nil {
			if latest == nil || lib.ParseTime(candidate.T_time).After(lib.ParseTime(latest.T_time)) {
				latest = candidate
			}
		}
	}
	if latest == nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 温度下降至“温度控制范围最高值”以下 数据!"})
		return
	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: latest.T_time})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A运行确认及偏差处理满载开始时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点") //  v26nplogbwt1
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("库内所有测点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("车内所有测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜/库/车内所有测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 柜内所有测点, "", 现场测试开始时间, 现场测试结束时间, 0, 9999)
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点|现场测试开始时间-现场测试结束时间 温度数据列表 失败!"})
		return
	}

	//情况1 现场测试开始时间的温度低于温度控制范围最高值，直接取现场测试开始时间
	firstTimeData := Task.GetFirstTimeData(list)
	超过温度控制范围最高值 := false
	for _, v := range firstTimeData {
		if v.T_t > 温度控制范围最高值 {
			超过温度控制范围最高值 = true
		}
	}
	if !超过温度控制范围最高值 {
		// 当发现数字开始上升时，结束递减状态
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: firstTimeData[0].T_time})
		return
	}

	// 情况2 现场测试开开始时间温度高于温度控制范围最高值，取温度下降至“温度控制范围最高值”以下的最后一个终端，该终端下降至最低点，并出现上升0.2℃的时间点
	groupMap := make(map[string][]Task.TaskData_)
	for _, r := range list {
		groupMap[r.T_id] = append(groupMap[r.T_id], r)
	}

	var latest *Task.TaskData_

	for _, group := range groupMap {
		candidate := Task.FindFirstDecreasingTendency(group, 温度控制范围最高值-0.1)
		if candidate != nil {
			if latest == nil || lib.ParseTime(candidate.T_time).After(lib.ParseTime(latest.T_time)) {
				latest = candidate
			}
		}
	}
	if latest == nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 温度下降至“温度控制范围最高值”以下 数据!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: latest.T_time})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A运行确认及偏差处理空载结束时间() {

	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")

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

	所有测点 := c.GetString("柜内所有测点") //  v26nplogbwt1
	if len(所有测点) == 0 {
		所有测点 = c.GetString("库内所有测点")
	}
	if len(所有测点) == 0 {
		所有测点 = c.GetString("车内所有测点")
	}
	if len(所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜/库/车内所有测点 失败!"})
		return
	}

	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	运行确认及偏差处理空载开始时间 := c.GetString("运行确认及偏差处理（空载）开始时间")
	if len(运行确认及偏差处理空载开始时间) == 0 || 运行确认及偏差处理空载开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 运行确认及偏差处理（空载）开始时间 失败!"})
		return
	}

	// 获取数据波动最大的三条
	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 所有测点, "", 运行确认及偏差处理空载开始时间, 现场测试结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)

	list2 := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 运行确认及偏差处理空载开始时间, 现场测试结束时间)
	CalculateHumps_list := Task.CalculateHumps(list2)

	if len(CalculateHumps_list) < 4 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到连续2个循环 !"})
		return
	}

	end := CalculateHumps_list[1].End // 驼峰结束
	endIndex := 0
	for i := 0; i < len(list2); i++ {
		if list2[i].T_time == end.T_time {
			endIndex = i
		}
	}
	list3 := list2[endIndex:]
	for i := 0; i < len(list3); i++ {
		if list3[i].T_t >= end.T_t+0.2 {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list3[i].T_time})
			return

		}
	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 开始时间过后出现第二个循环温度再次上升0.2℃的拐点时间点  数据!"})
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A运行确认及偏差处理满载结束时间() {

	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")

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

	所有测点 := c.GetString("柜内所有测点") //  v26nplogbwt1
	if len(所有测点) == 0 {
		所有测点 = c.GetString("库内所有测点")
	}
	if len(所有测点) == 0 {
		所有测点 = c.GetString("车内所有测点")
	}
	if len(所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜/库/车内所有测点 失败!"})
		return
	}

	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	运行确认及偏差处理满载开始时间 := c.GetString("运行确认及偏差处理（满载）开始时间")
	if len(运行确认及偏差处理满载开始时间) == 0 || 运行确认及偏差处理满载开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 运行确认及偏差处理（满载）开始时间 失败!"})
		return
	}

	// 获取数据波动最大的三条
	initialData, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 所有测点, "", 运行确认及偏差处理满载开始时间, 现场测试结束时间, 0, 9999)
	snList := Task.GetTheGreatestFluctuations(initialData, 3)
	list2 := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, snList, 运行确认及偏差处理满载开始时间, 现场测试结束时间)
	CalculateHumps_list := Task.CalculateHumps(list2)

	if len(CalculateHumps_list) < 4 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到连续2个循环 !"})
		return
	}

	end := CalculateHumps_list[1].End // 驼峰结束
	endIndex := 0
	for i := 0; i < len(list2); i++ {
		if list2[i].T_time == end.T_time {
			endIndex = i
		}
	}
	list3 := list2[endIndex:]
	for i := 0; i < len(list3); i++ {
		if list3[i].T_t >= end.T_t+0.2 {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list3[i].T_time})
			return
		}
	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 运行确认及偏差处理（满载）开始时间过后出现第二个循环温度再次上升0.2℃的拐点时间点  数据!"})
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)

}
func (c *TaskDataController) A空载温度偏差均匀度波动度分析时间区间() {

	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")

	时间1 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）开始时间") //  v26nplogbwt1
	if len(时间1) == 0 || 时间1 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）开始时间 失败!"})
		return
	}
	时间2 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）结束时间") //  v26nplogbwt1
	if len(时间2) == 0 || 时间2 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1 + "|" + 时间2})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A满载温度偏差均匀度波动度分析时间区间() {

	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")

	时间1 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）开始时间") //  v26nplogbwt1
	if len(时间1) == 0 || 时间1 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）开始时间 失败!"})
		return
	}
	时间2 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）结束时间") //  v26nplogbwt1
	if len(时间2) == 0 || 时间2 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1 + "|" + 时间2})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A温控设备运行参数及使用状况测试空载结束时间() {

	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")

	时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）结束时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A温控设备运行参数及使用状况测试满载结束时间() {

	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")

	时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）结束时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A温控设备运行参数及使用状况测试空载开始时间() {

	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")

	时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A温控设备运行参数及使用状况测试满载开始时间() {

	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")

	时间 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A温度分布特性的测试与分析空载结束时间() {

	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")

	时间1 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）结束时间") //  v26nplogbwt1
	时间2 := c.GetString("温度自动监测设备放置位置结束时间")

	if len(时间1) == 0 || 时间1 == "null" {
		if len(时间2) == 0 || 时间2 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）结束时间 或 温度自动监测设备放置位置结束时间 失败!"})
			return
		} else {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间2})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A温度分布特性的测试与分析满载结束时间() {

	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")

	时间1 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）结束时间") //  v26nplogbwt1
	时间2 := c.GetString("温度自动监测设备放置位置结束时间")

	if len(时间1) == 0 || 时间1 == "null" {
		if len(时间2) == 0 || 时间2 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）结束时间 或 温度自动监测设备放置位置结束时间 失败!"})
			return
		} else {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间2})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A温度分布特性的测试与分析空载开始时间() {

	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")

	时间1 := c.GetString("监测系统配置的测点终端参数及安装位置确认（空载）开始时间") //  v26nplogbwt1
	时间2 := c.GetString("温度自动监测设备放置位置开始时间")

	if len(时间1) == 0 || 时间1 == "null" {
		if len(时间2) == 0 || 时间2 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（空载）开始时间 或 温度自动监测设备放置位置开始时间 失败!"})
			return
		} else {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间2})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A温度分布特性的测试与分析满载开始时间() {

	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")

	时间1 := c.GetString("监测系统配置的测点终端参数及安装位置确认（满载）开始时间") //  v26nplogbwt1
	时间2 := c.GetString("温度自动监测设备放置位置开始时间")

	if len(时间1) == 0 || 时间1 == "null" {
		if len(时间2) == 0 || 时间2 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测系统配置的测点终端参数及安装位置确认（满载）开始时间 或 温度自动监测设备放置位置开始时间 失败!"})
			return
		} else {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间2})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A最长保温时限结束时间() {

	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")

	时间 := c.GetString("温度自动监测设备放置位置结束时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A最长保温时限开始时间() {

	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")

	时间 := c.GetString("温度自动监测设备放置位置开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A温度分布特性结束时间() {

	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")

	时间 := c.GetString("温度自动监测设备放置位置结束时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A温度分布特性开始时间() {

	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")

	时间 := c.GetString("温度自动监测设备放置位置开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 箱内所有测点|温度自动监测设备放置位置开始时间
// 1}取 平均值 ，高于等于 [温度控制范围最高值] 并持续5分钟，取 第一个超标时的时间值
// 2}[温湿度系统测点] 取最后时间点
func (c *TaskDataController) A温度自动监测设备放置位置结束时间() {

	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")

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

	箱内所有测点 := c.GetString("箱内所有测点") //  v26nplogbwt1
	if len(箱内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 箱内所有测点 失败!"})
		return
	}
	温度自动监测设备放置位置开始时间 := c.GetString("温度自动监测设备放置位置开始时间") //  v26nplogbwt1
	if len(温度自动监测设备放置位置开始时间) == 0 || 温度自动监测设备放置位置开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置开始时间 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 箱内所有测点, 温度自动监测设备放置位置开始时间, "")
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 箱内所有测点|温度自动监测设备放置位置开始时间 数据!"})
		return
	}

	for i := 0; i < (len(list) - 7); i++ {
		if list[i].T_t >= 温度控制范围最高值 {
			if list[i].T_t <= list[i+1].T_t &&
				list[i+1].T_t <= list[i+2].T_t &&
				list[i+2].T_t <= list[i+3].T_t &&
				list[i+3].T_t <= list[i+4].T_t &&
				list[i+4].T_t <= list[i+5].T_t &&
				list[i+5].T_t <= list[i+6].T_t {
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list[i].T_time})
				return
			}
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 高于等于 [温度控制范围最高值] 并持续5分钟 数据!"})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 温湿度系统测点 第一条数据时间
func (c *TaskDataController) A温度自动监测设备放置位置开始时间() {

	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")

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

	监测终端01 := c.GetString("监测终端01") //  v26nplogbwt1
	if len(监测终端01) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测终端01 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 监测终端01, "", "", "", 0, 1)
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温湿度系统测点 数据!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list[0].T_time})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A保温箱准备开始时间() {

	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")

	时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 箱内所有测点|现场测试开始时间|温度自动监测设备放置位置开始时间
// 温度低于（温度控制范围最高值 - 0.5），= 低于温度当前时的时间点
func (c *TaskDataController) A冰排预冷保温箱准备结束时间() {

	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")

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

	箱内所有测点 := c.GetString("箱内所有测点") //  v26nplogbwt1
	if len(箱内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 箱内所有测点 失败!"})
		return
	}
	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	//温度自动监测设备放置位置开始时间 := c.GetString("温度自动监测设备放置位置开始时间") //  v26nplogbwt1
	//if len(温度自动监测设备放置位置开始时间) == 0 {
	//	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置开始时间 失败!"})
	//	return
	//}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_) - 0.5
	list, _ := Task.Read_TaskData_ById_List_SQL(Task_r.T_task_id, " AND t_t  <= "+lib.To_string(温度控制范围最高值)+" ", 箱内所有测点, "", 现场测试开始时间, "", 0, 1)
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温度低于（温度控制范围最高值 - 0.5） !"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list[0].T_time})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 保温箱温度设定值 = （温度控制范围最高值 - 温度范围最低值）/ 2
func (c *TaskDataController) A保温箱温度设定值() {

	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")

	温度控制范围最高值 := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度范围最低值 := c.GetString("温度控制范围最小值") //  v26nplogbwt1
	if len(温度范围最低值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最小值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: lib.To_string((lib.To_float32(温度控制范围最高值) + lib.To_float32(温度范围最低值)) / 2)})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 风机温度设定值=（制冷机组温控设定最低值+制冷机组温控设定最高值）/2
func (c *TaskDataController) A风机温度设定值() {

	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")

	制冷机组温控设定最低值 := c.GetString("制冷机组温控设定最低值") //  v26nplogbwt1
	if len(制冷机组温控设定最低值) != 0 || 制冷机组温控设定最低值 != "null" {
		if !strings.Contains(制冷机组温控设定最低值, "档") {
			制冷机组温控设定最高值 := c.GetString("制冷机组温控设定最高值") //  v26nplogbwt1
			if len(制冷机组温控设定最高值) == 0 {
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 制冷机组温控设定最高值 失败!"})
				return
			}
			制冷机组温控设定最低值_, _ := lib.StringToFloat32(制冷机组温控设定最低值)
			制冷机组温控设定最高值_, _ := lib.StringToFloat32(制冷机组温控设定最高值)

			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: lib.To_string((制冷机组温控设定最低值_ + 制冷机组温控设定最高值_) / 2)})
			return

		}
	}
	温度控制范围最高值 := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}

	温度控制范围最小值 := c.GetString("温度控制范围最小值") //  v26nplogbwt1
	if len(温度控制范围最小值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最小值 失败!"})
		return
	}
	T := (lib.To_float32(温度控制范围最高值) + lib.To_float32(温度控制范围最小值)) / 2
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: lib.To_string(lib.RoundToDecimal(float64(T), 1))})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A动态第三次开箱注释() {

	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")

	时间 := c.GetString("动态三次开箱开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A动态第二次开箱注释() {

	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")

	时间 := c.GetString("动态二次开箱开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A动态第一次开箱注释() {

	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")

	时间 := c.GetString("动态第一次开箱开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A静态第三次开箱注释() {

	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")

	时间 := c.GetString("静态三次开箱开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A静态第二次开箱注释() {

	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")

	时间 := c.GetString("静态二次开箱开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A静态第一次开箱注释() {

	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")

	时间 := c.GetString("静态第一次开箱开始时间") //  v26nplogbwt1
	if len(时间) == 0 || 时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间 + "/" + 时间})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A第三次开箱注释() {

	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")

	时间1 := c.GetString("静态第三次开箱开始时间")
	时间2 := c.GetString("动态第三次开箱开始时间")
	if len(时间1) == 0 || 时间1 == "null" {
		if len(时间2) == 0 || 时间2 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 静/动态第三次开箱开始时间 失败!"})
			return
		} else {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间2 + "/" + 时间2})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1 + "/" + 时间1})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A第二次开箱注释() {

	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")

	时间1 := c.GetString("静态第二次开箱开始时间")
	时间2 := c.GetString("动态第二次开箱开始时间")
	if len(时间1) == 0 || 时间1 == "null" {
		if len(时间2) == 0 || 时间2 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 静/动态第二次开箱开始时间 失败!"})
			return
		} else {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间2 + "/" + 时间2})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1 + "/" + 时间1})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

func (c *TaskDataController) A第一次开箱注释() {

	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")

	时间1 := c.GetString("静态第一次开箱开始时间") //  v26nplogbwt1
	时间2 := c.GetString("动态第一次开箱开始时间") //  v26nplogbwt1
	if len(时间1) == 0 || 时间1 == "null" {
		if len(时间2) == 0 || 时间2 == "null" {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 静/动态第一次开箱开始时间 失败!"})
			return
		} else {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间2 + "/" + 时间2})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 时间1 + "/" + 时间1})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 冰排释冷监测设备|冰排释冷开始时间  当前 温度数据
func (c *TaskDataController) A冰排释冷分割线最低温() {

	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")

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

	冰排释冷监测设备 := c.GetString("冰排释冷监测设备") //  v26nplogbwt1
	if len(冰排释冷监测设备) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷监测设备 失败!"})
		return
	}

	冰排释冷开始时间 := c.GetString("冰排释冷开始时间") //  v26nplogbwt1
	if len(冰排释冷开始时间) == 0 || 冰排释冷开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷开始时间 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 冰排释冷监测设备, "", 冰排释冷开始时间, 冰排释冷开始时间, 0, 1)
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷监测设备|冰排释冷开始时间  当前 温度数据 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(list[0].T_t*10))/10)})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 冰排释冷监测设备|冰排释冷结束时间  当前 温度数据
func (c *TaskDataController) A冰排释冷分割线最高温() {

	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")

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

	冰排释冷监测设备 := c.GetString("冰排释冷监测设备") //  v26nplogbwt1
	if len(冰排释冷监测设备) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷监测设备 失败!"})
		return
	}

	冰排释冷结束时间 := c.GetString("冰排释冷结束时间") //  v26nplogbwt1
	if len(冰排释冷结束时间) == 0 || 冰排释冷结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷结束时间 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 冰排释冷监测设备, "", 冰排释冷结束时间, 冰排释冷结束时间, 0, 1)
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷监测设备|冰排释冷结束时间  当前 温度数据 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(list[0].T_t*10))/10)})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 冰排释冷监测设备|现场测试开始时间|温度自动监测设备放置位置开始时间
// [冰排释冷开始时间] 时间后 ，超过 [温度范围最低值 ]度,第一条超标数据点时间
func (c *TaskDataController) A冰排释冷结束时间() {

	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")

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

	冰排释冷监测设备 := c.GetString("冰排释冷监测设备") //  v26nplogbwt1
	if len(冰排释冷监测设备) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷监测设备 失败!"})
		return
	}
	温度范围最低值 := c.GetString("温度范围最低值") //  v26nplogbwt1
	if len(温度范围最低值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度范围最低值 失败!"})
		return
	}
	冰排释冷开始时间 := c.GetString("冰排释冷开始时间") //  v26nplogbwt1
	if len(冰排释冷开始时间) == 0 || 冰排释冷开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷开始时间 失败!"})
		return
	}
	温度自动监测设备放置位置开始时间 := c.GetString("温度自动监测设备放置位置开始时间") //  v26nplogbwt1
	if len(温度自动监测设备放置位置开始时间) == 0 || 温度自动监测设备放置位置开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置开始时间 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 冰排释冷监测设备, "", 冰排释冷开始时间, 温度自动监测设备放置位置开始时间, 0, 9999)
	for _, v := range list {
		if v.T_t >= lib.To_float32(温度范围最低值) {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: v.T_time})
			return
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 [冰排释冷开始时间] 时间后 ，超过 [温度范围最低值]度,第一条超标数据点时间 失败!"})
	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}

// 冰排释冷监测设备|现场测试开始时间|温度自动监测设备放置位置开始时间
// V型数据，下降持续5分钟，持续上升 5 分钟，取上升点的第一条数据
// 40 2025-02-27 12:08  2025-02-27 14:40
func (c *TaskDataController) A冰排释冷开始时间() {

	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")

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

	冰排释冷监测设备 := c.GetString("冰排释冷监测设备") //  v26nplogbwt1
	if len(冰排释冷监测设备) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冰排释冷监测设备 失败!"})
		return
	}
	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	温度自动监测设备放置位置开始时间 := c.GetString("温度自动监测设备放置位置开始时间") //  v26nplogbwt1
	if len(温度自动监测设备放置位置开始时间) == 0 || 温度自动监测设备放置位置开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度自动监测设备放置位置开始时间 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 冰排释冷监测设备, "", 现场测试开始时间, 温度自动监测设备放置位置开始时间, 0, 9999)
	list_id, found := Task.FindVTrend(list)
	if !found {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 V型趋势 失败!,下降持续5分钟，上升持续5分钟"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list[list_id].T_time})

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

// 保温箱外环境测点|温度自动监测设备放置位置开始时间|温度自动监测设备放置位置结束时间
// 061 2025-02-27 14:40 2025-02-28 21:46
func (c *TaskDataController) A外部环境分割线最高温() {

	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")

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

	保温箱外环境测点 := c.GetString("保温箱外环境测点") //  v26nplogbwt1
	if len(保温箱外环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 保温箱外环境测点 失败!"})
		return
	}
	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	_, maxT := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 保温箱外环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", RoundToDecimal(maxT+0.5, 1))})

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

// 保温箱外环境测点|温度自动监测设备放置位置开始时间|温度自动监测设备放置位置结束时间
func (c *TaskDataController) A外部环境分割线最低温() {

	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")

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

	保温箱外环境测点 := c.GetString("保温箱外环境测点") //  v26nplogbwt1
	if len(保温箱外环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 保温箱外环境测点 失败!"})
		return
	}
	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	minT, _ := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 保温箱外环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", RoundToDecimal(minT-0.5, 1))})

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

// 保温箱外环境测点|温度自动监测设备放置位置开始时间|温度自动监测设备放置位置结束时间
// 061 2025-02-27 14:40 2025-02-28 21:46
func (c *TaskDataController) A冷藏柜外部环境测点最高温() {

	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")

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

	保温箱外环境测点 := c.GetString("冷藏柜外部环境测点") //  v26nplogbwt1
	if len(保温箱外环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏柜外部环境测点 失败!"})
		return
	}
	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	_, maxT := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 保温箱外环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(maxT*10))/10+0.5)})

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

// 保温箱外环境测点|温度自动监测设备放置位置开始时间|温度自动监测设备放置位置结束时间
func (c *TaskDataController) A冷藏柜外部环境测点最低温() {

	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")

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

	保温箱外环境测点 := c.GetString("冷藏柜外部环境测点") //  v26nplogbwt1
	if len(保温箱外环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏柜外部环境测点 失败!"})
		return
	}
	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	minT, _ := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 保温箱外环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(minT*10))/10-0.5)})

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

func (c *TaskDataController) A内部环境分割线最低温() {

	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")

	温度范围最低值 := c.GetString("温度控制范围最小值") //  v26nplogbwt1
	if len(温度范围最低值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最小值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 温度范围最低值})

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

func (c *TaskDataController) A内部环境分割线最高温() {

	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")

	温度控制范围最高值 := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 温度控制范围最高值})

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

func (c *TaskDataController) A满载第一次关门温度恢复时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点")
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("均匀性布点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("产品存放区域测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点/均匀性布点/产品存放区域测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	第一次开门结束时间 := c.GetString("第一次开门结束时间") //  v26nplogbwt1
	if len(第一次开门结束时间) == 0 || 第一次开门结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第一次开门结束时间 失败!"})
		return
	}
	第一次开门结束时间_a, err := time.Parse("2006-01-02 15:04", 第一次开门结束时间)
	第一次开门结束时间_b := 第一次开门结束时间_a

	for x := 0; x < 60; x++ {
		第一次开门结束时间_b = 第一次开门结束时间_a.Add(time.Minute * 60)

		maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第一次开门结束时间_a.Format("2006-01-02 15:04"), 第一次开门结束时间_b.Format("2006-01-02 15:04"))

		//  判断拐点
		if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
			maps_Time_Min_Max_GROUP[1].T_max >= maps_Time_Min_Max_GROUP[2].T_max {

			if maps_Time_Min_Max_GROUP[1].T_max > 温度控制范围最高值 {
				// 情况1：开门有超标的情况：
				// 柜内所有测点中任意一条数据出现超温度控制范围最高值后所有验证工具下降至温度控制范围最高值减0.5℃此时的时间
				for _, group := range maps_Time_Min_Max_GROUP {
					if group.T_max < 温度控制范围最高值-0.5 {
						lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: group.T_times})
						return
					}
				}
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 下降至温度控制范围最高值减0.5℃此时的时间 !"})
				return
			} else {
				// 情况2：开门无超标的情况：
				// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
				list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第一次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))

				for i := 0; i < len(list)-6; i++ {
					if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
						maps_Time_Min_Max_GROUP[i+1].T_max >= maps_Time_Min_Max_GROUP[i+2].T_max &&
						maps_Time_Min_Max_GROUP[i+2].T_max >= maps_Time_Min_Max_GROUP[i+3].T_max &&
						maps_Time_Min_Max_GROUP[i+3].T_max >= maps_Time_Min_Max_GROUP[i+4].T_max &&
						maps_Time_Min_Max_GROUP[i+4].T_max >= maps_Time_Min_Max_GROUP[i+5].T_max {

						lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: maps_Time_Min_Max_GROUP[i].T_times})
						return

					}
				}
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温度持续下降连续5分钟 !"})
				return
			}

		}

		第一次开门结束时间_a = 第一次开门结束时间_a.Add(time.Minute * 1)
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到数据拐点 !"})

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

func (c *TaskDataController) A空载第一次关门温度恢复时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点")
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("均匀性布点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("产品存放区域测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点/均匀性布点/产品存放区域测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	第一次开门结束时间 := c.GetString("第一次开门结束时间") //  v26nplogbwt1
	if len(第一次开门结束时间) == 0 || 第一次开门结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第一次开门结束时间 失败!"})
		return
	}
	第一次开门结束时间_a, err := time.Parse("2006-01-02 15:04", 第一次开门结束时间)
	第一次开门结束时间_b := 第一次开门结束时间_a

	for x := 0; x < 60; x++ {
		第一次开门结束时间_b = 第一次开门结束时间_a.Add(time.Minute * 20)

		maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第一次开门结束时间_a.Format("2006-01-02 15:04"), 第一次开门结束时间_b.Format("2006-01-02 15:04"))

		//  判断拐点
		if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
			maps_Time_Min_Max_GROUP[1].T_max >= maps_Time_Min_Max_GROUP[2].T_max {

			if maps_Time_Min_Max_GROUP[1].T_max > 温度控制范围最高值 {
				// 情况1：开门有超标的情况：
				// 柜内所有测点中任意一条数据出现超温度控制范围最高值后所有验证工具下降至温度控制范围最高值减0.5℃此时的时间
				for _, group := range maps_Time_Min_Max_GROUP {
					if group.T_max <= 温度控制范围最高值-0.5 {
						lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: group.T_times})
						return
					}
				}
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 下降至温度控制范围最高值减0.5℃此时的时间 !"})
				return
			} else {
				// 情况2：开门无超标的情况：
				// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
				list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第一次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))

				for i := 0; i < len(list)-6; i++ {
					if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
						maps_Time_Min_Max_GROUP[i+1].T_max >= maps_Time_Min_Max_GROUP[i+2].T_max &&
						maps_Time_Min_Max_GROUP[i+2].T_max >= maps_Time_Min_Max_GROUP[i+3].T_max &&
						maps_Time_Min_Max_GROUP[i+3].T_max >= maps_Time_Min_Max_GROUP[i+4].T_max &&
						maps_Time_Min_Max_GROUP[i+4].T_max >= maps_Time_Min_Max_GROUP[i+5].T_max {

						lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: maps_Time_Min_Max_GROUP[i].T_times})
						return

					}
				}
				lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温度持续下降连续5分钟 !"})
				return
			}

		}

		第一次开门结束时间_a = 第一次开门结束时间_a.Add(time.Minute * 1)
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到数据拐点 !"})

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

func (c *TaskDataController) A满载第二次关门温度恢复时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点")
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("均匀性布点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("产品存放区域测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点/均匀性布点/产品存放区域测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	第二次开门结束时间 := c.GetString("第二次开门结束时间") //  v26nplogbwt1
	if len(第二次开门结束时间) == 0 || 第二次开门结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第二次开门结束时间 失败!"})
		return
	}
	第三次开门开始时间 := c.GetString("第三次开门开始时间") //  v26nplogbwt1
	if len(第三次开门开始时间) == 0 || 第三次开门开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第三次开门开始时间 失败!"})
		return
	}
	第二次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第二次开门结束时间)
	第三次开门开始时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门开始时间)

	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第二次开门结束时间_a.Format("2006-01-02 15:04"), 第三次开门开始时间_a.Format("2006-01-02 15:04"))

	if maps_Time_Min_Max_GROUP == nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
		return
	}

	//  判断拐点
	if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
		maps_Time_Min_Max_GROUP[1].T_max >= maps_Time_Min_Max_GROUP[2].T_max {

		if maps_Time_Min_Max_GROUP[1].T_max > 温度控制范围最高值 {
			// 情况1：开门有超标的情况：
			// 柜内所有测点中任意一条数据出现超温度控制范围最高值后所有验证工具下降至温度控制范围最高值减0.5℃此时的时间
			for _, group := range maps_Time_Min_Max_GROUP {
				if group.T_max < 温度控制范围最高值 {
					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: group.T_times})
					return
				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 下降至温度控制范围最高值减0.5℃此时的时间 !"})
			return
		} else {
			// 情况2：开门无超标的情况：
			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第二次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))

			for i := 0; i < len(list)-6; i++ {
				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
					maps_Time_Min_Max_GROUP[i+1].T_max >= maps_Time_Min_Max_GROUP[i+2].T_max &&
					maps_Time_Min_Max_GROUP[i+2].T_max >= maps_Time_Min_Max_GROUP[i+3].T_max &&
					maps_Time_Min_Max_GROUP[i+3].T_max >= maps_Time_Min_Max_GROUP[i+4].T_max &&
					maps_Time_Min_Max_GROUP[i+4].T_max >= maps_Time_Min_Max_GROUP[i+5].T_max {

					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: maps_Time_Min_Max_GROUP[i].T_times})
					return

				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温度持续下降连续5分钟 !"})
			return
		}

	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到数据拐点 !"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A空载第二次关门温度恢复时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点")
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("均匀性布点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("产品存放区域测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点/均匀性布点/产品存放区域测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	第二次开门结束时间 := c.GetString("第二次开门结束时间") //  v26nplogbwt1
	if len(第二次开门结束时间) == 0 || 第二次开门结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第二次开门结束时间 失败!"})
		return
	}
	第三次开门开始时间 := c.GetString("第三次开门开始时间") //  v26nplogbwt1
	if len(第三次开门开始时间) == 0 || 第三次开门开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第三次开门开始时间 失败!"})
		return
	}
	第二次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第二次开门结束时间)
	第三次开门开始时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门开始时间)

	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第二次开门结束时间_a.Format("2006-01-02 15:04"), 第三次开门开始时间_a.Format("2006-01-02 15:04"))
	if maps_Time_Min_Max_GROUP == nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
		return
	}
	//  判断拐点
	if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
		maps_Time_Min_Max_GROUP[1].T_max >= maps_Time_Min_Max_GROUP[2].T_max {

		if maps_Time_Min_Max_GROUP[1].T_max > 温度控制范围最高值 {
			// 情况1：开门有超标的情况：
			// 柜内所有测点中任意一条数据出现超温度控制范围最高值后所有验证工具下降至温度控制范围最高值减0.5℃此时的时间
			for _, group := range maps_Time_Min_Max_GROUP {
				if group.T_max < 温度控制范围最高值 {
					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: group.T_times})
					return
				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 下降至温度控制范围最高值减0.5℃此时的时间 !"})
			return
		} else {
			// 情况2：开门无超标的情况：
			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第二次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))

			for i := 0; i < len(list)-6; i++ {
				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
					maps_Time_Min_Max_GROUP[i+1].T_max >= maps_Time_Min_Max_GROUP[i+2].T_max &&
					maps_Time_Min_Max_GROUP[i+2].T_max >= maps_Time_Min_Max_GROUP[i+3].T_max &&
					maps_Time_Min_Max_GROUP[i+3].T_max >= maps_Time_Min_Max_GROUP[i+4].T_max &&
					maps_Time_Min_Max_GROUP[i+4].T_max >= maps_Time_Min_Max_GROUP[i+5].T_max {

					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: maps_Time_Min_Max_GROUP[i].T_times})
					return

				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温度持续下降连续5分钟 !"})
			return
		}

	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到数据拐点 !"})

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

func (c *TaskDataController) A满载第三次关门温度恢复时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点")
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("均匀性布点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("产品存放区域测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点/均匀性布点/产品存放区域测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	第三次开门结束时间 := c.GetString("第三次开门结束时间") //  v26nplogbwt1
	if len(第三次开门结束时间) == 0 || 第三次开门结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第三次开门结束时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}
	第三次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门结束时间)
	现场测试结束时间_a, _ := time.Parse("2006-01-02 15:04", 现场测试结束时间)

	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第三次开门结束时间_a.Format("2006-01-02 15:04"), 现场测试结束时间_a.Format("2006-01-02 15:04"))
	if maps_Time_Min_Max_GROUP == nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
		return
	}
	//  判断拐点
	if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
		maps_Time_Min_Max_GROUP[1].T_max >= maps_Time_Min_Max_GROUP[2].T_max {

		if maps_Time_Min_Max_GROUP[1].T_max > 温度控制范围最高值 {
			// 情况1：开门有超标的情况：
			// 柜内所有测点中任意一条数据出现超温度控制范围最高值后所有验证工具下降至温度控制范围最高值减0.5℃此时的时间
			for _, group := range maps_Time_Min_Max_GROUP {
				if group.T_max < 温度控制范围最高值 {
					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: group.T_times})
					return
				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 下降至温度控制范围最高值减0.5℃此时的时间 !"})
			return
		} else {
			// 情况2：开门无超标的情况：
			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第三次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))

			for i := 0; i < len(list)-6; i++ {
				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
					maps_Time_Min_Max_GROUP[i+1].T_max >= maps_Time_Min_Max_GROUP[i+2].T_max &&
					maps_Time_Min_Max_GROUP[i+2].T_max >= maps_Time_Min_Max_GROUP[i+3].T_max &&
					maps_Time_Min_Max_GROUP[i+3].T_max >= maps_Time_Min_Max_GROUP[i+4].T_max &&
					maps_Time_Min_Max_GROUP[i+4].T_max >= maps_Time_Min_Max_GROUP[i+5].T_max {

					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: maps_Time_Min_Max_GROUP[i].T_times})
					return

				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温度持续下降连续5分钟 !"})
			return
		}

	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到数据拐点 !"})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A空载第三次关门温度恢复时间() {

	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")

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

	柜内所有测点 := c.GetString("柜内所有测点")
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("均匀性布点")
	}
	if len(柜内所有测点) == 0 {
		柜内所有测点 = c.GetString("产品存放区域测点")
	}
	if len(柜内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点/均匀性布点/产品存放区域测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	第三次开门结束时间 := c.GetString("第三次开门结束时间") //  v26nplogbwt1
	if len(第三次开门结束时间) == 0 || 第三次开门结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第三次开门结束时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}
	第三次开门结束时间_a, _ := time.Parse("2006-01-02 15:04", 第三次开门结束时间)
	现场测试结束时间_a, _ := time.Parse("2006-01-02 15:04", 现场测试结束时间)

	maps_Time_Min_Max_GROUP := Task.Read_TaskData_T_Min_Max_Time_Min_Max_ListGROUP(Task_r.T_task_id, 柜内所有测点, 第三次开门结束时间_a.Format("2006-01-02 15:04"), 现场测试结束时间_a.Format("2006-01-02 15:04"))
	if maps_Time_Min_Max_GROUP == nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 柜内所有测点 最大最小值 数据 !"})
		return
	}
	//  判断拐点
	if maps_Time_Min_Max_GROUP[0].T_max <= maps_Time_Min_Max_GROUP[1].T_max &&
		maps_Time_Min_Max_GROUP[1].T_max >= maps_Time_Min_Max_GROUP[2].T_max {

		if maps_Time_Min_Max_GROUP[1].T_max > 温度控制范围最高值 {
			// 情况1：开门有超标的情况：
			// 柜内所有测点中任意一条数据出现超温度控制范围最高值后所有验证工具下降至温度控制范围最高值减0.5℃此时的时间
			for _, group := range maps_Time_Min_Max_GROUP {
				if group.T_max < 温度控制范围最高值 {
					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: group.T_times})
					return
				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 下降至温度控制范围最高值减0.5℃此时的时间 !"})
			return
		} else {
			// 情况2：开门无超标的情况：
			// 柜内所有测点中温度持续下降连续5分钟内，取第一条时间作为此时间点
			list := Task.Read_TaskData_ById_AVG(Task_r.T_task_id, 柜内所有测点, maps_Time_Min_Max_GROUP[1].T_times, 第三次开门结束时间_a.Add(time.Minute*30).Format("2006-01-02 15:04"))

			for i := 0; i < len(list)-6; i++ {
				if maps_Time_Min_Max_GROUP[i].T_max <= maps_Time_Min_Max_GROUP[i+1].T_max &&
					maps_Time_Min_Max_GROUP[i+1].T_max >= maps_Time_Min_Max_GROUP[i+2].T_max &&
					maps_Time_Min_Max_GROUP[i+2].T_max >= maps_Time_Min_Max_GROUP[i+3].T_max &&
					maps_Time_Min_Max_GROUP[i+3].T_max >= maps_Time_Min_Max_GROUP[i+4].T_max &&
					maps_Time_Min_Max_GROUP[i+4].T_max >= maps_Time_Min_Max_GROUP[i+5].T_max {

					lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: maps_Time_Min_Max_GROUP[i].T_times})
					return

				}
			}
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到 温度持续下降连续5分钟 !"})
			return
		}

	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没找到数据拐点 !"})

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

func (c *TaskDataController) A满载开门最长需要多少分钟恢复() {

	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")

	恢复时间_ := c.GetString("满载第一次关门温度恢复时间") //  v26nplogbwt1
	恢复时间, err := time.Parse("2006-01-02 15:04", 恢复时间_)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 满载第一次关门温度恢复时间 失败!"})
		return
	}

	结束时间_ := c.GetString("第一次开门结束时间") //  v26nplogbwt1
	结束时间, err := time.Parse("2006-01-02 15:04", 结束时间_)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第一次开门结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: lib.To_string((恢复时间.Unix() - 结束时间.Unix()) / 60)})

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

func (c *TaskDataController) A空载开门最长需要多少分钟恢复() {

	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")

	恢复时间_ := c.GetString("空载第一次关门温度恢复时间") //  v26nplogbwt1
	恢复时间, err := time.Parse("2006-01-02 15:04", 恢复时间_)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 空载第一次关门温度恢复时间 失败!"})
		return
	}

	结束时间_ := c.GetString("第一次开门结束时间") //  v26nplogbwt1
	结束时间, err := time.Parse("2006-01-02 15:04", 结束时间_)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 第一次开门结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: lib.To_string((恢复时间.Unix() - 结束时间.Unix()) / 60)})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A冷藏库作业口外部环境分割线最低温() {

	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")

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

	冷藏库作业口外部环境测点 := c.GetString("冷藏库作业口外部环境测点") //  v26nplogbwt1
	if len(冷藏库作业口外部环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏库作业口外部环境测点 失败!"})
		return
	}

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	minT, _ := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 冷藏库作业口外部环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(minT*10))/10-0.5)})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A冷藏库作业口外部环境分割线最高温() {

	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")

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

	冷藏库作业口外部环境测点 := c.GetString("冷藏库作业口外部环境测点") //  v26nplogbwt1
	if len(冷藏库作业口外部环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏库作业口外部环境测点 失败!"})
		return
	}

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	_, maxT := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 冷藏库作业口外部环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(maxT*10))/10+0.5)})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A冷藏库外部环境测点最高温() {

	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")

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

	冷藏库外部环境测点 := c.GetString("冷藏库外部环境测点") //  v26nplogbwt1
	if len(冷藏库外部环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏库外部环境测点 失败!"})
		return
	}

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	_, maxT := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 冷藏库外部环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(maxT*10))/10)})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A冷藏库外部环境测点最低温() {

	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")

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

	冷藏库外部环境测点 := c.GetString("冷藏库外部环境测点") //  v26nplogbwt1
	if len(冷藏库外部环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏库外部环境测点 失败!"})
		return
	}

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	minT, _ := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 冷藏库外部环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(minT*10))/10)})

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

func (c *TaskDataController) A冷藏库内部最低温() {

	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")

	温度控制范围最小值 := c.GetString("温度控制范围最小值") //  v26nplogbwt1
	if len(温度控制范围最小值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最小值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 温度控制范围最小值})

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

func (c *TaskDataController) A冷藏库内部最高温() {

	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")

	温度控制范围最高值 := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 温度控制范围最高值})

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

func (c *TaskDataController) A冷藏车外部环境测点最高温() {

	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")

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

	冷藏车外部环境测点 := c.GetString("冷藏车外部环境测点") //  v26nplogbwt1
	if len(冷藏车外部环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏车外部环境测点 失败!"})
		return
	}

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	_, maxT := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 冷藏车外部环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(maxT*10))/10)})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A冷藏车外部环境测点最低温() {

	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")

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

	冷藏车外部环境测点 := c.GetString("冷藏车外部环境测点") //  v26nplogbwt1
	if len(冷藏车外部环境测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 冷藏车外部环境测点 失败!"})
		return
	}

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	minT, _ := Task.Read_TaskData_T_Min_Max(Task_r.T_task_id, 冷藏车外部环境测点, "", 现场测试开始时间, 现场测试结束时间)

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: fmt.Sprintf("%.1f", math.Ceil(float64(minT*10))/10)})

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

func (c *TaskDataController) A冷藏车内部最低温() {

	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")

	温度控制范围最小值 := c.GetString("温度控制范围最小值") //  v26nplogbwt1
	if len(温度控制范围最小值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最小值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 温度控制范围最小值})

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

func (c *TaskDataController) A冷藏车内部最高温() {

	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")

	温度控制范围最高值 := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 温度控制范围最高值})

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

func (c *TaskDataController) A验证测试期间当地天气情况曲线图() {

	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")

	验证测试期间当地天气情况图 := c.GetString("验证测试期间当地天气情况图") //  v26nplogbwt1
	if len(验证测试期间当地天气情况图) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 验证测试期间当地天气情况图 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: strings.Replace(验证测试期间当地天气情况图, "1.png", "2.png", 1)})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A当地历史气温数据查询曲线图() {

	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")

	验证测试期间当地天气情况图 := c.GetString("验证测试期间当地天气情况图") //  v26nplogbwt1
	if len(验证测试期间当地天气情况图) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 验证测试期间当地天气情况图 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: strings.Replace(验证测试期间当地天气情况图, "1.png", "3.png", 1)})

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

func (c *TaskDataController) A报告编号() {

	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")

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

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

func (c *TaskDataController) A数据分析时间() {

	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")

	报告日期 := c.GetString("报告日期") //  v26nplogbwt1
	if len(报告日期) == 0 || 报告日期 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 报告日期 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 报告日期})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A实施计划月份() {

	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")

	现场测试开始时间_ := c.GetString("现场测试开始时间") //  v26nplogbwt1
	现场测试开始时间, err := time.Parse("2006-01-02 15:04", 现场测试开始时间_)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 现场测试开始时间.Format("2006年01月")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A计划验证实施时间() {

	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")

	现场测试开始时间_ := c.GetString("现场测试开始时间") //  v26nplogbwt1
	现场测试开始时间, err := time.Parse("2006-01-02 15:04", 现场测试开始时间_)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 现场测试开始时间.Format("2006年01月")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A监测终端01() {

	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")

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

	监测终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "监测终端01")
	if len(监测终端_list) > 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 监测终端_list[0].T_sn})

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

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 监测终端01 !"})
	return

}
func (c *TaskDataController) A监测终端安装编号01() {

	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")

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

	监测终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "监测终端01")
	if len(监测终端_list) > 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 监测终端_list[0].T_id})

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

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 监测终端01 终端!"})
	return
}
func (c *TaskDataController) A监测终端02() {

	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")

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

	监测终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "监测终端02")
	if len(监测终端_list) > 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 监测终端_list[0].T_sn})

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

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 监测终端02 终端!"})
	return

}
func (c *TaskDataController) A监测终端安装编号02() {

	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")

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

	监测终端_list := Device.Read_DeviceClassList_List_id_T_remark(Task_r.T_class, "监测终端02")
	if len(监测终端_list) > 1 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 监测终端_list[0].T_id})

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

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 监测终端02 终端!"})
	return
}

func (c *TaskDataController) A监测系统配置的测点终端参数及安装位置确认满载开始时间() {

	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")

	运行确认及偏差处理满载结束时间 := c.GetString("运行确认及偏差处理（满载）结束时间") //  v26nplogbwt1
	if len(运行确认及偏差处理满载结束时间) == 0 || 运行确认及偏差处理满载结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 运行确认及偏差处理（满载）结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 运行确认及偏差处理满载结束时间})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A监测系统配置的测点终端参数及安装位置确认满载结束时间() {

	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")

	开满开 := c.GetString("开满开")
	if len(开满开) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 开满开 失败!"})
		return
	}

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

	监测终端01 := c.GetString("监测终端01") //  v26nplogbwt1
	if len(监测终端01) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测终端01 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 监测终端01, "", "", 开满开, 0, 9999)

	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 终端数据 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list[len(list)-1].T_time})

	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A监测系统配置的测点终端参数及安装位置确认空载开始时间() {

	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")

	运行确认及偏差处理空载结束时间 := c.GetString("运行确认及偏差处理（空载）结束时间") //  v26nplogbwt1
	if len(运行确认及偏差处理空载结束时间) == 0 || 运行确认及偏差处理空载结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 运行确认及偏差处理（空载）结束时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 运行确认及偏差处理空载结束时间})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A监测系统配置的测点终端参数及安装位置确认空载结束时间() {

	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")

	开空开 := c.GetString("开空开")
	if len(开空开) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 开空开 失败!"})
		return
	}

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

	监测终端01 := c.GetString("监测终端01") //  v26nplogbwt1
	if len(监测终端01) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 监测终端01 失败!"})
		return
	}
	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 监测终端01, "", "", 开空开, 0, 9999)

	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 终端数据 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: list[len(list)-1].T_time})

	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A培训讲师() {

	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")

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

	// 数据采集工程师
	user, err := NatsServer.Read_Admin(Task_r.T_collection)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取数据采集工程师信息失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: user.T_name})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A培训时间() {

	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")

	现场测试开始时间_ := c.GetString("现场测试开始时间") //  v26nplogbwt1
	现场测试开始时间, err := time.Parse("2006-01-02 15:04", 现场测试开始时间_)
	if err != nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 现场测试开始时间.Format("2006年01月")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A作业出入口总测点() {

	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")

	一号作业出入口测点 := c.GetString("1号作业出入口测点") //  v26nplogbwt1
	二号作业出入口测点 := c.GetString("2号作业出入口测点") //  v26nplogbwt1

	parts := strings.Split(strings.Trim(一号作业出入口测点, "|")+"|"+strings.Trim(二号作业出入口测点, "|"), "|")

	uniqueMap := make(map[string]struct{})
	var result []string

	for _, part := range parts {
		if _, exists := uniqueMap[part]; !exists {
			uniqueMap[part] = struct{}{}
			result = append(result, part)
		}
	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: strings.Join(result, "|")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A风机布点总测点() {

	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")

	一号风机测点 := c.GetString("1号风机测点")   //  v26nplogbwt1
	二号风机测点 := c.GetString("2号风机测点")   //  v26nplogbwt1
	一号风机回风口 := c.GetString("1号风机回风口") //  v26nplogbwt1
	二号风机回风口 := c.GetString("2号风机回风口") //  v26nplogbwt1

	parts := strings.Split(strings.Trim(一号风机回风口, "|")+"|"+strings.Trim(一号风机测点, "|")+"|"+strings.Trim(二号风机回风口, "|")+"|"+strings.Trim(二号风机测点, "|"), "|")

	uniqueMap := make(map[string]struct{})
	var result []string

	for _, part := range parts {
		if _, exists := uniqueMap[part]; !exists {
			uniqueMap[part] = struct{}{}
			result = append(result, part)
		}
	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: strings.Join(result, "|")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A库内除风机出风口回风口外总测点() {

	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")

	库内所有测点 := c.GetString("库内所有测点")   //  v26nplogbwt1
	风机布点总测点 := c.GetString("风机布点总测点") //  v26nplogbwt1

	parts1 := strings.Split(库内所有测点, "|")
	parts2 := strings.Split(风机布点总测点, "|")

	excludeMap := make(map[string]struct{})
	for _, part := range parts2 {
		excludeMap[part] = struct{}{}
	}

	var result []string
	for _, part := range parts1 {
		if _, exists := excludeMap[part]; !exists {
			result = append(result, part)
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: strings.Join(result, "|")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A库内除风机出风口回风口特殊位置布点作业口外总测点() {

	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")

	库内所有测点 := c.GetString("库内所有测点")                       //  v26nplogbwt1
	风机布点总测点 := c.GetString("风机布点总测点")                     //  v26nplogbwt1
	作业出入口总测点 := c.GetString("作业出入口总测点")                   //  v26nplogbwt1
	照明灯除湿机风幕机等特殊区域测点 := c.GetString("照明灯、除湿机、风幕机等特殊区域测点") //  v26nplogbwt1

	parts1 := strings.Split(strings.Trim(库内所有测点, "|"), "|")
	parts2 := strings.Split(strings.Trim(风机布点总测点, "|"), "|")
	parts3 := strings.Split(strings.Trim(作业出入口总测点, "|"), "|")
	parts4 := strings.Split(strings.Trim(照明灯除湿机风幕机等特殊区域测点, "|"), "|")

	excludeMap := make(map[string]struct{})
	for _, part := range parts2 {
		excludeMap[part] = struct{}{}
	}
	for _, part := range parts3 {
		excludeMap[part] = struct{}{}
	}
	for _, part := range parts4 {
		excludeMap[part] = struct{}{}
	}

	var result []string
	for _, part := range parts1 {
		if _, exists := excludeMap[part]; !exists {
			result = append(result, part)
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: strings.Join(result, "|")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A车内除风机出风口回风口外总测点() {

	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")

	车内所有测点 := c.GetString("车内所有测点")   //  v26nplogbwt1
	风机布点总测点 := c.GetString("风机布点总测点") //  v26nplogbwt1

	parts1 := strings.Split(车内所有测点, "|")
	parts2 := strings.Split(风机布点总测点, "|")

	excludeMap := make(map[string]struct{})
	for _, part := range parts2 {
		excludeMap[part] = struct{}{}
	}

	var result []string
	for _, part := range parts1 {
		if _, exists := excludeMap[part]; !exists {
			result = append(result, part)
		}
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: strings.Join(result, "|")})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A预冷开始时间() {

	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")

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 现场测试开始时间})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A预冷结束时间() {

	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")

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

	车内所有测点 := c.GetString("车内所有测点") //  v26nplogbwt1
	if len(车内所有测点) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 车内所有测点 失败!"})
		return
	}
	温度控制范围最高值_ := c.GetString("温度控制范围最高值") //  v26nplogbwt1
	if len(温度控制范围最高值_) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 温度控制范围最高值 失败!"})
		return
	}
	温度控制范围最高值 := lib.To_float32(温度控制范围最高值_)

	现场测试开始时间 := c.GetString("现场测试开始时间") //  v26nplogbwt1
	if len(现场测试开始时间) == 0 || 现场测试开始时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试开始时间 失败!"})
		return
	}
	现场测试结束时间 := c.GetString("现场测试结束时间") //  v26nplogbwt1
	if len(现场测试结束时间) == 0 || 现场测试结束时间 == "null" {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 现场测试结束时间 失败!"})
		return
	}

	list, _ := Task.Read_TaskData_ById_List_AES(Task_r.T_task_id, 车内所有测点, "", 现场测试开始时间, 现场测试结束时间, 0, 9999)
	if len(list) == 0 {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 柜内所有测点|现场测试开始时间-现场测试结束时间 当前 温度数据 失败!"})
		return
	}

	// 现场测试开开始时间温度高于温度控制范围最高值，取温度下降至“温度控制范围最高值”-0.1以下的最后一个终端时间

	groupMap := make(map[string][]Task.TaskData_)
	for _, r := range list {
		groupMap[r.T_id] = append(groupMap[r.T_id], r)
	}

	var latest *Task.TaskData_

	for _, group := range groupMap {
		candidate := Task.FindFirstDecreasingTendency(group, 温度控制范围最高值-0.1)
		if candidate != nil {
			if latest == nil || lib.ParseTime(candidate.T_time).After(lib.ParseTime(latest.T_time)) {
				latest = candidate
			}
		}
	}
	if latest == nil {
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "没有找到 温度下降至“温度控制范围最高值”以下 数据!"})
		return
	}

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: latest.T_time})

	// Close the connection
	c.Ctx.ResponseWriter.WriteHeader(http.StatusOK)
}
func (c *TaskDataController) A现场测试结束时间() {

	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")

	保空结 := c.GetString("保空结") //  v26nplogbwt1
	if len(保空结) == 0 {
		保满结 := c.GetString("保满结")
		if len(保满结) == 0 {
			lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 2, Msg: "获取 保空结|保满结 失败!"})
			return
		}
		lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 保满结})

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

	lib.SseWriteJSON(c.Ctx.ResponseWriter, lib.JSONSSE{State: 1, Msg: 保空结})

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