ColdVerify_server/controllers/Task.go

package controllers

import (
	"ColdVerify_server/Nats/NatsServer"
	"ColdVerify_server/conf"
	"ColdVerify_server/lib"
	"ColdVerify_server/lib/wx"
	"ColdVerify_server/logs"
	"ColdVerify_server/models/Account"
	"ColdVerify_server/models/Certificate"
	"ColdVerify_server/models/Device"
	"ColdVerify_server/models/InfoCollection"
	"ColdVerify_server/models/System"
	"ColdVerify_server/models/Task"
	"ColdVerify_server/models/VerifyTemplate"
	"archive/zip"
	"encoding/json"
	"errors"
	"fmt"
	"image/color"
	"io"
	"math"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"
	"sync"
	"time"

	"github.com/xuri/excelize/v2"

	beego "github.com/beego/beego/v2/server/web"
	"github.com/google/uuid"
	"gonum.org/v1/plot"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
)

type TaskController struct {
	beego.Controller
}

// 导入Excel创建任务并写入模版数据
func (c *TaskController) Import_Tasks() {
	file, fileHeader, err := c.GetFile("file")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "读取上传文件失败!"}
		c.ServeJSON()
		return
	}
	defer file.Close()

	// 保存上传的文件到临时位置，以便后续提取图片
	lib.Create_Dir("./ofile/temp_excel")
	tempExcelPath := fmt.Sprintf("./ofile/temp_excel/%d_%s", time.Now().Unix(), fileHeader.Filename)
	err = c.SaveToFile("file", tempExcelPath)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "保存临时文件失败!"}
		c.ServeJSON()
		return
	}
	defer os.Remove(tempExcelPath) // 处理完成后删除临时文件

	// 重新打开文件用于读取数据（必须使用文件路径，GetPicture 等功能依赖于完整文件）
	f, err := excelize.OpenFile(tempExcelPath)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "Excel 文件解析失败!"}
		c.ServeJSON()
		return
	}
	defer func() {
		_ = f.Close()
	}()

	sheetName := c.GetString("sheet")
	if len(sheetName) == 0 {
		sheets := f.GetSheetList()
		if len(sheets) == 0 {
			c.Data["json"] = lib.JSONS{Code: 203, Msg: "Excel 文件为空!"}
			c.ServeJSON()
			return
		}
		sheetName = sheets[0]
	}

	rows, err := f.GetRows(sheetName)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "读取 Excel 内容失败!"}
		c.ServeJSON()
		return
	}
	if len(rows) < 2 {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "Excel 中缺少数据行!"}
		c.ServeJSON()
		return
	}

	headers := rows[0]
	successIDs := make([]string, 0)
	skippedRows := make([]int, 0)
	failedRows := make([]string, 0)

	// 从 Excel 文件中提取所有图片，建立 DISPIMG ID 到图片数据的映射
	// pictureMap key格式: DISPIMG 中的 ID (例如 "ID_53A3119AC46541C694965B07E5E00F81")
	pictureMap, err := c.extractPicturesFromExcel(tempExcelPath)
	if err != nil {
		logs.Warning(fmt.Sprintf("提取 Excel 图片失败: %v，将继续处理数据", err))
		pictureMap = make(map[string][]byte)
	}
	logs.Info(fmt.Sprintf("共提取到 %d 个图片（ID映射）", len(pictureMap)))

	// 缓存 InfoCollection，避免同一家公司重复查询或创建
	infoCollectionCache := make(map[string]InfoCollection.InfoCollection)

	for idx := 1; idx < len(rows); idx++ {
		rowCells := rows[idx]
		rowData := make(map[string]string, len(headers))
		nonEmpty := false
		for colIdx, header := range headers {
			header = strings.TrimSpace(header)
			if len(header) == 0 {
				continue
			}
			value := ""
			if colIdx < len(rowCells) {
				value = strings.TrimSpace(rowCells[colIdx])
			}
			if len(value) > 0 {
				nonEmpty = true
			}

			// 处理单元格内是图片的情况：只有value包含DISPIMG时才处理
			if strings.Contains(value, "DISPIMG") {
				logs.Info(fmt.Sprintf("单元格 %d:%d 包含DISPIMG，可能是图片: %s", idx+1, colIdx+1, value))

				// 从 DISPIMG 公式中提取 ID
				// 格式: =DISPIMG("ID_53A3119AC46541C694965B07E5E00F81",1) 或 DISPIMG("ID_...",1)
				var picData []byte
				var foundBy string

				// 通过 ID 查找图片（pictureMap 现在使用 DISPIMG ID 作为 key）
				dispimgIdRe := regexp.MustCompile(`DISPIMG\s*\(\s*"([^"]+)"`)
				idMatches := dispimgIdRe.FindStringSubmatch(value)
				if len(idMatches) > 1 {
					imageId := idMatches[1]
					logs.Info(fmt.Sprintf("从 DISPIMG 公式中提取到 ID: %s", imageId))
					if data, exists := pictureMap[imageId]; exists && len(data) > 0 {
						picData = data
						foundBy = fmt.Sprintf("ID (%s)", imageId)
						logs.Info(fmt.Sprintf("通过 ID %s 找到图片数据 (大小: %d 字节)", imageId, len(picData)))
					} else {
						logs.Warning(fmt.Sprintf("通过 ID %s 未找到图片数据，pictureMap 中有 %d 个图片", imageId, len(pictureMap)))
					}
				}

				// 如果找到了图片数据，上传图片
				if picData != nil && len(picData) > 0 {
					imageURL, uploadErr := c.uploadImageData(picData, header)
					if uploadErr == nil && len(imageURL) > 0 {
						value = imageURL
						nonEmpty = true
						logs.Info(fmt.Sprintf("第%d行 %s 图片上传成功 (通过%s): %s", idx+1, header, foundBy, imageURL))
						logs.Info(fmt.Sprintf("第%d行 %s 图片上传成功 (通过%s): %s", idx+1, header, foundBy, imageURL))
					} else if uploadErr != nil {
						logs.Error(fmt.Sprintf("第%d行 %s 上传单元格图片失败: %v", idx+1, header, uploadErr))
					}
				} else {
					logs.Warning(fmt.Sprintf("第%d行 %s 包含DISPIMG但未找到对应图片数据", idx+1, header))
				}
			}

			rowData[header] = value
		}
		if !nonEmpty {
			continue
		}

		companyName := strings.TrimSpace(rowData["公司名称"])
		taskName := strings.TrimSpace(rowData["任务名称"])
		belongYear := strings.TrimSpace(rowData["所属年份"])
		if len(companyName) == 0 || len(taskName) == 0 || len(belongYear) == 0 {
			skippedRows = append(skippedRows, idx+1)
			continue
		}

		taskID, err := c.importTaskRow(rowData, infoCollectionCache)
		if err != nil {
			failedRows = append(failedRows, fmt.Sprintf("第%d行: %v", idx+1, err))
			continue
		}
		successIDs = append(successIDs, taskID)
	}

	msg := fmt.Sprintf("导入完成, 成功 %d 条, 跳过 %d 条, 失败 %d 条", len(successIDs), len(skippedRows), len(failedRows))
	respData := map[string]interface{}{
		"success_ids":  successIDs,
		"skipped_rows": skippedRows,
	}
	if len(failedRows) > 0 {
		respData["failed_rows"] = failedRows
	}

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

func (c *TaskController) importTaskRow(row map[string]string, infoCollectionCache map[string]InfoCollection.InfoCollection) (string, error) {
	templateName := strings.TrimSpace(row["模板名称"])
	lastOpenBracket := strings.LastIndex(templateName, "[")
	lastCloseBracket := strings.LastIndex(templateName, "]")
	if lastOpenBracket == -1 || lastCloseBracket == -1 || lastOpenBracket >= lastCloseBracket {
		return "", fmt.Errorf("模版名称中未找到模版ID")
	}
	templateID := templateName[lastOpenBracket+1 : lastCloseBracket]
	if len(templateID) == 0 {
		return "", fmt.Errorf("模版ID为空")
	}

	vt, ok := VerifyTemplate.Read_VerifyTemplate(templateID)
	if !ok {
		return "", fmt.Errorf("模版不存在: %s", templateID)
	}

	taskUID := strings.TrimSpace(row["唯一标识"])
	if len(taskUID) == 0 {
		return "", fmt.Errorf("唯一标识缺失")
	}
	existingTask, taskExists := Task.Read_Task_ByUid(taskUID)

	companyName := strings.TrimSpace(row["公司名称"])
	if len(companyName) == 0 {
		return "", fmt.Errorf("公司名称缺失")
	}

	cachedUser, found, err := Account.GetCompanyFromCache(companyName)
	if err != nil {
		return "", fmt.Errorf("公司数据读取失败: %w", err)
	}
	var user Account.User
	if !found {
		newUser := Account.User{
			T_name:    companyName,
			T_pass:    Account.DefaultCompanyPasswordHash,
			T_passstr: Account.DefaultCompanyPasswordPlain,
			T_Show:    1,
			T_State:   1,
			T_pid:     0,
		}
		newID, ok := Account.Add_User(newUser)
		if !ok {
			return "", fmt.Errorf("自动创建公司失败")
		}
		if err := Account.UpdateUserPath(int(newID)); err != nil {
			logs.Error("更新新公司路径失败:", err)
		}
		createdUser, is := Account.Read_User_ById(int(newID))
		if !is {
			return "", fmt.Errorf("获取新公司信息失败")
		}
		user = createdUser
		Account.UpsertCompanyCache(user)
	} else {
		user = cachedUser
	}

	// 根据用户信息获取或创建 InfoCollection，并使用 map 做本次导入缓存，避免重复查询
	cacheKey := user.T_uuid
	if len(cacheKey) == 0 {
		cacheKey = user.T_name
	}

	infoCollectionRecord, ok := infoCollectionCache[cacheKey]
	if !ok {
		record, err := InfoCollection.GetOrCreate_InfoCollection(user.T_uuid, user.T_name)
		if err != nil {
			return "", fmt.Errorf("自动创建信息采集失败: %w", err)
		}
		infoCollectionRecord = record
		infoCollectionCache[cacheKey] = infoCollectionRecord
	}

	resolveAdminUUID := func(fieldName, fallback string, strict bool) (string, error) {
		value, ok := row[fieldName]
		if !ok || len(strings.TrimSpace(value)) == 0 {
			return fallback, nil
		}
		admin, err := Account.EnsureAdminByName(strings.TrimSpace(value), "")
		if err != nil {
			if strict {
				return "", err
			}
			logs.Error(fieldName+" 负责人处理失败:", err)
			return fallback, nil
		}
		return admin.T_uuid, nil
	}

	taskName := strings.TrimSpace(row["任务名称"])
	if len(taskName) == 0 {
		return "", fmt.Errorf("任务名称缺失")
	}

	classPath := ""
	if vt.T_class > 0 {
		if cls, err := VerifyTemplate.Read_VerifyTemplateClass_ById(vt.T_class); err == nil {
			p := cls.T_path
			p = strings.Trim(p, "/")
			p = strings.TrimPrefix(p, "0/")
			classPath = p
		}
	}

	schemeFallback := ""
	collectionFallback := ""
	reportingFallback := ""
	deliveryFallback := ""
	projectFallback := ""
	categoryFallback := ""
	deviceTypeFallback := ""
	verifyTypeFallback := ""
	if taskExists {
		schemeFallback = existingTask.T_scheme
		collectionFallback = existingTask.T_collection
		reportingFallback = existingTask.T_reporting
		deliveryFallback = existingTask.T_delivery
		projectFallback = existingTask.T_project
		categoryFallback = existingTask.T_category
		deviceTypeFallback = existingTask.T_device_type
		verifyTypeFallback = existingTask.T_verify_type
	}

	schemeUUID, err := resolveAdminUUID("实施方案", schemeFallback, false)
	if err != nil {
		return "", fmt.Errorf("实施方案负责人创建失败: %w", err)
	}
	collectionUUID, err := resolveAdminUUID("数据采集", collectionFallback, true)
	if err != nil {
		return "", fmt.Errorf("数据采集负责人创建失败: %w", err)
	}
	reportingUUID, err := resolveAdminUUID("报告编辑", reportingFallback, true)
	if err != nil {
		return "", fmt.Errorf("报告编辑负责人创建失败: %w", err)
	}
	deliveryUUID, err := resolveAdminUUID("交付审核", deliveryFallback, false)
	if err != nil {
		return "", fmt.Errorf("交付审核负责人创建失败: %w", err)
	}
	projectUUID, _ := resolveAdminUUID("项目负责人", projectFallback, false)

	categoryValue := strings.TrimSpace(row["类别"])
	if len(categoryValue) == 0 {
		categoryValue = categoryFallback
	}

	deviceTypeValue := strings.TrimSpace(row["设备类型"])
	if len(deviceTypeValue) == 0 {
		deviceTypeValue = deviceTypeFallback
	} else {
		if mapped, ok := Task.DeviceTypeMap[deviceTypeValue]; ok {
			deviceTypeValue = mapped
		} else {
			deviceTypeValue = deviceTypeValue
		}
	}

	verifyTypeValue := strings.TrimSpace(row["验证类型"])
	if len(verifyTypeValue) == 0 {
		verifyTypeValue = verifyTypeFallback
	}

	belongYearValue := strings.TrimSpace(row["所属年份"])

	infoCollectionID := infoCollectionRecord.T_InfoCollection_id

	taskRecord := Task.Task{
		T_Distributor_id:       user.T_Distributor_id,
		T_uuid:                 user.T_uuid,
		T_name:                 taskName,
		T_VerifyTemplate_id:    templateID,
		T_VerifyTemplate_class: classPath,
		T_InfoCollection_id:    infoCollectionID,
		T_uid:                  taskUID,
		T_scheme:               schemeUUID,
		T_collection:           collectionUUID,
		T_reporting:            reportingUUID,
		T_delivery:             deliveryUUID,
		T_project:              projectUUID,
		T_category:             categoryValue,
		T_device_type:          deviceTypeValue,
		T_verify_type:          verifyTypeValue,
		T_belong_year:          belongYearValue,
	}

	var taskID string
	if taskExists {
		taskRecord.Id = existingTask.Id
		taskRecord.T_task_id = existingTask.T_task_id
		taskRecord.T_State = existingTask.T_State
		if ok := Task.Update_Task(taskRecord, "T_Distributor_id", "T_uuid", "T_name", "T_VerifyTemplate_id", "T_VerifyTemplate_class", "T_uid", "T_scheme", "T_collection", "T_reporting", "T_delivery", "T_project", "T_category", "T_device_type", "T_verify_type", "T_belong_year"); !ok {
			return "", fmt.Errorf("更新任务失败")
		}
		taskID = existingTask.T_task_id
	} else {
		dc := Device.DeviceClass{
			T_uuid:  user.T_uuid,
			T_State: 1,
		}
		classID, ok := Device.Add_DeviceClass(dc)
		if !ok {
			return "", fmt.Errorf("创建分类失败")
		}
		taskRecord.T_class = int(classID)
		taskRecord.T_State = 1
		taskRecord.T_deadline = time.Now().AddDate(0, 2, 0).Format("2006-01-02")
		if len(strings.TrimSpace(taskRecord.T_device_type)) > 0 {
			number, err := Task.GenerateNextT_report_number(taskRecord.T_device_type)
			if err != nil {
				return "", fmt.Errorf("生成报告编号失败: %w", err)
			}
			taskRecord.T_report_number = number
		}

		if newID, ok := Task.Add_Task(taskRecord); !ok {
			return "", fmt.Errorf("创建任务失败")
		} else {
			taskID = newID
		}
	}

	mapList, _ := VerifyTemplate.Read_VerifyTemplateMap_List(templateID, 0, 0)
	labelMap := make(map[string]VerifyTemplate.VerifyTemplateMap_R, len(mapList))
	for _, m := range mapList {
		labelMap[m.T_name] = m
	}

	dataList := make([]VerifyTemplate.VerifyTemplateMapData, 0, len(row))
	for key, val := range row {
		if vtm, exists := labelMap[key]; exists {
			logs.Println("key:", key, "val:", val)
			dataList = append(dataList, VerifyTemplate.VerifyTemplateMapData{
				T_source:               vtm.T_source,
				T_task_id:              taskID,
				T_VerifyTemplate_id:    templateID,
				T_VerifyTemplateMap_id: vtm.T_id,
				T_value:                val,
				T_Required:             vtm.T_Required,
				T_Construction:         vtm.T_Construction,
				T_flow_sort:            vtm.T_flow_sort,
				T_max_time:             vtm.T_max_time,
				T_min_time:             vtm.T_min_time,
				T_start_time:           int64(vtm.T_start_time),
			})
		}
	}
	if len(dataList) > 0 {
		if _, ok := VerifyTemplate.AddOrUpdate_VerifyTemplateMapData(dataList); !ok {
			return "", fmt.Errorf("写入模版数据失败")
		}
	}

	return taskID, nil
}
func (c *TaskController) extractPicturesFromExcel(filePath string) (map[string][]byte, error) {
	filePath = strings.TrimSpace(filePath)
	if len(filePath) == 0 {
		return nil, fmt.Errorf("Excel 文件路径为空")
	}

	zipReader, err := zip.OpenReader(filePath)
	if err != nil {
		return nil, fmt.Errorf("打开 Excel 压缩包失败: %w", err)
	}
	defer zipReader.Close()

	return c.extractWpsDispImgPictures(zipReader), nil
}

// extractWpsDispImgPictures 专门处理 WPS / _xlfn.DISPIMG 的图片提取逻辑
// 原理参考: `https://www.hushlll.top/?p=644`
// 1. 读取 xl/cellimages.xml，找到每个图片块中的 name="ID_xxx" 和 r:embed="rIdX"
// 2. 读取 xl/_rels/cellimages.xml.rels（或退回到 xl/drawings/_rels/drawing1.xml.rels），把 rId 映射到具体的图片路径（如 media/image1.jpg）
// 3. 从 ZIP 中按路径取出图片数据，建立 ID -> 图片数据 的映射
func (c *TaskController) extractWpsDispImgPictures(zipReader *zip.ReadCloser) map[string][]byte {
	result := make(map[string][]byte)

	if zipReader == nil || zipReader.File == nil {
		return result
	}

	// 1. 找到 xl/cellimages.xml
	var cellImagesFile *zip.File
	for _, f := range zipReader.File {
		if f != nil && f.Name == "xl/cellimages.xml" {
			cellImagesFile = f
			break
		}
	}
	if cellImagesFile == nil {
		// 非 WPS / 无 cellimages.xml 的情况，直接返回空
		return result
	}

	rc, err := cellImagesFile.Open()
	if err != nil {
		logs.Warning(fmt.Sprintf("无法打开 xl/cellimages.xml: %v", err))
		return result
	}
	cellImagesData, err := io.ReadAll(rc)
	rc.Close()
	if err != nil {
		logs.Warning(fmt.Sprintf("无法读取 xl/cellimages.xml: %v", err))
		return result
	}
	cellImagesContent := string(cellImagesData)

	// 2. 读取关系文件：优先 xl/_rels/cellimages.xml.rels，找不到再尝试 xl/drawings/_rels/drawing1.xml.rels
	var relsFile *zip.File
	for _, f := range zipReader.File {
		if f != nil && f.Name == "xl/_rels/cellimages.xml.rels" {
			relsFile = f
			break
		}
	}
	if relsFile == nil {
		for _, f := range zipReader.File {
			if f != nil && f.Name == "xl/drawings/_rels/drawing1.xml.rels" {
				relsFile = f
				break
			}
		}
	}
	if relsFile == nil {
		logs.Warning("未找到 cellimages 对应的关系文件 (cellimages.xml.rels / drawing1.xml.rels)")
		return result
	}

	rc, err = relsFile.Open()
	if err != nil {
		logs.Warning(fmt.Sprintf("无法打开关系文件 %s: %v", relsFile.Name, err))
		return result
	}
	relsData, err := io.ReadAll(rc)
	rc.Close()
	if err != nil {
		logs.Warning(fmt.Sprintf("无法读取关系文件 %s: %v", relsFile.Name, err))
		return result
	}
	relsContent := string(relsData)

	// 2.1 解析关系文件，建立 rId -> Target 的映射
	relsMap := make(map[string]string)
	reRel := regexp.MustCompile(`Id="([^"]+)"[^>]*Target="([^"]+)"`)
	for _, m := range reRel.FindAllStringSubmatch(relsContent, -1) {
		if len(m) >= 3 {
			id := m[1]
			target := m[2]
			relsMap[id] = target
		}
	}
	if len(relsMap) == 0 {
		logs.Warning(fmt.Sprintf("关系文件 %s 中未解析到任何图片关系", relsFile.Name))
		return result
	}

	// 3. 从 cellimages.xml 中解析每个图片块
	// 结构大致类似：
	// <xdr:pic> ... <xdr:nvPicPr>...<xdr:cNvPr name="ID_XXXX".../> ...</xdr:nvPicPr> ... <a:blip r:embed="rId1"/> ... </xdr:pic>
	picBlocks := regexp.MustCompile(`(?s)<xdr:pic[^>]*>.*?</xdr:pic>`).FindAllString(cellImagesContent, -1)
	if len(picBlocks) == 0 {
		logs.Warning("xl/cellimages.xml 中未找到任何 <xdr:pic> 图片块")
		return result
	}

	nameRe := regexp.MustCompile(`name="(ID_[^"]+)"`)
	embedRe := regexp.MustCompile(`r:embed="([^"]+)"`)

	for _, block := range picBlocks {
		nameMatch := nameRe.FindStringSubmatch(block)
		if len(nameMatch) < 2 {
			continue
		}
		imgID := nameMatch[1]

		embedMatch := embedRe.FindStringSubmatch(block)
		if len(embedMatch) < 2 {
			logs.Warning(fmt.Sprintf("WPS 图片块中 ID %s 未找到 r:embed 属性", imgID))
			continue
		}
		rId := embedMatch[1]

		target, ok := relsMap[rId]
		if !ok {
			logs.Warning(fmt.Sprintf("在关系文件中未找到 rId=%s 对应的图片路径 (ID=%s)", rId, imgID))
			continue
		}

		// 关系文件里的 Target 一般是 media/image1.jpg 或 ../media/image1.jpg
		// 在 ZIP 中的真实路径应为 xl/<Target 去掉前导 / >
		imagePathInZip := "xl/" + strings.TrimLeft(target, "/")

		var imageFile *zip.File
		for _, f := range zipReader.File {
			if f != nil && f.Name == imagePathInZip {
				imageFile = f
				break
			}
		}
		if imageFile == nil {
			logs.Warning(fmt.Sprintf("在 ZIP 中未找到图片文件 %s (ID=%s, rId=%s)", imagePathInZip, imgID, rId))
			continue
		}

		rcImg, err := imageFile.Open()
		if err != nil {
			logs.Warning(fmt.Sprintf("无法打开图片文件 %s: %v", imagePathInZip, err))
			continue
		}
		imgData, err := io.ReadAll(rcImg)
		rcImg.Close()
		if err != nil {
			logs.Warning(fmt.Sprintf("无法读取图片文件 %s: %v", imagePathInZip, err))
			continue
		}
		if len(imgData) == 0 {
			logs.Warning(fmt.Sprintf("图片文件 %s 为空，跳过 (ID=%s)", imagePathInZip, imgID))
			continue
		}

		result[imgID] = imgData
		logs.Info(fmt.Sprintf("WPS cellimages 建立映射: ID %s -> %s (大小: %d 字节)", imgID, imagePathInZip, len(imgData)))
	}

	logs.Info(fmt.Sprintf("通过 WPS cellimages 共解析出 %d 个 ID->图片 映射", len(result)))
	return result
}

// 上传图片数据到七牛云
func (c *TaskController) uploadImageData(imageData []byte, headerName string) (string, error) {
	if len(imageData) == 0 {
		return "", fmt.Errorf("图片数据为空")
	}

	// 创建临时目录
	tempDir := "./ofile/temp_images"
	err := os.MkdirAll(tempDir, 0755)
	if err != nil {
		return "", fmt.Errorf("创建临时目录失败: %w", err)
	}

	// 根据图片数据的前几个字节判断图片格式
	ext := ".png" // 默认扩展名
	if len(imageData) >= 4 {
		// PNG: 89 50 4E 47
		if imageData[0] == 0x89 && imageData[1] == 0x50 && imageData[2] == 0x4E && imageData[3] == 0x47 {
			ext = ".png"
		} else if len(imageData) >= 2 {
			// JPEG: FF D8
			if imageData[0] == 0xFF && imageData[1] == 0xD8 {
				ext = ".jpg"
			} else if len(imageData) >= 6 {
				// GIF: 47 49 46 38
				if imageData[0] == 0x47 && imageData[1] == 0x49 && imageData[2] == 0x46 && imageData[3] == 0x38 {
					ext = ".gif"
				}
			}
		}
	}

	fileName := fmt.Sprintf("%s_%s_%d%s", headerName, uuid.New().String(), time.Now().Unix(), ext)
	tempFilePath := filepath.Join(tempDir, fileName)

	// 保存图片到临时文件
	err = os.WriteFile(tempFilePath, imageData, 0644)
	if err != nil {
		return "", fmt.Errorf("保存图片失败: %w", err)
	}
	defer func() {
		// 确保清理临时文件
		if removeErr := os.Remove(tempFilePath); removeErr != nil {
			logs.Error(fmt.Sprintf("删除临时文件失败: %s, 错误: %v", tempFilePath, removeErr))
		}
	}()

	// 检查文件是否存在
	fileInfo, err := os.Stat(tempFilePath)
	if err != nil {
		return "", fmt.Errorf("获取文件信息失败: %w", err)
	}

	// 上传到七牛云
	qiniuFileName := fmt.Sprintf("UpImage/excel_import_%s_%d%s", uuid.New().String(), time.Now().Unix(), ext)
	logs.Info(fmt.Sprintf("准备上传图片: %s, 大小: %d 字节, 目标: %s", tempFilePath, fileInfo.Size(), qiniuFileName))

	imageURL, success := NatsServer.Qiniu_UploadFile(tempFilePath, qiniuFileName)
	if !success {
		logs.Error(fmt.Sprintf("上传图片到七牛云失败: 文件=%s, 大小=%d 字节, 目标=%s", tempFilePath, fileInfo.Size(), qiniuFileName))
		return "", fmt.Errorf("上传图片到七牛云失败，文件大小: %d 字节", fileInfo.Size())
	}

	if imageURL == "" {
		return "", fmt.Errorf("上传图片后未返回URL")
	}

	logs.Info(fmt.Sprintf("图片上传成功: %s -> %s", tempFilePath, imageURL))
	return imageURL, nil
}

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

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

	T_name := c.GetString("T_name")
	T_company := c.GetString("T_company") // 公司名称
	T_uuid := c.GetString("T_uuid")
	T_InfoCollection_id := c.GetString("T_InfoCollection_id")

	T_scheme := c.GetString("T_scheme")                     // 实施方案 负责人UUID
	T_collection := c.GetString("T_collection")             // 数据采集 负责人UUID
	T_reporting := c.GetString("T_reporting")               // 报告编写 负责人UUID
	T_delivery := c.GetString("T_delivery")                 // 交付审核 负责人UUID
	T_scheme_state := c.GetString("T_scheme_state")         // 实施方案 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_collection_state := c.GetString("T_collection_state") // 数据采集 状态 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4-数据编辑已完成(已提交) 5已通过(负责人) 6已退回(负责人)
	T_reporting_state := c.GetString("T_reporting_state")   // 报告编写 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_delivery_state := c.GetString("T_delivery_state")     // 交付审核 状态 0 未完成 1 已完成 2 处理中
	T_marking_state := c.GetString("T_marking_state")       // 验证标识 状态 0 未完成 1 已完成
	CreateTime := c.GetString("CreateTime")                 // 任务添加时间

	UserMap := Account.UserListToMap(Account.Read_User_List_ALL_1())
	AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())

	var T_company_list []string
	if len(T_company) > 0 {
		T_company_list = Account.Read_User_T_uuid_ListByT_name(T_company)
	}

	var T_admin string
	if User_r.T_power > 2 {
		T_admin = User_r.T_uuid
	}
	// 经销商下管理员可查看自己经销商下所有的任务
	// 经销商下其他角色只能查看分配给自己的任务
	if len(User_r.T_Distributor_id) > 0 && User_r.T_power <= 2 {
		T_admin = ""
	}

	var cnt int

	List, cnt := Task.Read_Task_List(User_r.T_Distributor_id, T_uuid, T_admin, T_name, T_InfoCollection_id, T_scheme, T_collection, T_reporting, T_delivery,
		T_scheme_state, T_collection_state, T_reporting_state, T_delivery_state, T_marking_state,
		T_company_list, UserMap, AdminMap, CreateTime, 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 = cnt

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

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

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

	T_name := c.GetString("T_name")
	T_company := c.GetString("T_company") // 公司名称
	T_uuid := c.GetString("T_uuid")
	T_InfoCollection_id := c.GetString("T_InfoCollection_id")

	T_project := c.GetString("T_project")                   // 项目 负责人UUID
	T_scheme := c.GetString("T_scheme")                     // 实施方案 负责人UUID
	T_collection := c.GetString("T_collection")             // 数据采集 负责人UUID
	T_reporting := c.GetString("T_reporting")               // 报告编写 负责人UUID
	T_delivery := c.GetString("T_delivery")                 // 交付审核 负责人UUID
	T_scheme_state := c.GetString("T_scheme_state")         // 实施方案 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_collection_state := c.GetString("T_collection_state") // 数据采集 状态 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4-数据编辑已完成(已提交) 5已通过(负责人) 6已退回(负责人)
	T_reporting_state := c.GetString("T_reporting_state")   // 报告编写 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_delivery_state := c.GetString("T_delivery_state")     // 交付审核 状态 0 未完成 1 已完成 2 处理中
	T_marking_state := c.GetString("T_marking_state")       // 验证标识 状态 0 未完成 1 已完成
	CreateTime := c.GetString("CreateTime")                 // 任务添加时间

	UserMap := Account.UserListToMap(Account.Read_User_List_ALL_1())
	AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())

	var T_company_list []string
	if len(T_company) > 0 {
		T_company_list = Account.Read_User_T_uuid_ListByT_name(T_company)
	}

	var T_admin string
	if User_r.T_power > 2 {
		T_admin = User_r.T_uuid
	}

	var cnt int
	List, cnt := Task.Read_Task_Stat(User_r.T_Distributor_id, T_uuid, T_admin, T_name, T_InfoCollection_id, T_project, T_scheme, T_collection, T_reporting, T_delivery,
		T_scheme_state, T_collection_state, T_reporting_state, T_delivery_state, T_marking_state,
		T_company_list, UserMap, AdminMap, CreateTime, 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 = cnt

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

// 报告统计 - 导出excel
func (c *TaskController) Stat_Excel() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_name := c.GetString("T_name")
	T_company := c.GetString("T_company") // 公司名称
	T_uuid := c.GetString("T_uuid")
	T_InfoCollection_id := c.GetString("T_InfoCollection_id")

	T_project := c.GetString("T_project")                   // 项目 负责人UUID
	T_scheme := c.GetString("T_scheme")                     // 实施方案 负责人UUID
	T_collection := c.GetString("T_collection")             // 数据采集 负责人UUID
	T_reporting := c.GetString("T_reporting")               // 报告编写 负责人UUID
	T_delivery := c.GetString("T_delivery")                 // 交付审核 负责人UUID
	T_scheme_state := c.GetString("T_scheme_state")         // 实施方案 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_collection_state := c.GetString("T_collection_state") // 数据采集 状态 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4-数据编辑已完成(已提交) 5已通过(负责人) 6已退回(负责人)
	T_reporting_state := c.GetString("T_reporting_state")   // 报告编写 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_delivery_state := c.GetString("T_delivery_state")     // 交付审核 状态 0 未完成 1 已完成 2 处理中
	T_marking_state := c.GetString("T_marking_state")       // 验证标识 状态 0 未完成 1 已完成
	CreateTime := c.GetString("CreateTime")                 // 任务添加时间

	UserMap := Account.UserListToMap(Account.Read_User_List_ALL_1())
	AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())

	var T_company_list []string
	if len(T_company) > 0 {
		T_company_list = Account.Read_User_T_uuid_ListByT_name(T_company)
	}

	var T_admin string
	if User_r.T_power > 2 {
		T_admin = User_r.T_uuid
	}

	List, _ := Task.Read_Task_Stat(User_r.T_Distributor_id, T_uuid, T_admin, T_name, T_InfoCollection_id, T_project, T_scheme, T_collection, T_reporting, T_delivery,
		T_scheme_state, T_collection_state, T_reporting_state, T_delivery_state, T_marking_state,
		T_company_list, UserMap, AdminMap, CreateTime, 0, 9999)

	f := excelize.NewFile() // 设置单元格的值
	line := 1
	// 这里设置表头
	f.MergeCell("Sheet1", fmt.Sprintf("A%d", line), fmt.Sprintf("A%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("B%d", line), fmt.Sprintf("B%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("C%d", line), fmt.Sprintf("C%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("D%d", line), fmt.Sprintf("D%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("E%d", line), fmt.Sprintf("E%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("F%d", line), fmt.Sprintf("F%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("G%d", line), fmt.Sprintf("G%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("H%d", line), fmt.Sprintf("H%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("I%d", line), fmt.Sprintf("I%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("J%d", line), fmt.Sprintf("J%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("K%d", line), fmt.Sprintf("K%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("L%d", line), fmt.Sprintf("L%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("M%d", line), fmt.Sprintf("M%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("N%d", line), fmt.Sprintf("N%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("O%d", line), fmt.Sprintf("O%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("P%d", line), fmt.Sprintf("P%d", line+1))
	f.MergeCell("Sheet1", fmt.Sprintf("Q%d", line), fmt.Sprintf("U%d", line))
	f.MergeCell("Sheet1", fmt.Sprintf("V%d", line), fmt.Sprintf("AA%d", line))
	f.MergeCell("Sheet1", fmt.Sprintf("AB%d", line), fmt.Sprintf("AG%d", line))
	f.MergeCell("Sheet1", fmt.Sprintf("AH%d", line), fmt.Sprintf("AM%d", line))

	f.SetCellValue("Sheet1", fmt.Sprintf("Q%d", line), "信息表")
	f.SetCellValue("Sheet1", fmt.Sprintf("V%d", line), "方案")
	f.SetCellValue("Sheet1", fmt.Sprintf("AB%d", line), "实施")
	f.SetCellValue("Sheet1", fmt.Sprintf("AH%d", line), "报告")

	f.SetCellValue("Sheet1", fmt.Sprintf("A%d", line), "序号")
	f.SetCellValue("Sheet1", fmt.Sprintf("B%d", line), "公司名称")
	f.SetCellValue("Sheet1", fmt.Sprintf("C%d", line), "报告名称")
	f.SetCellValue("Sheet1", fmt.Sprintf("D%d", line), "项目负责人")
	f.SetCellValue("Sheet1", fmt.Sprintf("E%d", line), "地区")
	f.SetCellValue("Sheet1", fmt.Sprintf("F%d", line), "类别")
	f.SetCellValue("Sheet1", fmt.Sprintf("G%d", line), "设备类型")
	f.SetCellValue("Sheet1", fmt.Sprintf("H%d", line), "规格/容积")
	f.SetCellValue("Sheet1", fmt.Sprintf("I%d", line), "验证类型")
	f.SetCellValue("Sheet1", fmt.Sprintf("J%d", line), "标的物名称")
	f.SetCellValue("Sheet1", fmt.Sprintf("K%d", line), "验证温度范围")
	f.SetCellValue("Sheet1", fmt.Sprintf("L%d", line), "报告编号")
	f.SetCellValue("Sheet1", fmt.Sprintf("M%d", line), "项目开始时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("N%d", line), "项目用时")
	f.SetCellValue("Sheet1", fmt.Sprintf("O%d", line), "驳回次数")
	f.SetCellValue("Sheet1", fmt.Sprintf("P%d", line), "回款")
	f.SetCellValue("Sheet1", fmt.Sprintf("Q%d", line+1), "编写人")
	f.SetCellValue("Sheet1", fmt.Sprintf("R%d", line+1), "状态")
	f.SetCellValue("Sheet1", fmt.Sprintf("S%d", line+1), "开始时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("T%d", line+1), "退回次数")
	f.SetCellValue("Sheet1", fmt.Sprintf("U%d", line+1), "所需时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("V%d", line+1), "编写人")
	f.SetCellValue("Sheet1", fmt.Sprintf("W%d", line+1), "状态")
	f.SetCellValue("Sheet1", fmt.Sprintf("X%d", line+1), "开始时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("Y%d", line+1), "退回次数")
	f.SetCellValue("Sheet1", fmt.Sprintf("Z%d", line+1), "所需时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AA%d", line+1), "超时时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AB%d", line+1), "编写人")
	f.SetCellValue("Sheet1", fmt.Sprintf("AC%d", line+1), "状态")
	f.SetCellValue("Sheet1", fmt.Sprintf("AD%d", line+1), "开始时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AE%d", line+1), "退回次数")
	f.SetCellValue("Sheet1", fmt.Sprintf("AF%d", line+1), "所需时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AG%d", line+1), "超时时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AH%d", line+1), "编写人")
	f.SetCellValue("Sheet1", fmt.Sprintf("AI%d", line+1), "状态")
	f.SetCellValue("Sheet1", fmt.Sprintf("AJ%d", line+1), "开始时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AK%d", line+1), "退回次数")
	f.SetCellValue("Sheet1", fmt.Sprintf("AL%d", line+1), "所需时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AM%d", line+1), "超时时间")
	f.SetCellValue("Sheet1", fmt.Sprintf("AN%d", line+1), "领导备注")

	// 设置列宽
	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", 12)
	f.SetColWidth("Sheet1", "F", "F", 8)
	f.SetColWidth("Sheet1", "G", "G", 12)
	f.SetColWidth("Sheet1", "H", "H", 14)
	f.SetColWidth("Sheet1", "I", "I", 12)
	f.SetColWidth("Sheet1", "J", "J", 12)
	f.SetColWidth("Sheet1", "K", "K", 12)
	f.SetColWidth("Sheet1", "L", "L", 12)
	f.SetColWidth("Sheet1", "M", "M", 12)
	f.SetColWidth("Sheet1", "N", "N", 12)
	f.SetColWidth("Sheet1", "O", "O", 10)
	f.SetColWidth("Sheet1", "P", "P", 8)
	f.SetColWidth("Sheet1", "Q", "Q", 8)
	f.SetColWidth("Sheet1", "R", "R", 8)
	f.SetColWidth("Sheet1", "S", "S", 12)
	f.SetColWidth("Sheet1", "T", "T", 10)
	f.SetColWidth("Sheet1", "U", "U", 10)
	f.SetColWidth("Sheet1", "V", "V", 8)
	f.SetColWidth("Sheet1", "W", "W", 8)
	f.SetColWidth("Sheet1", "X", "X", 12)
	f.SetColWidth("Sheet1", "Y", "Y", 10)
	f.SetColWidth("Sheet1", "Z", "Z", 12)
	f.SetColWidth("Sheet1", "AA", "AA", 12)
	f.SetColWidth("Sheet1", "AB", "AB", 8)
	f.SetColWidth("Sheet1", "AC", "AC", 8)
	f.SetColWidth("Sheet1", "AD", "AD", 12)
	f.SetColWidth("Sheet1", "AE", "AE", 10)
	f.SetColWidth("Sheet1", "AF", "AF", 12)
	f.SetColWidth("Sheet1", "AG", "AG", 12)
	f.SetColWidth("Sheet1", "AG", "AG", 10)
	f.SetColWidth("Sheet1", "AH", "AH", 8)
	f.SetColWidth("Sheet1", "AI", "AI", 8)
	f.SetColWidth("Sheet1", "AJ", "AJ", 10)
	f.SetColWidth("Sheet1", "AK", "AK", 12)
	f.SetColWidth("Sheet1", "AL", "AL", 12)
	f.SetColWidth("Sheet1", "AM", "AM", 12)

	Style1, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 12, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
			Border: []excelize.Border{
				{Type: "left", Color: "000000", Style: 1},
				{Type: "top", Color: "000000", Style: 1},
				{Type: "bottom", Color: "000000", Style: 1},
				{Type: "right", Color: "000000", Style: 1},
			},
		})

	f.SetCellStyle("Sheet1", "A1", "AM2", Style1)
	f.SetRowHeight("Sheet1", 1, 25)
	f.SetRowHeight("Sheet1", 2, 25)

	line += 1

	// 循环写入数据
	for i, v := range List {
		line++
		f.SetCellValue("Sheet1", fmt.Sprintf("A%d", line), i+1)
		f.SetCellValue("Sheet1", fmt.Sprintf("B%d", line), v.T_user_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("C%d", line), v.T_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("D%d", line), v.T_project_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("E%d", line), fmt.Sprintf("%s-%s-%s", v.T_province, v.T_city, v.T_district))
		f.SetCellValue("Sheet1", fmt.Sprintf("F%d", line), v.T_category)
		f.SetCellValue("Sheet1", fmt.Sprintf("G%d", line), v.T_device_type)
		f.SetCellValue("Sheet1", fmt.Sprintf("H%d", line), v.T_volume)
		f.SetCellValue("Sheet1", fmt.Sprintf("I%d", line), v.T_verify_type)
		f.SetCellValue("Sheet1", fmt.Sprintf("J%d", line), v.T_subject_matter)
		f.SetCellValue("Sheet1", fmt.Sprintf("K%d", line), v.T_temp_range)
		f.SetCellValue("Sheet1", fmt.Sprintf("L%d", line), fmt.Sprintf("%s-%s", v.T_report_type, v.T_report_number))
		f.SetCellValue("Sheet1", fmt.Sprintf("M%d", line), v.T_start_time)
		f.SetCellValue("Sheet1", fmt.Sprintf("N%d", line), v.T_time_interval)
		f.SetCellValue("Sheet1", fmt.Sprintf("O%d", line), v.T_reject_times)
		returnedMoney := "否"
		if v.InfoCollection.T_status == InfoCollection.InfoCollectionStatusReturnedMoney {
			returnedMoney = "是"
		}
		f.SetCellValue("Sheet1", fmt.Sprintf("P%d", line), returnedMoney)
		f.SetCellValue("Sheet1", fmt.Sprintf("Q%d", line), v.InfoCollection.T_submit_uuid_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("R%d", line), InfoCollection.InfoCollectionStatusMap[v.InfoCollection.T_State])
		f.SetCellValue("Sheet1", fmt.Sprintf("S%d", line), v.InfoCollection.T_start_time)
		f.SetCellValue("Sheet1", fmt.Sprintf("T%d", line), v.InfoCollection.T_return_times)
		f.SetCellValue("Sheet1", fmt.Sprintf("U%d", line), v.InfoCollection.T_time_interval)
		f.SetCellValue("Sheet1", fmt.Sprintf("V%d", line), v.T_scheme_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("W%d", line), Task.TaskSchemeStateMap[v.T_scheme_state])
		f.SetCellValue("Sheet1", fmt.Sprintf("X%d", line), v.T_scheme_start_time)
		f.SetCellValue("Sheet1", fmt.Sprintf("Y%d", line), v.T_scheme_return_times)
		f.SetCellValue("Sheet1", fmt.Sprintf("Z%d", line), v.T_scheme_time_interval)
		f.SetCellValue("Sheet1", fmt.Sprintf("AA%d", line), v.T_scheme_overtime)
		f.SetCellValue("Sheet1", fmt.Sprintf("AB%d", line), v.T_collection_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("AC%d", line), Task.TaskCollectionStateMap[v.T_collection_state])
		f.SetCellValue("Sheet1", fmt.Sprintf("AD%d", line), v.T_collection_start_time)
		f.SetCellValue("Sheet1", fmt.Sprintf("AE%d", line), v.T_collection_return_times)
		f.SetCellValue("Sheet1", fmt.Sprintf("AF%d", line), v.T_collection_time_interval)
		f.SetCellValue("Sheet1", fmt.Sprintf("AG%d", line), v.T_collection_overtime)
		f.SetCellValue("Sheet1", fmt.Sprintf("AH%d", line), v.T_reporting_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("AI%d", line), Task.TaskReportingStateMap[v.T_reporting_state])
		f.SetCellValue("Sheet1", fmt.Sprintf("AJ%d", line), v.T_reporting_start_time)
		f.SetCellValue("Sheet1", fmt.Sprintf("AK%d", line), v.T_reporting_return_times)
		f.SetCellValue("Sheet1", fmt.Sprintf("AL%d", line), v.T_reporting_time_interval)
		f.SetCellValue("Sheet1", fmt.Sprintf("AM%d", line), v.T_reporting_overtime)
		f.SetCellValue("Sheet1", fmt.Sprintf("AN%d", line), v.T_record)
	}

	Style2, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Size: 10, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
			Border: []excelize.Border{
				{Type: "left", Color: "000000", Style: 1},
				{Type: "top", Color: "000000", Style: 1},
				{Type: "bottom", Color: "000000", Style: 1},
				{Type: "right", Color: "000000", Style: 1},
			},
		})
	f.SetCellStyle("Sheet1", "A2", fmt.Sprintf("AM%d", line), Style2)

	StyleBlueFill, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 12, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
			Border: []excelize.Border{
				{Type: "left", Color: "000000", Style: 1},
				{Type: "top", Color: "000000", Style: 1},
				{Type: "bottom", Color: "000000", Style: 1},
				{Type: "right", Color: "000000", Style: 1},
			},
			Fill: excelize.Fill{Type: "pattern", Color: []string{"#DEE5F5"}, Pattern: 1},
		})

	// 粉色填充
	StylePinkFill, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 12, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
			Border: []excelize.Border{
				{Type: "left", Color: "000000", Style: 1},
				{Type: "top", Color: "000000", Style: 1},
				{Type: "bottom", Color: "000000", Style: 1},
				{Type: "right", Color: "000000", Style: 1},
			},
			Fill: excelize.Fill{Type: "pattern", Color: []string{"#FBDFE2"}, Pattern: 1},
		})

	StyleOrangeFill, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 12, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
			Border: []excelize.Border{
				{Type: "left", Color: "000000", Style: 1},
				{Type: "top", Color: "000000", Style: 1},
				{Type: "bottom", Color: "000000", Style: 1},
				{Type: "right", Color: "000000", Style: 1},
			},
			Fill: excelize.Fill{Type: "pattern", Color: []string{"#FCE7D8"}, Pattern: 1},
		})
	StyleYellowFill, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 12, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
			Border: []excelize.Border{
				{Type: "left", Color: "000000", Style: 1},
				{Type: "top", Color: "000000", Style: 1},
				{Type: "bottom", Color: "000000", Style: 1},
				{Type: "right", Color: "000000", Style: 1},
			},
			Fill: excelize.Fill{Type: "pattern", Color: []string{"#FFF5D0"}, Pattern: 1},
		})
	StyleGreenFill, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 12, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
			Border: []excelize.Border{
				{Type: "left", Color: "000000", Style: 1},
				{Type: "top", Color: "000000", Style: 1},
				{Type: "bottom", Color: "000000", Style: 1},
				{Type: "right", Color: "000000", Style: 1},
			},
			Fill: excelize.Fill{Type: "pattern", Color: []string{"#E7F4DE"}, Pattern: 1},
		})

	f.SetCellStyle("Sheet1", "A1", "AM2", StyleBlueFill)
	f.SetCellStyle("Sheet1", "Q1", "U1", StylePinkFill)
	f.SetCellStyle("Sheet1", "V1", "AA1", StyleOrangeFill)
	f.SetCellStyle("Sheet1", "AB1", "AG1", StyleYellowFill)
	f.SetCellStyle("Sheet1", "AH1", "AM1", StyleGreenFill)
	f.SetCellStyle("Sheet1", "AN1", "AN2", StyleBlueFill)

	// 冻结1-2行
	f.SetPanes("Sheet1", &excelize.Panes{
		Freeze:      true,
		Split:       false,
		XSplit:      3,
		YSplit:      2,
		TopLeftCell: "A1",
		ActivePane:  "topRight",
	})

	lib.Create_Dir("./ofile")

	timeStr := time.Now().Format("20060102150405")
	// 保存文件
	if err := f.SaveAs("ofile/" + timeStr + ".xlsx"); err != nil {
		logs.Error(lib.FuncName(), 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 {
		logs.Error(lib.FuncName(), err)
	}

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

// 导出唯一任务标识
func (c *TaskController) ExportTaskUid() {
	// 验证登录
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_num, _ := c.GetInt("T_num")
	if T_num <= 0 {
		T_num = 10
	}
	if T_num > 1000 {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "单次最多生成1000个唯一标识"}
		c.ServeJSON()
		return
	}

	uidList := make([]string, 0, T_num)
	exists := make(map[string]struct{}, T_num)
	exportBatch := fmt.Sprintf("export_%d", time.Now().UnixNano())

	for len(uidList) < T_num {
		candidate := strings.ToUpper(strings.ReplaceAll(uuid.New().String(), "-", ""))
		if len(candidate) > 16 {
			candidate = candidate[:16]
		}

		if _, ok := exists[candidate]; ok {
			continue
		}
		if _, found := Task.Read_Task_ByUid(candidate); found {
			continue
		}
		if Task.TaskUidExists(candidate) {
			continue
		}
		exists[candidate] = struct{}{}
		uidList = append(uidList, candidate)
	}

	f := excelize.NewFile()
	sheet := "Sheet1"
	f.SetCellValue(sheet, "A1", "序号")
	f.SetCellValue(sheet, "B1", "唯一标识")
	for i, uid := range uidList {
		row := i + 2
		f.SetCellValue(sheet, fmt.Sprintf("A%d", row), i+1)
		f.SetCellValue(sheet, fmt.Sprintf("B%d", row), uid)
	}
	f.SetColWidth(sheet, "A", "A", 12)
	f.SetColWidth(sheet, "B", "B", 30)

	lib.Create_Dir("./ofile")
	fileName := fmt.Sprintf("task_uid_%d.xlsx", time.Now().Unix())
	localPath := "ofile/" + fileName
	if err := f.SaveAs(localPath); err != nil {
		logs.Error("ExportTaskUid SaveAs error:", err)
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "生成Excel失败!"}
		c.ServeJSON()
		return
	}

	if !lib.Pload_qiniu(localPath, localPath) {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "文件上传失败!"}
		c.ServeJSON()
		return
	}
	if err := os.Remove(localPath); err != nil {
		logs.Error("ExportTaskUid remove temp file:", err)
	}

	if err := Task.SaveTaskUids(uidList, exportBatch); err != nil {
		c.Data["json"] = lib.JSONS{Code: 204, Msg: "保存唯一标识失败!"}
		c.ServeJSON()
		return
	}

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

// 获取任务负责人列表
func (c *TaskController) GetTaskUserList() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_type := c.GetString("T_type") // T_project项目 T_scheme方案 T_collection数据采集 T_reporting报告

	list := Task.Get_Task_UserList(T_type)
	AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())

	var User_list []Account.Admin_R
	for _, v := range list {
		if len(v) == 0 {
			continue
		}
		User_list = append(User_list, Account.Admin_R{T_uuid: v, T_name: AdminMap[v]})
	}

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

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

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

	T_name := c.GetString("T_name")
	UserMap := Account.UserListToMap(Account.Read_User_List_ALL_1())
	AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())

	var cnt int
	List, cnt := Task.Read_UserTask_List(User_r.T_uuid, T_name, UserMap, AdminMap, 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 = cnt

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

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

	T_task_id := c.GetString("T_task_id")
	r, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}
	// 添加浏览量
	_ = Task.Add_Task_Visit(r)
	r.T_Visit += 1
	userMap := Account.UserListToMap(Account.Read_User_List_ALL_1())
	adminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: Task.TaskToTask_Stat(r, userMap, adminMap)}
	c.ServeJSON()
	return
}

// 添加-
func (c *TaskController) Add() {

	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	dc := Device.DeviceClass{
		T_uuid:  User_r.T_uuid,
		T_State: 1,
	}
	T_class_id, is := Device.Add_DeviceClass(dc)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加分类失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "分类管理", "添加", dc)

	T_InfoCollection_id := c.GetString("T_InfoCollection_id") // 信息采集id

	T_name := c.GetString("T_name")
	T_uuid := c.GetString("T_uuid") // 用户uuid
	T_VerifyTemplate_class := c.GetString("T_VerifyTemplate_class")
	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")
	T_deadline := c.GetString("T_deadline")
	T_scheme := c.GetString("T_scheme")
	T_collection := c.GetString("T_collection")
	T_reporting := c.GetString("T_reporting")
	T_delivery := c.GetString("T_delivery")

	T_project := c.GetString("T_project")                 // 项目 负责人UUID
	T_province := c.GetString("T_province")               // 省
	T_city := c.GetString("T_city")                       // 市
	T_district := c.GetString("T_district")               // 区
	T_province_code := c.GetString("T_province_code")     // 省 code
	T_city_code := c.GetString("T_city_code")             // 市 code
	T_district_code := c.GetString("T_district_code")     // 区 code
	T_category := c.GetString("T_category")               // 类别
	T_device_type := c.GetString("T_device_type")         // 设备类型
	T_volume := c.GetString("T_volume")                   // 规格/容积
	T_verify_type := c.GetString("T_verify_type")         // 验证类型
	T_subject_matter := c.GetString("T_subject_matter")   // 标的物名称
	T_temp_range := c.GetString("T_temp_range")           // 验证温度范围
	T_report_number := c.GetString("T_report_number")     // 报告编号
	T_report_type := c.GetString("T_report_type")         // 报告类型
	T_device_quantity, _ := c.GetInt("T_device_quantity") // 终端数量
	T_cnas, _ := c.GetInt("T_cnas")                       // cnas实验室

	// 查询信息采集信息
	infoCollection, is := InfoCollection.Read_InfoCollection(T_InfoCollection_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取信息采集失败!"}
		c.ServeJSON()
		return
	}

	// 查询信息采集信息
	user, is := Account.Read_User(T_uuid)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_uuid 错误!"}
		c.ServeJSON()
		return
	}
	var_ := Task.Task{
		T_Distributor_id:       user.T_Distributor_id,
		T_InfoCollection_id:    T_InfoCollection_id,
		T_InfoTemplate_id:      infoCollection.T_InfoTemplate_id,
		T_start_time:           infoCollection.T_start_time, // 项目开始时间使用信息采集开始时间
		T_class:                int(T_class_id),
		T_uuid:                 T_uuid,
		T_name:                 T_name,
		T_VerifyTemplate_class: T_VerifyTemplate_class,
		T_VerifyTemplate_id:    T_VerifyTemplate_id,
		T_deadline:             T_deadline,
		T_scheme:               T_scheme,
		T_collection:           T_collection,
		T_reporting:            T_reporting,
		T_delivery:             T_delivery,
		T_Show:                 1,
		T_State:                1,

		T_project:         T_project,
		T_province:        T_province,
		T_city:            T_city,
		T_district:        T_district,
		T_province_code:   T_province_code,
		T_city_code:       T_city_code,
		T_district_code:   T_district_code,
		T_category:        T_category,
		T_device_type:     T_device_type,
		T_volume:          T_volume,
		T_verify_type:     T_verify_type,
		T_subject_matter:  T_subject_matter,
		T_temp_range:      T_temp_range,
		T_report_number:   T_report_number,
		T_report_type:     T_report_type,
		T_device_quantity: T_device_quantity,
		T_cnas:            T_cnas,
	}
	if T_report_number != "/" {
		_, exist := Task.Read_TaskbyT_report_number(T_report_number)
		if exist {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "报告编号已存在!"}
			c.ServeJSON()
			return
		}
	}

	T_task_id, is := Task.Add_Task(var_)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败!"}
		c.ServeJSON()
		return
	}
	NatsServer.Create_Local_Table(T_task_id)
	Task.Redis_Task_T_report_number_DelK(T_report_number) // 删除redis内的任务编号
	// 通知
	_, company_r := Account.Read_User_ByT_uuid(var_.T_uuid)
	go wx.WxSend(var_.T_scheme, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))
	go wx.WxSend(var_.T_collection, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))
	go wx.WxSend(var_.T_reporting, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))
	go wx.WxSend(var_.T_delivery, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))

	// 同步信息采集表 --------
	InfoCollection_Map_List := InfoCollection.Read_InfoTemplateMap_List_For_Data(var_.T_InfoTemplate_id)
	InfoCollection_Data := InfoCollection.Read_InfoTemplateMapData_List(var_.T_InfoCollection_id, var_.T_InfoTemplate_id, InfoCollection_Map_List)

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

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

	MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)
	for _, v := range Data {
		if len(v.T_value) > 0 {
			continue
		}
		if InfoCollectionDataMap[v.T_name] == "" {
			continue
		}
		val := VerifyTemplate.VerifyTemplateMapData{
			T_source:               v.T_source,
			T_task_id:              T_task_id,
			T_VerifyTemplate_id:    var_.T_VerifyTemplate_id,
			T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,

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

			T_value: InfoCollectionDataMap[v.T_name],
		}
		MapDataList = append(MapDataList, val)
	}
	_, is = VerifyTemplate.AddOrUpdate_VerifyTemplateMapData(MapDataList)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "同步信息采集表失败"}
		c.ServeJSON()
		return
	}
	// 同步信息采集表结束 --------

	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "添加", var_)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "添加", var_)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: T_task_id}
	c.ServeJSON()
	return
}

// 接收信息采集
func (c *TaskController) ReceiptInfoCollection() {

	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	// 修改信息采集状态为已接收
	T_InfoCollection_id := c.GetString("T_InfoCollection_id")
	//T_status,_ := c.GetInt("T_status")
	infoCollection, is := InfoCollection.Read_InfoCollection(T_InfoCollection_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}
	if infoCollection.T_status != InfoCollection.InfoCollectionStatusSubmitted && infoCollection.T_status != InfoCollection.InfoCollectionStatusReceipt {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("当前状态为%s，禁止接收！", InfoCollection.InfoCollectionStatusMap[infoCollection.T_status])}
		c.ServeJSON()
		return
	}
	//infoCollection.T_status = InfoCollection.InfoCollectionStatusReceipt
	//if len(infoCollection.T_end_time) == 0 {
	//	infoCollection.T_end_time = time.Now().Format("2006-01-02 15:04:05")
	//	infoCollection.T_time_interval, _ = lib.MinutesDifference(infoCollection.T_start_time, infoCollection.T_end_time)
	//}

	//if !InfoCollection.Update_InfoCollection(infoCollection, "T_status", "T_end_time", "T_time_interval") {
	infoCollection.T_status = 3 // 已接收
	if !InfoCollection.Update_InfoCollection(infoCollection, "T_status") {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "信息采集管理", "接收信息采集", infoCollection)

	//if T_status == InfoCollection.InfoCollectionStatusReturn{
	//	// 通知 报告负责人审核
	//	_, company_r := Account.Read_User_ByT_uuid(infoCollection.T_uuid)
	//	System.Add_News(conf.VdelUuid, fmt.Sprintf("【%s-%s】信息采集 已退回", company_r.T_name, infoCollection.T_name), "")
	//	go wx.WxSend(conf.VdelUuid, fmt.Sprintf("【%s-%s】信息采集 已退回", company_r.T_name, infoCollection.T_name))
	//
	//}

	// 修改任务管理实施方案开始时间
	//T_task_id := c.GetString("T_task_id")
	//task, is := Task.Read_Task(T_task_id)
	//if !is {
	//	c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
	//	c.ServeJSON()
	//	return
	//}

	// 添加任务操作日志
	//Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "接收信息采集", task)
	//System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "接收信息采集", task)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 添加-
func (c *TaskController) AddData_Tool() {
	T_uuid := "3e84dda9-9eec-42b9-9350-0894262fc8a1" // 用户uuid

	T_name := c.GetString("T_name")
	T_task_id := c.GetString("T_task_id")
	T_task_id = strings.ToLower(T_task_id)

	r, _ := Task.Read_Task(T_task_id)
	if r.T_collection_state == 2 {
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "数据采集中..."}
		c.ServeJSON()
		return
	}
	if r.Id > 0 {
		// 同步1.0数据
		NatsServer.Sync1_TaskData(T_task_id)

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

	dc := Device.DeviceClass{
		T_uuid:  T_uuid,
		T_State: 1,
	}
	T_class_id, is := Device.Add_DeviceClass(dc)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加分类失败!"}
		c.ServeJSON()
		return
	}
	var_ := Task.Task{
		T_task_id:          T_task_id,
		T_class:            int(T_class_id),
		T_uuid:             T_uuid,
		T_name:             T_name,
		T_Show:             1,
		T_State:            1,
		T_collection_state: 2,
	}

	_, is = Task.Add_Task_Tool(var_)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败!"}
		c.ServeJSON()
		return
	}
	// 创建本地表
	NatsServer.Create_Local_Table(T_task_id)
	// 同步1.0数据
	NatsServer.Sync1_TaskData(T_task_id)

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

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

	T_collection_state, _ := c.GetInt("T_collection_state")
	T_reason := c.GetString("T_reason") // 退回原因

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

	r.T_collection_state = T_collection_state
	clos := make([]string, 0)
	clos = append(clos, "T_collection_state")

	if T_collection_state == Task.TaskCollectionStateReturn {
		r.T_collection_return_times += 1
		clos = append(clos, "T_collection_return_times")
	}

	if T_collection_state == Task.TaskCollectionStateSubmitted ||
		T_collection_state == Task.TaskCollectionStateReturn ||
		T_collection_state == Task.TaskCollectionStatePass {
		// 添加已提交状态验证报告记录
		auditRecordJson, err := Task.Add_AuditRecord(r.T_collection_audit_record, "", User_r.T_uuid, T_collection_state, T_reason, "")
		if err != nil {
			return
		}
		r.T_collection_audit_record = auditRecordJson
		clos = append(clos, "T_collection_audit_record")
	}

	if T_collection_state == Task.TaskCollectionStatePass {
		// 数据编辑审核通过时间为验证报告开始时间
		r.T_reporting_start_time = time.Now().Format("2006-01-02 15:04:05")
		clos = append(clos, "T_reporting_start_time")
	}

	if !Task.Update_Task(r, clos...) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	// 已退回(负责人)
	if T_collection_state == Task.TaskCollectionStateReturn {
		System.Add_News(r.T_collection, fmt.Sprintf("【%s-%s】数据编辑 %s,%s", company_r.T_name, r.T_name, Task.TaskCollectionStateMap[T_collection_state], T_reason), "")
		go wx.WxSend(r.T_collection, fmt.Sprintf("【%s-%s】数据编辑 %s,%s", company_r.T_name, r.T_name, Task.TaskCollectionStateMap[T_collection_state], T_reason))
	}

	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "修改采集状态", r)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "修改采集状态", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

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

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

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

	r.T_delivery_state = T_delivery_state

	if !Task.Update_Task(r, "T_delivery_state") {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "修改交付审核状态", r)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "修改交付审核状态", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 更新线上数据后台执行
func (c *TaskDataController) TaskData_Up_TaskData_Back() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

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

	// 通知 报告人员
	_, company_r := Account.Read_User_ByT_uuid(r.T_uuid)
	infoCollection, _ := InfoCollection.Read_InfoCollection(r.T_InfoCollection_id)
	System.Add_News(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】报告已完成，请及时通知客户审核", company_r.T_name, r.T_name), "")
	go wx.WxSend(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】报告已完成，请及时通知客户审核", company_r.T_name, r.T_name))

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

}

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

	T_name := c.GetString("T_name")
	T_Show, T_Show_err := c.GetInt("T_Show")

	T_VerifyTemplate_class := c.GetString("T_VerifyTemplate_class")
	T_VerifyTemplate_id := c.GetString("T_VerifyTemplate_id")
	T_deadline := c.GetString("T_deadline")
	T_scheme := c.GetString("T_scheme")
	T_collection := c.GetString("T_collection")
	T_collection_state, _ := c.GetInt("T_collection_state")
	T_collection_signature := c.GetString("T_collection_signature") // 完成编辑签字图片
	T_reporting := c.GetString("T_reporting")
	T_delivery := c.GetString("T_delivery")
	T_record := c.GetString("T_record")

	T_doc1 := c.GetString("T_doc1")
	T_pdf1 := c.GetString("T_pdf1")              // 方案
	T_pdf1_stamp, _ := c.GetBool("T_pdf1_stamp") // 方案加盖公章
	T_doc2 := c.GetString("T_doc2")
	T_pdf2 := c.GetString("T_pdf2")              // 证书
	T_pdf2_stamp, _ := c.GetBool("T_pdf2_stamp") // 报告加盖公章

	T_doc3 := c.GetString("T_doc3")
	T_pdf3 := c.GetString("T_pdf3")
	T_pdf4 := c.GetString("T_pdf4") // 验证标识
	T_pdf5 := c.GetString("T_pdf5") // 检测报告
	T_pdf6 := c.GetString("T_pdf6") // 原始记录

	T_VerifyDeviceDataStartTime := c.GetString("T_VerifyDeviceDataStartTime") // 验证设备数据开始时间
	T_VerifyDeviceDataEndTime := c.GetString("T_VerifyDeviceDataEndTime")     // 验证设备数据开始时间
	T_BindDeviceDataStartTime := c.GetString("T_BindDeviceDataStartTime")     // 绑定设备数据开始时间
	T_BindDeviceDataEndTime := c.GetString("T_BindDeviceDataEndTime")         // 绑定设备数据结束时间
	T_sn := c.GetString("T_sn")                                               // T_sn
	T_CalibrationExpirationTime := c.GetString("T_CalibrationExpirationTime") // 校准到期时间

	T_project := c.GetString("T_project")                 // 项目 负责人UUID
	T_province := c.GetString("T_province")               // 省
	T_city := c.GetString("T_city")                       // 市
	T_district := c.GetString("T_district")               // 区
	T_province_code := c.GetString("T_province_code")     // 省 code
	T_city_code := c.GetString("T_city_code")             // 市 code
	T_district_code := c.GetString("T_district_code")     // 区 code
	T_category := c.GetString("T_category")               // 类别
	T_device_type := c.GetString("T_device_type")         // 设备类型
	T_volume := c.GetString("T_volume")                   // 规格/容积
	T_verify_type := c.GetString("T_verify_type")         // 验证类型
	T_subject_matter := c.GetString("T_subject_matter")   // 标的物名称
	T_temp_range := c.GetString("T_temp_range")           // 验证温度范围
	T_report_number := c.GetString("T_report_number")     // 报告编号
	T_report_type := c.GetString("T_report_type")         // 报告编号
	T_device_quantity, _ := c.GetInt("T_device_quantity") // 报告编号
	T_cnas, _ := c.GetInt("T_cnas")                       // cnas实验室

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

	if len(T_report_number) > 0 && T_report_number != "/" {
		t, exist := Task.Read_TaskbyT_report_number(T_report_number)
		if exist && r.T_task_id != t.T_task_id {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "报告编号已存在!"}
			c.ServeJSON()
			return
		}
	}

	// .......
	clos := make([]string, 0)
	if len(T_name) > 0 {
		r.T_name = T_name
		clos = append(clos, "T_name")
	}
	if T_Show_err == nil {
		r.T_Show = T_Show
		clos = append(clos, "T_Show")
	}
	if len(T_VerifyTemplate_class) > 0 {
		r.T_VerifyTemplate_class = T_VerifyTemplate_class
		clos = append(clos, "T_VerifyTemplate_class")
	}
	if len(T_VerifyTemplate_id) > 0 {
		// 保存旧的 T_VerifyTemplate_id
		old_T_VerifyTemplate_id := r.T_VerifyTemplate_id
		// 判断旧的模版id与新模版id是否一致，如果不一致则复制旧模板数据到新模板
		if old_T_VerifyTemplate_id != T_VerifyTemplate_id && len(old_T_VerifyTemplate_id) > 0 {
			// 创建新任务对象用于复制数据
			new_task := r
			new_task.T_VerifyTemplate_id = T_VerifyTemplate_id
			_, err := CopyMapData(r, new_task, 0)
			if err != nil {
				logs.Error("复制旧模板数据到新模板失败", err)
			}
		}
		r.T_VerifyTemplate_id = T_VerifyTemplate_id
		clos = append(clos, "T_VerifyTemplate_id")
	}
	if len(T_deadline) > 0 {
		r.T_deadline = T_deadline
		clos = append(clos, "T_deadline")
	}

	if len(T_scheme) > 0 {
		r.T_scheme = T_scheme
		clos = append(clos, "T_scheme")
	}
	if len(T_collection) > 0 {
		r.T_collection = T_collection
		clos = append(clos, "T_collection")
	}
	if len(T_reporting) > 0 {
		r.T_reporting = T_reporting
		clos = append(clos, "T_reporting")
	}
	if len(T_delivery) > 0 {
		r.T_delivery = T_delivery
		clos = append(clos, "T_delivery")
	}
	if len(T_record) > 0 {
		r.T_record = T_record
		clos = append(clos, "T_record")
	}

	// 完成编辑后设置实施结束时间
	if T_collection_state == 4 {
		r.T_collection_state = T_collection_state
		clos = append(clos, "T_collection_state")
		r.T_collection_signature = T_collection_signature
		clos = append(clos, "T_collection_signature")
		r.T_collection_end_time = time.Now().Format("2006-01-02 15:04:05")
		clos = append(clos, "T_collection_end_time")
		if len(r.T_collection_start_time) > 0 {
			r.T_collection_time_interval, _ = lib.MinutesDifference(r.T_collection_start_time, r.T_collection_end_time)
			// 扣除暂停时间
			Task_Compute := Task.Read_TaskTime_Compute(r.T_task_id, 1)
			if Task_Compute > 0 {
				r.T_collection_time_interval -= float64(Task_Compute)
			}

			clos = append(clos, "T_collection_time_interval")
			// 所需时间 > 超时时间
			if r.T_collection_time_interval > Task.TaskCollectionTimeLimit && len(r.T_report_type) > 0 {
				r.T_collection_overtime = r.T_collection_time_interval - Task.TaskCollectionTimeLimit // 超时时间
				clos = append(clos, "T_collection_overtime")
			}

			// 通知 报告人员
			_, company_r := Account.Read_User_ByT_uuid(r.T_uuid)
			System.Add_News(r.T_reporting, fmt.Sprintf("【%s-%s】数据采集 已提交", company_r.T_name, r.T_name), "")
			go wx.WxSend(r.T_reporting, fmt.Sprintf("【%s-%s】数据采集 已提交", company_r.T_name, r.T_name))

		}
		// 添加已提交状态数据编辑记录
		auditRecordJson, err := Task.Add_AuditRecord(r.T_collection_audit_record, "", User_r.T_uuid, r.T_collection_state, "", "")
		if err == nil {
			r.T_collection_audit_record = auditRecordJson
			clos = append(clos, "T_collection_audit_record")
		}
	}

	if len(T_doc1) > 0 {
		r.T_doc1 = T_doc1
		clos = append(clos, "T_doc1")
	}
	// 验证报告内容T_pdf1，上传后将 当前任务 验证方案 标志 为 5 (0未完成 1已完成(客户通过) 2已退回(客户) 3已通过(报告负责人) 4已退回(报告负责人) 5已提交)
	// 上传后设置方案结束时间，计算所需时间和超时时间
	if len(T_pdf1) > 0 {
		r.T_pdf1 = T_pdf1
		clos = append(clos, "T_pdf1")
		//r.T_pdf1_watermark = GetWatermarkPdf(r,T_pdf1,"T_pdf1")
		//clos = append(clos, "T_pdf1_watermark")
		go GetWatermarkPdf(r, T_pdf1, T_pdf1_stamp, "T_pdf1")
		r.T_scheme_state = 5
		clos = append(clos, "T_scheme_state")
		// 添加已提交状态验证方案记录
		auditRecordJson, err := Task.Add_AuditRecord(r.T_scheme_audit_record, "", User_r.T_uuid, r.T_scheme_state, "", "")
		if err != nil {
			return
		}
		r.T_scheme_audit_record = auditRecordJson
		clos = append(clos, "T_scheme_audit_record")
		r.T_scheme_end_time = time.Now().Format("2006-01-02 15:04:05")
		clos = append(clos, "T_scheme_end_time")

		r.T_scheme_time_interval, _ = lib.MinutesDifference(r.T_scheme_start_time, r.T_scheme_end_time)
		Task_Compute := Task.Read_TaskTime_Compute(r.T_task_id, 0)
		if Task_Compute > 0 {
			r.T_scheme_time_interval -= float64(Task_Compute)
		}
		clos = append(clos, "T_scheme_time_interval")

		// 所需时间 > 超时时间
		if r.T_scheme_time_interval > Task.TaskSchemeTimeLimit[r.T_report_type] && len(r.T_report_type) > 0 {
			r.T_scheme_overtime = r.T_scheme_time_interval - Task.TaskSchemeTimeLimit[r.T_report_type] // 超时时间
			if Task.TaskSchemeTimeLimit[r.T_report_type] == 0 {
				r.T_scheme_overtime = 0
			}
			clos = append(clos, "T_scheme_overtime")
		}

		// 通知 实施人员进场
		_, company_r := Account.Read_User_ByT_uuid(r.T_uuid)
		System.Add_News(r.T_collection, fmt.Sprintf("【%s-%s】验证方案 已提交", company_r.T_name, r.T_name), "")
		go wx.WxSend(r.T_collection, fmt.Sprintf("【%s-%s】验证方案 已提交", company_r.T_name, r.T_name))

	}
	if len(T_doc2) > 0 {
		r.T_doc2 = T_doc2
		clos = append(clos, "T_doc2")
	}
	// 验证报告内容T_pdf2 ，上传后将 当前任务 报告编写 标志 为 1
	// 上传后设置报告结束时间，计算所需时间和超时时间
	if len(T_pdf2) > 0 {
		r.T_pdf2 = T_pdf2
		clos = append(clos, "T_pdf2")
		//r.T_pdf2_watermark = GetWatermarkPdf(T_pdf2,"T_pdf1")
		//clos = append(clos, "T_pdf2_watermark")
		go GetWatermarkPdf(r, T_pdf2, T_pdf2_stamp, "T_pdf2")

		r.T_reporting_state = 5
		r.T_reporting_submit_time = time.Now().Format("2006-01-02 15:04:05")
		clos = append(clos, "T_reporting_state", "T_reporting_submit_time")
		// 添加已提交状态验证报告记录
		auditRecordJson, err := Task.Add_AuditRecord(r.T_reporting_audit_record, "", User_r.T_uuid, r.T_reporting_state, "", "")
		if err == nil {
			r.T_reporting_audit_record = auditRecordJson
			clos = append(clos, "T_reporting_audit_record")
			r.T_reporting_end_time = time.Now().Format("2006-01-02 15:04:05")
			clos = append(clos, "T_reporting_end_time")
			if len(r.T_reporting_start_time) > 0 {
				r.T_reporting_time_interval, _ = lib.MinutesDifference(r.T_reporting_start_time, r.T_reporting_end_time)
				clos = append(clos, "T_reporting_time_interval")
				// 扣除暂停时间
				Task_Compute := Task.Read_TaskTime_Compute(r.T_task_id, 2)
				if Task_Compute > 0 {
					r.T_reporting_time_interval -= float64(Task_Compute)
				}
				clos = append(clos, "T_reporting_time_interval")
				// 所需时间 > 超时时间
				if r.T_reporting_time_interval > Task.TaskReportingTimeLimit[r.T_report_type] && len(r.T_report_type) > 0 {
					r.T_reporting_overtime = r.T_reporting_time_interval - Task.TaskReportingTimeLimit[r.T_report_type] // 超时时间
					if Task.TaskReportingTimeLimit[r.T_report_type] == 0 {
						r.T_reporting_overtime = 0
					}
					clos = append(clos, "T_reporting_overtime")
				}

			}
		}

		// 通知 报告人员
		_, company_r := Account.Read_User_ByT_uuid(r.T_uuid)
		System.Add_News(r.T_delivery, fmt.Sprintf("【%s-%s】验证报告 已提交", company_r.T_name, r.T_name), "")
		go wx.WxSend(r.T_delivery, fmt.Sprintf("【%s-%s】验证报告 已提交", company_r.T_name, r.T_name))

	}
	if len(T_doc3) > 0 {
		r.T_doc3 = T_doc3
		clos = append(clos, "T_doc3")
	}
	if len(T_pdf3) > 0 {
		r.T_pdf3 = T_pdf3
		clos = append(clos, "T_pdf3")
	}
	// 验证标识内容T_pdf4 ，上传后将 当前任务 验证标识 标志 为 1
	if len(T_pdf4) > 0 {
		r.T_pdf4 = T_pdf4
		clos = append(clos, "T_pdf4")
		r.T_marking_state = 1
		clos = append(clos, "T_marking_state")
	}
	if len(T_pdf5) > 0 {
		r.T_pdf5 = T_pdf5
		clos = append(clos, "T_pdf5")
		r.T_examining_report_state = 1
		clos = append(clos, "T_examining_report_state")
		// 添加已提交状态 检测报告记录
		auditRecordJson, err := Task.Add_AuditRecord(r.T_examining_report_audit_record, "", User_r.T_uuid, r.T_examining_report_state, "", "")
		if err == nil {
			r.T_examining_report_audit_record = auditRecordJson
			clos = append(clos, "T_examining_report_audit_record")
			r.T_examining_report_end_time = time.Now().Format("2006-01-02 15:04:05")
			clos = append(clos, "T_examining_report_end_time")
			if len(r.T_examining_report_start_time) > 0 {
				r.T_examining_report_time_interval, _ = lib.MinutesDifference(r.T_examining_report_start_time, r.T_examining_report_end_time)
				clos = append(clos, "T_examining_report_time_interval")
				// 扣除暂停时间
				Task_Compute := Task.Read_TaskTime_Compute(r.T_task_id, 3)
				if Task_Compute > 0 {
					r.T_examining_report_time_interval -= float64(Task_Compute)
				}
				clos = append(clos, "T_examining_report_time_interval")

			}
		}

		// 通知 报告人员
		_, company_r := Account.Read_User_ByT_uuid(r.T_uuid)
		System.Add_News(r.T_delivery, fmt.Sprintf("【%s-%s】检测报告 已提交", company_r.T_name, r.T_name), "")
		go wx.WxSend(r.T_delivery, fmt.Sprintf("【%s-%s】检测报告 已提交", company_r.T_name, r.T_name))
	}
	if len(T_pdf6) > 0 {
		r.T_pdf6 = T_pdf6
		clos = append(clos, "T_pdf6")
		r.T_examining_report_state = 1
		clos = append(clos, "T_original_record_state")
		// 添加已提交状态 原始记录 记录
		auditRecordJson, err := Task.Add_AuditRecord(r.T_original_record_audit_record, "", User_r.T_uuid, r.T_original_record_state, "", "")
		if err == nil {
			r.T_original_record_audit_record = auditRecordJson
			clos = append(clos, "T_original_record_audit_record")
			r.T_original_record_end_time = time.Now().Format("2006-01-02 15:04:05")
			clos = append(clos, "T_original_record_end_time")
			if len(r.T_reporting_start_time) > 0 {
				r.T_original_record_time_interval, _ = lib.MinutesDifference(r.T_original_record_start_time, r.T_original_record_end_time)
				clos = append(clos, "T_original_record_time_interval")
				// 扣除暂停时间
				Task_Compute := Task.Read_TaskTime_Compute(r.T_task_id, 2)
				if Task_Compute > 0 {
					r.T_original_record_time_interval -= float64(Task_Compute)
				}
				clos = append(clos, "T_original_record_time_interval")

			}
		}

		// 通知 报告人员
		_, company_r := Account.Read_User_ByT_uuid(r.T_uuid)
		System.Add_News(r.T_delivery, fmt.Sprintf("【%s-%s】原始记录 已提交", company_r.T_name, r.T_name), "")
		go wx.WxSend(r.T_delivery, fmt.Sprintf("【%s-%s】原始记录 已提交", company_r.T_name, r.T_name))
	}

	if len(T_VerifyDeviceDataStartTime) > 0 {
		r.T_VerifyDeviceDataStartTime = T_VerifyDeviceDataStartTime
		clos = append(clos, "T_VerifyDeviceDataStartTime")
	}
	if len(T_VerifyDeviceDataEndTime) > 0 {
		r.T_VerifyDeviceDataEndTime = T_VerifyDeviceDataEndTime
		clos = append(clos, "T_VerifyDeviceDataEndTime")
	}
	if len(T_BindDeviceDataStartTime) > 0 {
		r.T_BindDeviceDataStartTime = T_BindDeviceDataStartTime
		clos = append(clos, "T_BindDeviceDataStartTime")
	}
	if len(T_BindDeviceDataEndTime) > 0 {
		r.T_BindDeviceDataEndTime = T_BindDeviceDataEndTime
		clos = append(clos, "T_BindDeviceDataEndTime")
	}
	if len(T_sn) > 0 {
		T_sn = strings.TrimSpace(T_sn)
		r.T_sn = T_sn
		clos = append(clos, "T_sn")
	}
	if len(T_CalibrationExpirationTime) > 0 {
		r.T_CalibrationExpirationTime = T_CalibrationExpirationTime
		clos = append(clos, "T_CalibrationExpirationTime")
	}

	// 从3.0获取校准时间
	if len(T_sn) > 0 && len(T_CalibrationExpirationTime) == 0 {

		go func(r Task.Task, T_sn, T_CalibrationExpirationTime string) {
			NatsServer.Cold_UpdateDevice_CalibrationTime(T_sn, T_CalibrationExpirationTime)
			device, err := NatsServer.Cold_ReadDeviceByT_sn(T_sn)
			if err == nil {
				if !device.T_CalibrationTime.IsZero() {
					r.T_CalibrationExpirationTime = device.T_CalibrationTime.Format("2006-01-02")
					clos = append(clos, "T_CalibrationExpirationTime")
					Task.Update_Task(r, "T_CalibrationExpirationTime")
				}
			}
		}(r, T_sn, T_CalibrationExpirationTime)

	}

	if len(T_project) > 0 {
		r.T_project = T_project
		clos = append(clos, "T_project")
	}
	if len(T_province) > 0 {
		r.T_province = T_province
		clos = append(clos, "T_province")
	}
	if len(T_city) > 0 {
		r.T_city = T_city
		clos = append(clos, "T_city")
	}
	if len(T_district) > 0 {
		r.T_district = T_district
		clos = append(clos, "T_district")
	}
	if len(T_province_code) > 0 {
		r.T_province_code = T_province_code
		clos = append(clos, "T_province_code")
	}
	if len(T_city_code) > 0 {
		r.T_city_code = T_city_code
		clos = append(clos, "T_city_code")
	}
	if len(T_district_code) > 0 {
		r.T_district_code = T_district_code
		clos = append(clos, "T_district_code")
	}
	if len(T_category) > 0 {
		r.T_category = T_category
		clos = append(clos, "T_category")
	}
	if len(T_device_type) > 0 {
		r.T_device_type = T_device_type
		clos = append(clos, "T_device_type")
	}
	if len(T_volume) > 0 {
		r.T_volume = T_volume
		clos = append(clos, "T_volume")
	}
	if len(T_verify_type) > 0 {
		r.T_verify_type = T_verify_type
		clos = append(clos, "T_verify_type")
	}
	if len(T_subject_matter) > 0 {
		r.T_subject_matter = T_subject_matter
		clos = append(clos, "T_subject_matter")
	}
	if len(T_temp_range) > 0 {
		r.T_temp_range = T_temp_range
		clos = append(clos, "T_temp_range")
	}
	if len(T_report_number) > 0 {
		r.T_report_number = T_report_number
		clos = append(clos, "T_report_number")
	}
	if len(T_report_type) > 0 {
		r.T_report_type = T_report_type
		clos = append(clos, "T_report_type")
	}
	if T_device_quantity > 0 {
		r.T_device_quantity = T_device_quantity
		clos = append(clos, "T_device_quantity")
	}

	r.T_cnas = T_cnas
	clos = append(clos, "T_cnas")

	if !Task.Update_Task(r, clos...) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "修改", r)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "修改", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

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

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

	T_InfoCollection_id := c.GetString("T_InfoCollection_id") // 信息采集id

	// 查询信息采集信息
	infoCollection, is := InfoCollection.Read_InfoCollection(T_InfoCollection_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取信息采集失败!"}
		c.ServeJSON()
		return
	}

	r.T_InfoCollection_id = T_InfoCollection_id
	r.T_InfoTemplate_id = infoCollection.T_InfoTemplate_id
	r.T_start_time = infoCollection.T_start_time // 项目开始时间使用信息采集开始时间

	if !Task.Update_Task(r, "T_InfoCollection_id", "T_InfoTemplate_id", "T_start_time") {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "修改信息采集id", r)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "修改信息采集id", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

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

	T_task_id := c.GetString("T_task_id")
	new_T_uuid := c.GetString("T_uuid") // 新公司UUID

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

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

	// 查询任务
	task, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "任务不存在!"}
		c.ServeJSON()
		return
	}

	// 查询原公司信息
	oldUser, is := Account.Read_User(task.T_uuid)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "原公司信息不存在!"}
		c.ServeJSON()
		return
	}

	// 查询新公司信息
	newUser, is := Account.Read_User(new_T_uuid)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "新公司信息不存在!"}
		c.ServeJSON()
		return
	}

	// 查询信息采集
	var infoCollection InfoCollection.InfoCollection
	if len(task.T_InfoCollection_id) > 0 {
		infoCollection, is = InfoCollection.Read_InfoCollection(task.T_InfoCollection_id)
		if !is {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "信息采集不存在!"}
			c.ServeJSON()
			return
		}
	} else {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "任务没有关联信息采集!"}
		c.ServeJSON()
		return
	}

	var newInfoCollection InfoCollection.InfoCollection
	var newInfoCollectionId string

	// 判断信息采集名称是否和原公司名称相同
	if infoCollection.T_name == oldUser.T_name {
		// 如果信息采集名称和原公司名称相同，查询新公司下与新公司同名的信息采集
		newInfoCollection, is = InfoCollection.Read_InfoCollection_By_T_uuid_Name(new_T_uuid, newUser.T_name)
		if !is {
			// 如果不存在，创建新公司下的信息采集（使用新公司名称）
			var err error
			newInfoCollection, err = InfoCollection.GetOrCreate_InfoCollection(new_T_uuid, newUser.T_name)
			if err != nil {
				c.Data["json"] = lib.JSONS{Code: 202, Msg: "创建信息采集失败: " + err.Error()}
				c.ServeJSON()
				return
			}
		}
		newInfoCollectionId = newInfoCollection.T_InfoCollection_id
	} else {
		// 如果信息采集名称和原公司名称不相同，查询新公司下有没有同名的信息采集
		newInfoCollection, is = InfoCollection.Read_InfoCollection_By_T_uuid_Name(new_T_uuid, infoCollection.T_name)
		if !is {
			// 如果不存在，创建新公司下的信息采集（使用原信息采集名称）
			var err error
			newInfoCollection, err = InfoCollection.GetOrCreate_InfoCollection(new_T_uuid, infoCollection.T_name)
			if err != nil {
				c.Data["json"] = lib.JSONS{Code: 202, Msg: "创建信息采集失败: " + err.Error()}
				c.ServeJSON()
				return
			}
		}
		newInfoCollectionId = newInfoCollection.T_InfoCollection_id
	}

	// 更新任务的公司和信息采集
	task.T_uuid = new_T_uuid
	task.T_InfoCollection_id = newInfoCollectionId
	if newInfoCollection.T_InfoTemplate_id != "" {
		task.T_InfoTemplate_id = newInfoCollection.T_InfoTemplate_id
	}

	// 更新新公司的分销商ID
	if newUser.T_Distributor_id != "" {
		task.T_Distributor_id = newUser.T_Distributor_id
	}

	// 更新任务
	updateCols := []string{"T_uuid", "T_InfoCollection_id", "T_InfoTemplate_id"}
	if newUser.T_Distributor_id != "" {
		updateCols = append(updateCols, "T_Distributor_id")
	}

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

	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "修改任务公司", task)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "修改任务公司", task)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 保存电子签名pdf
func (c *TaskController) SaveElectronicSignaturePDF() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_pdf1 := c.GetString("T_pdf1") // 方案
	T_pdf2 := c.GetString("T_pdf2") // 证书

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

	// .......
	clos := make([]string, 0)
	// 验证报告内容T_pdf1，上传后将 当前任务 验证方案 标志 为 5 (0未完成 1已完成(客户通过) 2已退回(客户) 3已通过(报告负责人) 4已退回(报告负责人) 5已提交)
	// 上传后设置方案结束时间，计算所需时间和超时时间
	if len(T_pdf1) > 0 {
		r.T_pdf1_elec_signature = T_pdf1
		clos = append(clos, "T_pdf1")
		go GetWatermarkPdf(r, T_pdf1, false, "T_pdf1")
	}

	// 验证报告内容T_pdf2 ，上传后将 当前任务 报告编写 标志 为 1
	// 上传后设置报告结束时间，计算所需时间和超时时间
	if len(T_pdf2) > 0 {
		r.T_pdf1_elec_signature = T_pdf2
		clos = append(clos, "T_pdf2")
		go GetWatermarkPdf(r, T_pdf2, false, "T_pdf2")

	}

	if !Task.Update_Task(r, clos...) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "保存电子签名方案/报告", r)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "保存电子签名方案/报告", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 修改验证方案状态
func (c *TaskController) UpSchemeState() {
	Admin_r, Admin_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	User_r, User_is := Account.Verification(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !Admin_is && !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	operate_uuid := ""
	if Admin_is {
		operate_uuid = Admin_r.T_uuid
	}
	if User_is {
		operate_uuid = User_r.T_uuid
	}

	T_scheme_state, _ := c.GetInt("T_scheme_state") // 1 已完成(客户通过) 5已退回(客户) 3已通过(报告负责人) 4已退回(报告负责人)
	T_reason := c.GetString("T_reason")             // 退回原因
	T_signature := c.GetString("T_signature")       // 通过后客户签名图片链接

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

	clos := make([]string, 0)
	if T_scheme_state > 0 {
		r.T_scheme_state = T_scheme_state
		clos = append(clos, "T_scheme_state")
	}
	if len(T_signature) > 0 {
		r.T_scheme_signature = T_signature
		clos = append(clos, "T_scheme_signature")
	}

	if T_scheme_state == Task.TaskSchemeStateClientReturn || T_scheme_state == Task.TaskSchemeStateReturn {
		r.T_scheme_return_times += 1
		clos = append(clos, "T_scheme_return_times")
		// 客户退回时新增驳回次数和驳回记录
		if T_scheme_state == Task.TaskSchemeStateClientReturn {
			r.T_reject_times += 1
			var rejectRecordList []Task.AuditRecord
			if len(r.T_reject_record) > 0 {
				err := json.Unmarshal([]byte(r.T_reject_record), &rejectRecordList)
				if err != nil {
					logs.Error("JSON 反序列化失败:", err)
					return
				}
			}

			rejectRecordList = append(rejectRecordList, Task.AuditRecord{
				T_uuid:   User_r.T_uuid,
				T_state:  T_scheme_state,
				T_reason: T_reason,
				T_time:   time.Now().Format("2006-01-02 15:04:05"),
				T_type:   "scheme",
			})
			rejectRecordJson, err := json.Marshal(rejectRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
			r.T_reject_record = string(rejectRecordJson)
			clos = append(clos, "T_reject_times")
			clos = append(clos, "T_reject_record")
		}

	}

	auditRecordJson, err := Task.Add_AuditRecord(r.T_scheme_audit_record, User_r.T_uuid, Admin_r.T_uuid, T_scheme_state, T_reason, "")
	if err != nil {
		return
	}
	r.T_scheme_audit_record = auditRecordJson
	clos = append(clos, "T_scheme_audit_record")

	if !Task.Update_Task(r, clos...) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	//AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())
	// 已提交
	if T_scheme_state == Task.TaskSchemeStateSubmitted {
		System.Add_News(r.T_collection, fmt.Sprintf("【%s-%s】验证方案 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state]), "")
		go wx.WxSend(r.T_collection, fmt.Sprintf("【%s-%s】验证方案 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state]))
	}

	// 已通过
	if T_scheme_state == Task.TaskSchemeStatePass {
		infoCollection, _ := InfoCollection.Read_InfoCollection(r.T_InfoCollection_id)
		System.Add_News(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】验证方案 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state]), "")
		go wx.WxSend(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】验证方案 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state]))
	}

	// 已退回(负责人)
	if T_scheme_state == Task.TaskSchemeStateReturn {
		System.Add_News(r.T_scheme, fmt.Sprintf("【%s-%s】验证方案 %s,%s", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state], T_reason), "")
		go wx.WxSend(r.T_scheme, fmt.Sprintf("【%s-%s】验证方案 %s,%s", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state], T_reason))
	}

	//  已退回(客户)
	if T_scheme_state == Task.TaskSchemeStateClientReturn {
		System.Add_News(r.T_scheme, fmt.Sprintf("！！！【%s-%s】验证方案 %s,%s", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state], T_reason), "")
		go wx.WxSend(r.T_scheme, fmt.Sprintf("！！！【%s-%s】验证方案 %s,%s", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state], T_reason))

		System.Add_News(conf.VdelUuid, fmt.Sprintf("！！！【%s-%s】验证方案 %s,%s", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state], T_reason), "")
		go wx.WxSend(conf.VdelUuid, fmt.Sprintf("！！！【%s-%s】验证方案 %s,%s", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state], T_reason))

		go wx.WxSend(conf.BoosUuid, fmt.Sprintf("！！！【%s-%s】验证方案 %s,%s", company_r.T_name, r.T_name, Task.TaskSchemeStateMap[T_scheme_state], T_reason))
	}

	// 添加任务操作日志
	Task.Add_TaskLogs_T(operate_uuid, T_task_id, "任务管理", "修改验证方案状态", r)
	System.Add_UserLogs_T(operate_uuid, "任务管理", "修改验证方案状态", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 修改验证报告状态
func (c *TaskController) UpReportingState() {
	Admin_r, Admin_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	User_r, User_is := Account.Verification(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !Admin_is && !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	operate_uuid := ""
	if Admin_is {
		operate_uuid = Admin_r.T_uuid
	}
	if User_is {
		operate_uuid = User_r.T_uuid
	}

	T_reporting_state, _ := c.GetInt("T_reporting_state") // 1 已完成(客户通过) 5已退回(客户) 3已通过(报告负责人) 4已退回(报告负责人)
	T_reason := c.GetString("T_reason")                   // 退回原因
	T_signature := c.GetString("T_signature")             // 通过后客户签名图片链接

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

	clos := make([]string, 0)
	if T_reporting_state > 0 {
		r.T_reporting_state = T_reporting_state
		clos = append(clos, "T_reporting_state")
	}
	if T_reporting_state == Task.TaskReportingStatePass {
		r.T_reporting_pass_time = time.Now().Format("2006-01-02 15:04:05")
		clos = append(clos, "T_reporting_pass_time")
	}
	if len(T_signature) > 0 {
		r.T_reporting_signature = T_signature
		clos = append(clos, "T_reporting_signature")
	}

	if T_reporting_state == Task.TaskReportingStateClientReturn || T_reporting_state == Task.TaskReportingStateReturn {
		r.T_reporting_return_times += 1
		clos = append(clos, "T_reporting_return_times")
		// 客户退回时新增驳回次数和驳回记录
		if T_reporting_state == Task.TaskReportingStateClientReturn {
			r.T_reject_times += 1
			var rejectRecordList []Task.AuditRecord
			if len(r.T_reject_record) > 0 {
				err := json.Unmarshal([]byte(r.T_reject_record), &rejectRecordList)
				if err != nil {
					logs.Error("JSON 反序列化失败:", err)
					return
				}
			}

			rejectRecordList = append(rejectRecordList, Task.AuditRecord{
				T_uuid:   User_r.T_uuid,
				T_state:  T_reporting_state,
				T_reason: T_reason,
				T_time:   time.Now().Format("2006-01-02 15:04:05"),
				T_type:   "reporting",
			})
			rejectRecordJson, err := json.Marshal(rejectRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
			r.T_reject_record = string(rejectRecordJson)
			clos = append(clos, "T_reject_times")
			clos = append(clos, "T_reject_record")
		}

	}

	auditRecordJson, err := Task.Add_AuditRecord(r.T_reporting_audit_record, User_r.T_uuid, Admin_r.T_uuid, T_reporting_state, T_reason, "")
	if err != nil {
		return
	}

	r.T_reporting_audit_record = auditRecordJson

	clos = append(clos, "T_reporting_audit_record")
	// 查询信息采集信息
	infoCollection, is := InfoCollection.Read_InfoCollection(r.T_InfoCollection_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取信息采集失败!"}
		c.ServeJSON()
		return
	}
	// 验证报告客户审核通过后设置结束时间
	if T_reporting_state == Task.TaskReportingStateClientPass {
		r.T_end_time = time.Now().Format("2006-01-02 15:04:05")
		r.T_time_interval, err = lib.MinutesDifference(infoCollection.T_start_time, r.T_end_time)
		if err != nil {
			logs.Error("UpReportingState:", err.Error())
		}
		clos = append(clos, "T_end_time")
		clos = append(clos, "T_time_interval")
	}

	if !Task.Update_Task(r, clos...) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	// 已通过
	if T_reporting_state == Task.TaskReportingStatePass {
		System.Add_News(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】验证报告 %s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state]), "")
		go wx.WxSend(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】验证报告 %s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state]))

		System.Add_News(r.T_reporting, fmt.Sprintf("【%s-%s】验证报告 %s,请及时 打印报告", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state]), "")
		go wx.WxSend(r.T_reporting, fmt.Sprintf("【%s-%s】验证报告 %s,请及时 打印报告", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state]))
	}
	// 已退回
	if T_reporting_state == Task.TaskReportingStateReturn {
		System.Add_News(r.T_reporting, fmt.Sprintf("【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason), "")
		go wx.WxSend(r.T_reporting, fmt.Sprintf("【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason))
	}
	// 已通过(客户)  通知销售
	if T_reporting_state == Task.TaskReportingStateClientPass {
		go wx.WxSend(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】 %s,请尽快安排客户回款", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state]))
	}

	if T_reporting_state == Task.TaskReportingStateClientReturn {
		System.Add_News(r.T_scheme, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason), "")
		go wx.WxSend(r.T_scheme, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason))

		System.Add_News(r.T_collection, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason), "")
		go wx.WxSend(r.T_collection, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason))

		System.Add_News(r.T_reporting, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason), "")
		go wx.WxSend(r.T_reporting, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason))

		//System.Add_News(r.T_delivery, fmt.Sprintf("！！！【%s-%s】验证报告 %s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state]), "")
		//go wx.WxSend(r.T_delivery, fmt.Sprintf("！！！【%s-%s】验证报告 %s", infoCollection.T_name, r.T_name,Task.TaskReportingStateMap[T_reporting_state]))

		System.Add_News(conf.VdelUuid, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason), "")
		go wx.WxSend(conf.VdelUuid, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason))

		go wx.WxSend(conf.BoosUuid, fmt.Sprintf("！！！【%s-%s】验证报告 %s,%s", infoCollection.T_name, r.T_name, Task.TaskReportingStateMap[T_reporting_state], T_reason))
	}

	// 添加任务操作日志
	Task.Add_TaskLogs_T(operate_uuid, T_task_id, "任务管理", "修改验证报告状态", r)
	System.Add_UserLogs_T(operate_uuid, "任务管理", "修改验证报告状态", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 修改检测报告状态
func (c *TaskController) UpExaminingReportState() {
	Admin_r, Admin_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	User_r, User_is := Account.Verification(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !Admin_is && !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	operate_uuid := ""
	if Admin_is {
		operate_uuid = Admin_r.T_uuid
	}
	if User_is {
		operate_uuid = User_r.T_uuid
	}

	T_examining_report_state, _ := c.GetInt("T_examining_report_state") // 1 已完成(客户通过) 5已退回(客户) 3已通过(报告负责人) 4已退回(报告负责人)
	T_reason := c.GetString("T_reason")                                 // 退回原因
	T_signature := c.GetString("T_signature")                           // 通过后客户签名图片链接

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

	clos := make([]string, 0)
	if T_examining_report_state > 0 {
		r.T_examining_report_state = T_examining_report_state
		clos = append(clos, "T_examining_report_state")
	}
	if len(T_signature) > 0 {
		r.T_examining_report_signature = T_signature
		clos = append(clos, "T_examining_report_signature")
	}

	if T_examining_report_state == Task.TaskExaminingReportStateClientReturn || T_examining_report_state == Task.TaskExaminingReportStateReturn {
		r.T_examining_report_return_times += 1
		clos = append(clos, "T_examining_report_return_times")
		// 客户退回时新增驳回次数和驳回记录
		if T_examining_report_state == Task.TaskExaminingReportStateClientReturn {
			r.T_reject_times += 1
			var rejectRecordList []Task.AuditRecord
			if len(r.T_reject_record) > 0 {
				err := json.Unmarshal([]byte(r.T_reject_record), &rejectRecordList)
				if err != nil {
					logs.Error("JSON 反序列化失败:", err)
					return
				}
			}

			rejectRecordList = append(rejectRecordList, Task.AuditRecord{
				T_uuid:   User_r.T_uuid,
				T_state:  T_examining_report_state,
				T_reason: T_reason,
				T_time:   time.Now().Format("2006-01-02 15:04:05"),
				T_type:   "examining_report",
			})
			rejectRecordJson, err := json.Marshal(rejectRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
			r.T_reject_record = string(rejectRecordJson)
			clos = append(clos, "T_reject_times")
			clos = append(clos, "T_reject_record")
		}

	}

	auditRecordJson, err := Task.Add_AuditRecord(r.T_examining_report_audit_record, User_r.T_uuid, Admin_r.T_uuid, T_examining_report_state, T_reason, "")
	if err != nil {
		return
	}
	r.T_examining_report_audit_record = auditRecordJson
	clos = append(clos, "T_examining_report_audit_record")

	if !Task.Update_Task(r, clos...) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	// 已提交
	if T_examining_report_state == Task.TaskExaminingReportStateSubmitted {
		System.Add_News(r.T_collection, fmt.Sprintf("【%s-%s】检测报告 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state]), "")
		go wx.WxSend(r.T_collection, fmt.Sprintf("【%s-%s】检测报告 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state]))
	}

	// 已通过
	if T_examining_report_state == Task.TaskExaminingReportStatePass {
		infoCollection, _ := InfoCollection.Read_InfoCollection(r.T_InfoCollection_id)
		System.Add_News(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】检测报告 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state]), "")
		go wx.WxSend(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】检测报告 %s,请尽快与客户沟通确定", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state]))
	}

	// 已退回(负责人)
	if T_examining_report_state == Task.TaskExaminingReportStateReturn {
		System.Add_News(r.T_scheme, fmt.Sprintf("【%s-%s】检测报告 %s,%s", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state], T_reason), "")
		go wx.WxSend(r.T_scheme, fmt.Sprintf("【%s-%s】检测报告 %s,%s", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state], T_reason))
	}

	//  已退回(客户)
	if T_examining_report_state == Task.TaskExaminingReportStateClientReturn {
		System.Add_News(r.T_scheme, fmt.Sprintf("！！！【%s-%s】检测报告 %s,%s", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state], T_reason), "")
		go wx.WxSend(r.T_scheme, fmt.Sprintf("！！！【%s-%s】检测报告 %s,%s", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state], T_reason))

		System.Add_News(conf.VdelUuid, fmt.Sprintf("！！！【%s-%s】检测报告 %s,%s", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state], T_reason), "")
		go wx.WxSend(conf.VdelUuid, fmt.Sprintf("！！！【%s-%s】检测报告 %s,%s", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state], T_reason))

		go wx.WxSend(conf.BoosUuid, fmt.Sprintf("！！！【%s-%s】检测报告 %s,%s", company_r.T_name, r.T_name, Task.TaskExaminingReportStateMap[T_examining_report_state], T_reason))
	}

	// 添加任务操作日志
	Task.Add_TaskLogs_T(operate_uuid, T_task_id, "任务管理", "修改检测报告状态", r)
	System.Add_UserLogs_T(operate_uuid, "任务管理", "修改检测报告状态", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 修改原始数据状态
func (c *TaskController) UpOriginalRecordState() {
	Admin_r, Admin_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))

	User_r, User_is := Account.Verification(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !Admin_is && !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}
	operate_uuid := ""
	if Admin_is {
		operate_uuid = Admin_r.T_uuid
	}
	if User_is {
		operate_uuid = User_r.T_uuid
	}

	T_original_record_state, _ := c.GetInt("T_original_record_state") // 1 已完成(客户通过) 5已退回(客户) 3已通过(报告负责人) 4已退回(报告负责人)
	T_reason := c.GetString("T_reason")                               // 退回原因
	T_signature := c.GetString("T_signature")                         // 通过后客户签名图片链接

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

	clos := make([]string, 0)
	if T_original_record_state > 0 {
		r.T_original_record_state = T_original_record_state
		clos = append(clos, "T_original_record_state")
	}
	if len(T_signature) > 0 {
		r.T_original_record_signature = T_signature
		clos = append(clos, "T_original_record_signature")
	}

	if T_original_record_state == Task.TaskOriginalRecordStateReturn {
		r.T_original_record_return_times += 1
		clos = append(clos, "T_original_record_return_times")
	}

	auditRecordJson, err := Task.Add_AuditRecord(r.T_original_record_audit_record, User_r.T_uuid, Admin_r.T_uuid, T_original_record_state, T_reason, "")
	if err != nil {
		return
	}
	r.T_original_record_audit_record = auditRecordJson
	clos = append(clos, "T_original_record_audit_record")

	if !Task.Update_Task(r, clos...) {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}

	// 已提交
	if T_original_record_state == Task.TaskOriginalRecordStateSubmitted {
		System.Add_News(r.T_collection, fmt.Sprintf("【%s-%s】原始数据 %s", company_r.T_name, r.T_name, Task.TaskOriginalRecordStateMap[T_original_record_state]), "")
		go wx.WxSend(r.T_collection, fmt.Sprintf("【%s-%s】原始数据 %s", company_r.T_name, r.T_name, Task.TaskOriginalRecordStateMap[T_original_record_state]))
	}

	// 已通过
	if T_original_record_state == Task.TaskOriginalRecordStatePass {
		infoCollection, _ := InfoCollection.Read_InfoCollection(r.T_InfoCollection_id)
		System.Add_News(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】原始数据 %s", company_r.T_name, r.T_name, Task.TaskOriginalRecordStateMap[T_original_record_state]), "")
		go wx.WxSend(infoCollection.T_submit_uuid, fmt.Sprintf("【%s-%s】原始数据 %s", company_r.T_name, r.T_name, Task.TaskOriginalRecordStateMap[T_original_record_state]))
	}

	// 已退回(负责人)
	if T_original_record_state == Task.TaskOriginalRecordStateReturn {
		System.Add_News(r.T_scheme, fmt.Sprintf("【%s-%s】原始数据 %s,%s", company_r.T_name, r.T_name, Task.TaskOriginalRecordStateMap[T_original_record_state], T_reason), "")
		go wx.WxSend(r.T_scheme, fmt.Sprintf("【%s-%s】原始数据 %s,%s", company_r.T_name, r.T_name, Task.TaskOriginalRecordStateMap[T_original_record_state], T_reason))
	}

	// 添加任务操作日志
	Task.Add_TaskLogs_T(operate_uuid, T_task_id, "任务管理", "修改原始数据状态", r)
	System.Add_UserLogs_T(operate_uuid, "任务管理", "修改原始数据状态", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 进场  改成 方案开始
func (c *TaskController) EnterArea() {
	// 验证登录 User_is, User_r
	User_r, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

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

	// 方案开始
	if len(r.T_scheme_start_time) == 0 {
		r.T_scheme_start_time = time.Now().Format("2006-01-02 15:04:05")
		Task.Update_Task(r, "T_scheme_start_time")
	}

	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "方案开始", r)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "方案开始", r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

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

	T_task_id := c.GetString("T_task_id")
	T_time := c.GetString("T_time") // 进场时间
	r, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}

	if len(r.T_collection_start_time) == 0 {
		r.T_collection_start_time = T_time
		if !Task.Update_Task(r, "T_collection_start_time") {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改实施开始时间失败!"}
			c.ServeJSON()
			return
		}
		// 添加任务操作日志
		Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "开始验证", r)
		System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "开始验证", r)
	}

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

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

	T_task_id := c.GetString("T_task_id")
	if r, is := Task.Read_Task(T_task_id); is {
		if !Task.Delete_Task(r) {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败！"}
			c.ServeJSON()
			return
		}
		// 添加任务操作日志
		Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务管理", "删除", r)
		System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "删除", r)
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
		c.ServeJSON()
		return
	}

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

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

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

	T_task_id := c.GetString("T_task_id")

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

	var cnt int
	List, cnt := Task.Read_TaskLogs_List(T_task_id, AdminMap, 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 = cnt

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

// 查询图片生成状态
func (c *TaskController) DeviceData_JPGState() {

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

// 生成温度图片
func (c *TaskController) DeviceData_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
		}
	} else {
		EndTime = time.Now().Format("2006-01-02 15:04:05")
	}
	T_remark := c.GetString("T_remark")

	TemperatureMin, _ := c.GetFloat("TemperatureMin") // 最低温度
	TemperatureMax, _ := c.GetFloat("TemperatureMax") // 最高温度
	if TemperatureMin == 0 {
		TemperatureMin = 2
	}
	if TemperatureMax == 0 {
		TemperatureMax = 8
	}

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

	deviceClassList, _ := Device.Read_DeviceClassList_OrderList(Task_r.T_class, "", "", T_remark, 0, 9999)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_class 错误!"}
		c.ServeJSON()
		return
	}

	Device.Redis_DeviceDataJPG_Del(T_task_id + T_remark)

	// 生成图片
	go DeviceDataJPG(StartTime, EndTime, T_task_id, T_remark, deviceClassList, TemperatureMin, TemperatureMax)

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

// SyncInfoCollection 同步信息采集表
func (c *TaskController) SyncInfoCollection() {
	T_task_id := c.GetString("T_task_id")
	T_source, _ := c.GetInt("T_source")
	task, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}

	// 获取信息采集表模版信息
	InfoCollection_Map_List := InfoCollection.Read_InfoTemplateMap_List_For_Data(task.T_InfoTemplate_id)
	InfoCollection_Data := InfoCollection.Read_InfoTemplateMapData_List(task.T_InfoCollection_id, task.T_InfoTemplate_id, InfoCollection_Map_List)

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

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

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

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

			T_value: InfoCollectionDataMap[v.T_name],
		}
		MapDataList = append(MapDataList, val)
	}
	var ids []int64
	ids, is = VerifyTemplate.AddOrUpdate_VerifyTemplateMapData(MapDataList)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "保存失败"}
		c.ServeJSON()
		return
	}

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

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

	T_task_id := c.GetString("T_task_id")
	T_type := c.GetString("T_type") // T_task任务 T_scheme方案 T_collection数据采集 T_reporting报告
	//T_task       驳回记录
	//T_scheme     实施方案状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	//T_collection 数据采集状态 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4-数据编辑已完成(已提交) 5已通过(负责人) 6已退回(负责人)
	//T_reporting  报告编写状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_state, _ := c.GetInt("T_state") // -1 获取全部
	r, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}
	var auditRecordList []Task.AuditRecord

	switch T_type {
	case "T_task":
		T_state = -1
		if len(r.T_reject_record) > 0 {
			err := json.Unmarshal([]byte(r.T_reject_record), &auditRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
		}
	case "T_scheme":
		if len(r.T_scheme_audit_record) > 0 {
			err := json.Unmarshal([]byte(r.T_scheme_audit_record), &auditRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
		}
	case "T_collection":
		if len(r.T_collection_audit_record) > 0 {
			err := json.Unmarshal([]byte(r.T_collection_audit_record), &auditRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
		}
	case "T_reporting":
		if len(r.T_reporting_audit_record) > 0 {
			err := json.Unmarshal([]byte(r.T_reporting_audit_record), &auditRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
		}
	case "T_examining_report":
		if len(r.T_examining_report_audit_record) > 0 {
			err := json.Unmarshal([]byte(r.T_examining_report_audit_record), &auditRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
		}
	case "T_original_record":
		if len(r.T_original_record_audit_record) > 0 {
			err := json.Unmarshal([]byte(r.T_original_record_audit_record), &auditRecordList)
			if err != nil {
				logs.Error("JSON 反序列化失败:", err)
				return
			}
		}
	}

	AdminMap := Account.AdminListToMap(Account.Read_Admin_List_ALL_1())
	UserMap := Account.UserListToMap(Account.Read_User_List_ALL_1())
	var auditRecordList2 []Task.AuditRecord

	// 返回全部
	if T_state == -1 {
		for i := 0; i < len(auditRecordList); i++ {
			auditRecordList[i].T_admin_name = AdminMap[auditRecordList[i].T_admin]
			auditRecordList[i].T_uuid_name = UserMap[auditRecordList[i].T_uuid]
			auditRecordList2 = append(auditRecordList2, auditRecordList[i])
		}
		c.Data["json"] = lib.JSONS{Data: auditRecordList2, Code: 200, Msg: "ok!"}
		c.ServeJSON()
		return
	}

	if T_state == -2 {
		for i := 0; i < len(auditRecordList); i++ {
			if auditRecordList[i].T_state == 2 || auditRecordList[i].T_state == 4 {
				auditRecordList[i].T_admin_name = AdminMap[auditRecordList[i].T_admin]
				auditRecordList[i].T_uuid_name = UserMap[auditRecordList[i].T_uuid]
				auditRecordList2 = append(auditRecordList2, auditRecordList[i])
			}
		}
		c.Data["json"] = lib.JSONS{Data: auditRecordList2, Code: 200, Msg: "ok!"}
		c.ServeJSON()
		return
	}

	for i := 0; i < len(auditRecordList); i++ {
		if auditRecordList[i].T_state == T_state {
			auditRecordList[i].T_admin_name = AdminMap[auditRecordList[i].T_admin]
			auditRecordList[i].T_uuid_name = UserMap[auditRecordList[i].T_uuid]
			auditRecordList2 = append(auditRecordList2, auditRecordList[i])
		}
	}
	c.Data["json"] = lib.JSONS{Data: auditRecordList2, Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 存档生成图片
func DeviceDataJPG(StartTime, EndTime, T_task_id, T_remark string, deviceList []Device.DeviceClassList, TemperatureMin, TemperatureMax float64) {
	Device.Redis_DeviceDataJPG_Set(T_task_id+T_remark, Device.DeviceDataJPG{
		State: 1,
		Msg:   "图片生成中",
		Url:   "",
	})
	msg := ""
	state := 2
	url := ""

	if TemperatureMin == 0 {
		TemperatureMin = 2
	}
	if TemperatureMax == 0 {
		TemperatureMax = 8
	}
	var ymin, ymax float64
	var xminT, xmaxT time.Time
	if len(deviceList) > 0 {
		ymin, ymax, xminT, xmaxT = Device.Read_DeviceData_T_Min_Max_Time_Min_Max(deviceList[0].T_sn, StartTime, EndTime)
	}

	// 创建一个新的绘图
	p := plot.New()

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

	var chData = make(chan int, 10)
	var jobGroup sync.WaitGroup
	var device = make([]Device.DeviceCount, len(deviceList))

	// 创建温度线
	for i := 0; i < len(deviceList); 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 := deviceList[index].T_sn, deviceList[index].T_id
			ymin_, ymax_, minTime_, maxTime_ := Device.Read_DeviceData_T_Min_Max_Time_Min_Max(sn, StartTime, EndTime)

			if ymin > ymin_ {
				ymin = ymin_
			}
			if ymax < ymax_ {
				ymax = ymax_
			}

			if xminT.After(minTime_) && !minTime_.IsZero() {
				xminT = minTime_
			}

			if xmaxT.Before(maxTime_) && !maxTime_.IsZero() {
				xmaxT = maxTime_
			}

			r_maps, r_maps_num := Device.Read_DeviceSensorData_ById_List(sn, StartTime, EndTime, 0, 9999)
			device[index] = Device.DeviceCount{
				T_id: id,
				T_sn: sn,
				Num:  r_maps_num,
			}
			if r_maps_num == 0 {
				return
			}

			pts := make(plotter.XYs, len(r_maps))
			for j, d := range r_maps {
				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 = randomColor(index)
			p.Add(line)
		}(i)
	}
	jobGroup.Wait()

	xmin, xmax := float64(xminT.Unix()), float64(xmaxT.Unix())
	// 添加最高，最低标准线 用红色虚线标识
	p.Add(horizontalLine(xmin, xmax, TemperatureMin))

	p.Add(horizontalLine(xmin, xmax, TemperatureMax))

	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 = commaTicks{}
	//p.X.Tick.Marker = plot.TimeTicks{Format: "2006-01-02 15:04:05"}
	p.X.Tick.Marker = 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 {
		Device.Redis_DeviceDataJPG_Set(T_task_id+T_remark, Device.DeviceDataJPG{
			State: 3,
			Msg:   "图片生成失败",
			Url:   url,
		})
		logs.Error(lib.FuncName(), "生成图片失败", err)
		return
	}
	if !lib.Pload_qiniu("ofile/"+filename+".jpg", "ofile/"+filename+".jpg") {
		Device.Redis_DeviceDataJPG_Set(T_task_id+T_remark, Device.DeviceDataJPG{
			State: 3,
			Msg:   "图片上传七牛云失败",
			Url:   url,
		})
		logs.Error(lib.FuncName(), "上传七牛云失败")
		return
	}
	//删除目录
	os.Remove("ofile/" + filename + ".jpg")

	msg = "图片生成成功"
	url = "https://bzdcoldverifyoss.baozhida.cn/" + "ofile/" + filename + ".jpg"

	Device.Redis_DeviceDataJPG_Set(T_task_id+T_remark, Device.DeviceDataJPG{
		State:  state,
		Msg:    msg,
		Url:    url,
		Device: device,
	})
	return

}

func horizontalLine(xmin, xmax, y float64) *plotter.Line {
	pts := make(plotter.XYs, 2)
	pts[0].X = xmin
	pts[0].Y = y
	pts[1].X = xmax
	pts[1].Y = y
	line, err := plotter.NewLine(pts)
	if err != nil {
		panic(any(err))
	}
	line.LineStyle.Dashes = []vg.Length{vg.Points(8), vg.Points(5), vg.Points(1), vg.Points(5)}
	line.Color = color.RGBA{R: 255, A: 255}
	return line
}

type timeTicks struct{}

func (timeTicks) Ticks(min, max float64) []plot.Tick {
	tks := plot.TimeTicks{}.Ticks(min, max)
	for i, t := range tks {
		//if t.Label == "" { // Skip minor ticks, they are fine.
		//	continue
		//}
		tks[i].Label = time.Unix(int64(t.Value), 0).Format("2006-01-02 15:04:05")
	}

	return tks
}

type commaTicks struct{}

// Ticks computes the default tick marks, but inserts commas
// into the labels for the major tick marks.
func (commaTicks) Ticks(min, max float64) []plot.Tick {
	tks := plot.DefaultTicks{}.Ticks(min, max)
	for i, t := range tks {
		//if t.Label == "" { // Skip minor ticks, they are fine.
		//	continue
		//}
		tks[i].Label = fmt.Sprintf("%.0f", t.Value)
	}

	return tks
}

// 生成随机颜色的辅助函数
func randomColor(i int) color.RGBA {
	var colors []color.RGBA
	colors = append(colors,
		color.RGBA{R: 52, G: 152, B: 219, A: 255},
		color.RGBA{R: 230, G: 126, B: 34, A: 255},
		color.RGBA{R: 142, G: 68, B: 173, A: 255},
		color.RGBA{R: 211, G: 84, B: 0, A: 255},
		color.RGBA{R: 231, G: 76, B: 60, A: 255},
		color.RGBA{R: 26, G: 188, B: 156, A: 255},
		color.RGBA{R: 243, G: 156, B: 18, A: 255},
		color.RGBA{R: 22, G: 160, B: 133, A: 255},
		color.RGBA{R: 46, G: 204, B: 113, A: 255},
		color.RGBA{R: 39, G: 174, B: 96, A: 255},
		color.RGBA{R: 41, G: 128, B: 185, A: 255},
		color.RGBA{R: 155, G: 89, B: 182, A: 255},
		color.RGBA{R: 192, G: 57, B: 43, A: 255},
		color.RGBA{R: 241, G: 196, B: 15, A: 255},
	)

	return colors[i%len(colors)]
}

// 获取加完水印的pdf
func GetWatermarkPdf_command(task Task.Task, pdfURL string, flag string) (pdf string) {
	if len(pdfURL) == 0 {
		return
	}

	currentDirectory := lib.GetCurrentDirectory()

	scriptPath := currentDirectory + "/script"
	pdf_file_out_name := uuid.New().String() + ".pdf"
	pdfFilename := currentDirectory + "/ofile/" + uuid.New().String() + ".pdf"
	pdf_file_out := currentDirectory + "/ofile/watermark" + pdf_file_out_name
	watermark_pdf := currentDirectory + "/script/watermark.pdf"

	// 执行Python脚本
	cmd := exec.Command("python3", "add_watermark.py", pdfURL, pdfFilename, pdf_file_out, watermark_pdf)
	cmd.Dir = scriptPath
	// 获取命令输出
	_, err := cmd.CombinedOutput()
	if err != nil {
		logs.Error("执行python脚本添加水印错误:", err)
		return
	}
	lib.Pload_qiniu(pdf_file_out, pdf_file_out_name)
	if !lib.Pload_qiniu(pdf_file_out, pdf_file_out) {
		err = errors.New("上传水印pdf失败")
		return
	}
	defer func() {
		os.Remove(pdfFilename)
		os.Remove(pdf_file_out)
	}()

	pdf = "https://bzdcoldverifyoss.baozhida.cn/" + pdf_file_out_name

	switch flag {
	case "T_pdf1":
		task.T_pdf1_watermark = pdf
		Task.Update_Task(task, "T_pdf1_watermark")
	case "T_pdf2":
		task.T_pdf2_watermark = pdf
		Task.Update_Task(task, "T_pdf2_watermark")
	}

	return
}
func GetSignaturePdf_command(task Task.Task, pdfURL string, flag string) (pdf string) {
	if len(pdfURL) == 0 {
		return
	}

	currentDirectory := lib.GetCurrentDirectory()
	scriptPath := currentDirectory + "/script"
	pdf_file_out_name := uuid.New().String() + ".pdf"
	pdfFilename := currentDirectory + "/ofile/" + uuid.New().String() + ".pdf"
	pdf_file_out := currentDirectory + "/ofile/signature" + pdf_file_out_name
	signature_img := currentDirectory + "/script/报告专用章.png"

	// 执行Python脚本
	cmd := exec.Command("python3", "add_signature.py", pdfURL, pdfFilename, signature_img, pdf_file_out)
	cmd.Dir = scriptPath
	// 获取命令输出
	_, err := cmd.CombinedOutput()
	if err != nil {
		logs.Error("执行python脚本添加公章错误:", err)
		return
	}

	_, err = os.Stat(pdf_file_out)
	if os.IsNotExist(err) {
		return ""
	}

	lib.Pload_qiniu(pdf_file_out, pdf_file_out_name)
	if !lib.Pload_qiniu(pdf_file_out, pdf_file_out) {
		err = errors.New("上传水印pdf失败")
		return
	}
	defer func() {
		os.Remove(pdfFilename)
		os.Remove(pdf_file_out)
	}()

	pdf = "https://bzdcoldverifyoss.baozhida.cn/" + pdf_file_out_name

	switch flag {
	case "T_pdf1":
		task.T_pdf1_signature = pdf
		Task.Update_Task(task, "T_pdf1_signature")
	case "T_pdf2":
		task.T_pdf2_signature = pdf
		Task.Update_Task(task, "T_pdf2_signature")
	}

	return
}

func GetWatermarkPdf(task Task.Task, pdfURL string, stamp bool, flag string) (pdf string) {
	if len(pdfURL) == 0 {
		return
	}

	// 添加公章 T_pdf5为CNAS实验室 ，不添加公章
	var signaturePdf, watermarkPdf string
	var err error
	if flag != "T_pdf5" {
		if stamp {
			signaturePdf, err = lib.GetSignaturePdf(pdfURL)
			if err != nil {
				logs.Error("获取加报告章pdf失败:", err)
				return
			}
		} else {
			signaturePdf = pdfURL
		}
	}

	// 添加水印
	watermarkPdf, err = lib.GetWatermarkPdf(pdfURL)
	if err != nil {
		logs.Error("获取加水印pdf失败:", err)
		return
	}
	switch flag {
	case "T_pdf1":
		task.T_pdf1_watermark = watermarkPdf
		task.T_pdf1_signature = signaturePdf
		Task.Update_Task(task, "T_pdf1_watermark", "T_pdf1_signature")
	case "T_pdf2":
		task.T_pdf2_watermark = watermarkPdf
		task.T_pdf2_signature = signaturePdf
		Task.Update_Task(task, "T_pdf2_watermark", "T_pdf2_signature")
	case "T_pdf5":
		task.T_pdf5_watermark = watermarkPdf
		Task.Update_Task(task, "T_pdf5_watermark")
	}

	return
}

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

		return
	}

	var r_jsons lib.R_JSONS

	T_task_id := c.GetString("T_task_id")
	T_task_type, _ := c.GetInt("T_task_type", 0)

	var cnt int64
	List, cnt := Task.Read_TaskTime_List(T_task_id, T_task_type)

	r_jsons.List = List
	r_jsons.Num = int(cnt)

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

// 添加-
func (c *TaskController) TaskTimeAdd() {

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

	System.Add_UserLogs_T(User_r.T_uuid, "任务暂停", "暂停申请", dc)

	T_task_id := c.GetString("T_task_id")

	T_task_type, _ := c.GetInt("T_task_type", 0) // 公司名称
	T_aaa := c.GetString("T_aaa")

	var_ := Task.TaskTime{
		T_task_id:    T_task_id,
		T_task_type:  T_task_type,
		T_uuid:       User_r.T_uuid,
		T_remarks:    T_aaa,
		T_start_time: time.Now().Format("2006-01-02 15:04:05"),
	}
	List, _ := Task.Read_TaskTime_List(T_task_id, T_task_type)
	if len(List) > 0 {
		if len(List[len(List)-1].T_end_time) == 0 {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "上一个任务还没结束!"}
			c.ServeJSON()
			return
		}
	}

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

	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_task_id, "任务暂停", "暂停申请", var_)
	System.Add_UserLogs_T(User_r.T_uuid, "任务暂停", "暂停申请", var_)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: T_task_id}
	c.ServeJSON()
	return
}

// 添加-
func (c *TaskController) TaskTimeEnd() {

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

	System.Add_UserLogs_T(User_r.T_uuid, "任务暂停", "暂停结束", dc)

	Id, _ := c.GetInt("Id", 0)

	TaskTime_r, is := Task.Read_TaskTime_ById(Id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}
	TaskTime_r.T_end_time = time.Now().Format("2006-01-02 15:04:05")
	is = Task.Update_TaskTime(TaskTime_r, "T_end_time")
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
		c.ServeJSON()
		return
	}
	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, TaskTime_r.T_task_id, "任务暂停", "暂停结束", TaskTime_r)
	System.Add_UserLogs_T(User_r.T_uuid, "任务暂停", "暂停结束", TaskTime_r)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: TaskTime_r.T_task_id}
	c.ServeJSON()
	return
}

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

	T_power, _ := c.GetInt("T_power", 0) // 5	数据采集工程师   6	验证报告工程师
	type Admin_T struct {
		T_name string

		T_scheme           int    // 实施方案
		T_scheme_returnnum int    // 退回
		T_scheme_overnum   int    // 超时
		T_scheme_log       string // 日志

		T_collection           int    // 数据采集
		T_collection_returnnum int    // 退回
		T_collection_overnum   int    // 超时
		T_collection_log       string // 日志

		T_reporting           int    // 报告编写
		T_reporting_returnnum int    // 退回
		T_reporting_overnum   int    // 超时
		T_reporting_log       string // 日志

		T_rejectdnum int // 驳回数量

	}

	var Admin_T_List []Admin_T
	Admin_List := Account.Read_Admin_List_ALL_T_power(T_power)
	for _, A := range Admin_List {
		Admin_t := Admin_T{T_name: A.T_name}

		// 方案
		Task_List := Task.Read_UserTask_StatisticalRanking(A.T_uuid, "T_scheme") //T_scheme   T_collection   T_reporting
		for _, T := range Task_List {
			if len(T.T_scheme_end_time) > 0 {
				if is, _ := lib.IsInCurrentMonth(T.T_scheme_end_time); !is {
					continue // 不是本月
				}
				Admin_t.T_scheme += 1
				Admin_t.T_scheme_log += T.T_name
				// 退回
				if T.T_scheme_return_times > 0 {
					Admin_t.T_scheme_returnnum += T.T_scheme_return_times
					Admin_t.T_scheme_log += " | 退回" + lib.To_string(int(T.T_scheme_return_times))
				}
				// 超时
				if T.T_scheme_overtime > 0 {
					Admin_t.T_scheme_overnum += 1
					Admin_t.T_scheme_log += " | 超时" + lib.ConvertMinutesToDHM(int(T.T_scheme_overtime))
				}
				// 驳回
				if T.T_reject_times > 0 {
					Admin_t.T_rejectdnum += T.T_reject_times
					Admin_t.T_scheme_log += " | 驳回" + lib.To_string(int(T.T_reject_times))
				}

				Admin_t.T_scheme_log += "\n"
			}
		}
		// 实施
		Task_List = Task.Read_UserTask_StatisticalRanking(A.T_uuid, "T_collection") //T_scheme   T_collection   T_reporting
		for _, T := range Task_List {
			if len(T.T_collection_end_time) > 0 {
				if is, _ := lib.IsInCurrentMonth(T.T_collection_end_time); !is {
					continue // 不是本月
				}
				Admin_t.T_collection += 1
				Admin_t.T_collection_log += T.T_name
				// 退回
				if T.T_collection_return_times > 0 {
					Admin_t.T_collection_returnnum += T.T_collection_return_times
					Admin_t.T_collection_log += " | 退回" + lib.To_string(int(T.T_collection_return_times))
				}
				// 超时
				if T.T_collection_overtime > 0 {
					Admin_t.T_collection_overnum += 1
					Admin_t.T_collection_log += " | 超时" + lib.ConvertMinutesToDHM(int(T.T_collection_overtime))
				}
				// 驳回
				if T.T_reject_times > 0 {
					Admin_t.T_rejectdnum += T.T_reject_times
					Admin_t.T_collection_log += " | 驳回" + lib.To_string(int(T.T_reject_times))
				}

				Admin_t.T_collection_log += "\n"
			}
		}
		// 报告
		Task_List = Task.Read_UserTask_StatisticalRanking(A.T_uuid, "T_reporting") //T_scheme   T_collection   T_reporting
		for _, T := range Task_List {
			if len(T.T_reporting_end_time) > 0 {
				if is, _ := lib.IsInCurrentMonth(T.T_reporting_end_time); !is {
					continue // 不是本月
				}
				Admin_t.T_reporting += 1
				Admin_t.T_reporting_log += T.T_name
				// 退回
				if T.T_reporting_return_times > 0 {
					Admin_t.T_reporting_returnnum += T.T_reporting_return_times
					Admin_t.T_reporting_log += " | 退回" + lib.To_string(int(T.T_reporting_return_times))
				}
				// 超时
				if T.T_reporting_overtime > 0 {
					Admin_t.T_reporting_overnum += 1
					Admin_t.T_reporting_log += " | 超时" + lib.ConvertMinutesToDHM(int(T.T_reporting_overtime))
				}
				// 驳回
				if T.T_reject_times > 0 {
					Admin_t.T_rejectdnum += T.T_reject_times
					Admin_t.T_reporting_log += " | 驳回" + lib.To_string(int(T.T_reject_times))
				}
				Admin_t.T_reporting_log += "\n"
			}
		}
		Admin_T_List = append(Admin_T_List, Admin_t)
	}

	var r_jsons lib.R_JSONS
	r_jsons.List = Admin_T_List
	r_jsons.Page = 0
	r_jsons.Page_size = 0
	r_jsons.Pages = lib.Func_page(int64(0), int64(0))
	r_jsons.Num = 0

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

// 复制-
func (c *TaskController) Copy() {

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

	T_name := c.GetString("T_name")
	T_task_id := c.GetString("T_task_id")
	new_T_uuid := c.GetString("T_uuid") // 新增T_uuid参数
	r, is := Task.Read_Task(T_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取信息采集失败!"}
		c.ServeJSON()
		return
	}

	// 确定使用的T_uuid
	target_T_uuid := r.T_uuid
	if len(new_T_uuid) > 0 && new_T_uuid != r.T_uuid {
		target_T_uuid = new_T_uuid
	}

	dc := Device.DeviceClass{
		T_uuid:  target_T_uuid,
		T_State: 1,
	}
	T_class_id, is := Device.Add_DeviceClass(dc)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加分类失败!"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "分类管理", "添加", dc)
	// 查询信息采集信息
	infoCollection, is := InfoCollection.Read_InfoCollection(r.T_InfoCollection_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取信息采集失败!"}
		c.ServeJSON()
		return
	}

	// 如果T_uuid不同，需要处理信息采集
	target_InfoCollection_id := r.T_InfoCollection_id
	if len(new_T_uuid) > 0 && new_T_uuid != r.T_uuid {
		// 查询新的T_uuid是否有同名的信息采集
		newInfoCollection, found := InfoCollection.Read_InfoCollection_By_T_uuid_Name(new_T_uuid, infoCollection.T_name)
		if found {
			// 如果有则使用该信息采集
			target_InfoCollection_id = newInfoCollection.T_InfoCollection_id
			infoCollection = newInfoCollection
		} else {
			// 如果没有则添加
			// 获取原公司和新公司的名称
			_, oldCompany := Account.Read_User_ByT_uuid(r.T_uuid)
			_, newCompany := Account.Read_User_ByT_uuid(new_T_uuid)
			infoCollectionName := infoCollection.T_name
			// 如果信息采集名称与原公司名称相同，则添加的时候需要将名称更改为新的T_uuid的公司的名称
			if infoCollection.T_name == oldCompany.T_name {
				infoCollectionName = newCompany.T_name
			}

			// 创建新的信息采集
			newInfoCollection := InfoCollection.InfoCollection{
				T_uuid:               new_T_uuid,
				T_name:               infoCollectionName,
				T_InfoTemplate_class: infoCollection.T_InfoTemplate_class,
				T_InfoTemplate_id:    infoCollection.T_InfoTemplate_id,
				T_status:             1,
				T_State:              1,
				T_start_time:         infoCollection.T_start_time,
				T_end_time:           infoCollection.T_end_time,
				T_time_interval:      infoCollection.T_time_interval,
			}
			newInfoCollectionId, err := InfoCollection.Add_InfoCollection(newInfoCollection)
			if err != nil {
				c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加信息采集失败: " + err.Error()}
				c.ServeJSON()
				return
			}
			target_InfoCollection_id = newInfoCollectionId
			// 重新读取新创建的信息采集以获取完整信息
			infoCollection, is = InfoCollection.Read_InfoCollection(target_InfoCollection_id)
			if !is {
				c.Data["json"] = lib.JSONS{Code: 202, Msg: "获取新创建的信息采集失败!"}
				c.ServeJSON()
				return
			}
		}
	}

	var_ := Task.Task{
		T_Distributor_id:       r.T_Distributor_id,
		T_InfoCollection_id:    target_InfoCollection_id,
		T_InfoTemplate_id:      infoCollection.T_InfoTemplate_id,
		T_start_time:           infoCollection.T_start_time, // 项目开始时间使用信息采集开始时间
		T_class:                int(T_class_id),
		T_uuid:                 target_T_uuid,
		T_name:                 T_name,
		T_VerifyTemplate_class: r.T_VerifyTemplate_class,
		T_VerifyTemplate_id:    r.T_VerifyTemplate_id,
		T_deadline:             time.Now().AddDate(0, 2, 0).Format("2006-01-02"),
		T_scheme:               r.T_scheme,
		T_collection:           r.T_collection,
		T_reporting:            r.T_reporting,
		T_delivery:             r.T_delivery,
		T_Show:                 1,
		T_State:                1,

		T_project:         r.T_project,
		T_province:        r.T_province,
		T_city:            r.T_city,
		T_district:        r.T_district,
		T_province_code:   r.T_province_code,
		T_city_code:       r.T_city_code,
		T_district_code:   r.T_district_code,
		T_category:        r.T_category,
		T_device_type:     r.T_device_type,
		T_volume:          r.T_volume,
		T_verify_type:     r.T_verify_type,
		T_subject_matter:  T_name,
		T_temp_range:      r.T_temp_range,
		T_report_type:     r.T_report_type,
		T_device_quantity: r.T_device_quantity,
		T_cnas:            r.T_cnas,
	}
	var_.T_report_number, _ = Task.GenerateNextT_report_number(var_.T_device_type)
	T_paste_task_id, is := Task.Add_Task(var_)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败!"}
		c.ServeJSON()
		return
	}

	// 复制 DeviceClassList
	err := CopyDeviceClassList(r, var_)
	if err != nil {
		logs.Error("复制设备列表失败", err)
	}
	// 自动填写备注
	err = AutoFillDeviceClassRemark(T_paste_task_id)
	if err != nil {
		logs.Error("自动填写设备备注失败", err)
	}

	// 自动填写布点
	err = AutoFillDeploy(T_paste_task_id, 0)
	if err != nil {
		logs.Error("自动填写布点失败", err)
	}

	NatsServer.Create_Local_Table(T_paste_task_id)
	Task.Redis_Task_T_report_number_DelK(var_.T_report_number) // 删除redis内的任务编号

	// 复制验证模版数据
	Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(r.T_VerifyTemplate_id, 0, 0)
	copy_task_Data := VerifyTemplate.Read_VerifyTemplateMapData_List(0, T_task_id, r.T_VerifyTemplate_id, Map_List)

	Data := VerifyTemplate.Read_VerifyTemplateMapData_List(0, T_paste_task_id, r.T_VerifyTemplate_id, Map_List)

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

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

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

			T_value: copyDataMap[v.T_name],
		}
		MapDataList = append(MapDataList, val)
	}
	_, is = VerifyTemplate.AddOrUpdate_VerifyTemplateMapData_ADD_History(MapDataList, 0, "复制", 0, 0, 1)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "保存失败"}
		c.ServeJSON()
		return
	}
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "复制标签数据", MapDataList)

	// 通知
	_, company_r := Account.Read_User_ByT_uuid(var_.T_uuid)
	go wx.WxSend(var_.T_scheme, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))
	go wx.WxSend(var_.T_collection, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))
	go wx.WxSend(var_.T_reporting, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))
	go wx.WxSend(var_.T_delivery, fmt.Sprintf("【%s-%s】任务派发", company_r.T_name, var_.T_name))

	// 添加任务操作日志
	Task.Add_TaskLogs_T(User_r.T_uuid, T_paste_task_id, "任务管理", "复制", var_)
	System.Add_UserLogs_T(User_r.T_uuid, "任务管理", "复制", var_)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: T_paste_task_id}
	c.ServeJSON()
	return
}

// 生成报告编号 设备类型+年+季度+递增编号
func (c *TaskController) GenT_report_number() {
	// 验证登录 User_is, User_r
	_, User_is := Account.Verification_Admin(c.Ctx.GetCookie("User_tokey"), c.GetString("User_tokey"))
	if !User_is {
		c.Data["json"] = lib.JSONS{Code: 201, Msg: "请重新登录!"}
		c.ServeJSON()
		return
	}

	T_device_type := c.GetString("T_device_type")

	number, err := Task.GenerateNextT_report_number(T_device_type)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: err.Error()}
		c.ServeJSON()
		return
	}

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

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

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

	verifyTemplate, is := VerifyTemplate.Read_VerifyTemplate(task.T_VerifyTemplate_id)
	verifyTemplate_R := VerifyTemplate.VerifyTemplateToVerifyTemplate_R(verifyTemplate)

	Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(task.T_VerifyTemplate_id, T_source, 0)
	MapData := VerifyTemplate.Read_VerifyTemplateMapData_List(T_source, T_task_id, task.T_VerifyTemplate_id, Map_List)
	T_deploy_list := verifyTemplate_R.T_deploy_list
	//if len(T_deploy_list) == 0 {
	//	// 解析设备列表备注的布点
	//	deviceClassList := Device.Read_DeviceClassList_List_ByT_remark(task.T_class, "")
	//	for _, v := range deviceClassList {
	//		splitList := lib.SplitStringSeparator(v.T_remark, "|")
	//		for _, T_name := range splitList {
	//			T_deploy_list = append(T_deploy_list, VerifyTemplate.VerifyTemplateDeploy{T_name: T_name})
	//		}
	//	}
	//}

	// 循环查询布点
	deployMap := make(map[string]string)
	for _, deploy := range T_deploy_list {
		deviceClassList := Device.Read_DeviceClassList_List_ByT_remark(task.T_class, deploy.T_name)
		var snList []string
		for _, v := range deviceClassList {
			snList = append(snList, v.T_sn)
		}
		deployMap[deploy.T_name] = strings.Join(snList, "|")
	}
	MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)

	for _, v := range MapData {
		if snList, ok := deployMap[v.T_name]; ok {
			val := VerifyTemplate.VerifyTemplateMapData{
				T_source:               v.T_source,
				T_task_id:              task.T_task_id,
				T_VerifyTemplate_id:    task.T_VerifyTemplate_id,
				T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
				T_Required:             v.T_Required,
				T_Construction:         v.T_Construction,
				T_flow_sort:            v.T_flow_sort,
				T_max_time:             v.T_max_time,
				T_min_time:             v.T_min_time,

				T_value:      snList,
				T_start_time: v.T_start_time,
			}
			MapDataList = append(MapDataList, val)
		}
	}

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

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

// SyncVerifyTemplateMapData 根据标签名称同步模版数据
func (c *TaskController) SyncVerifyTemplateMapData() {
	T_copy_task_id := c.GetString("T_copy_task_id")
	T_paste_task_id := c.GetString("T_paste_task_id")
	T_source, _ := c.GetInt("T_source")
	copy_task, is := Task.Read_Task(T_copy_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}
	paste_task, is := Task.Read_Task(T_paste_task_id)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "Id 错误!"}
		c.ServeJSON()
		return
	}

	copy_task_Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(copy_task.T_VerifyTemplate_id, 0, 0)
	copy_task_Data := VerifyTemplate.Read_VerifyTemplateMapData_List(T_source, T_copy_task_id, copy_task.T_VerifyTemplate_id, copy_task_Map_List)

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

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

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

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

			T_value: copyDataMap[v.T_name],
		}
		MapDataList = append(MapDataList, val)
	}
	var ids []int64
	ids, is = VerifyTemplate.AddOrUpdate_VerifyTemplateMapData_ADD_History(MapDataList, 0, "", 0, 0, 0)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "保存失败"}
		c.ServeJSON()
		return
	}

	c.Data["json"] = lib.JSONS{Data: ids, Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}
func (c *TaskController) TaskData_Stat() {
	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
		}
	} else {
		EndTime = time.Now().Format("2006-01-02 15:04:05")
	}
	T_remark := c.GetString("T_remark")

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

	deviceList, _ := Device.Read_DeviceClassList_OrderList(Task_r.T_class, "", "", T_remark, 0, 9999)
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_class 错误!"}
		c.ServeJSON()
		return
	}

	var chData = make(chan int, 10)
	var jobGroup sync.WaitGroup
	var device = make([]Device.DeviceCount, len(deviceList))

	// 创建温度线
	for i := 0; i < len(deviceList); 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 := deviceList[index].T_sn, deviceList[index].T_id

			_, r_maps_num := Device.Read_DeviceSensorData_ById_List(sn, StartTime, EndTime, 0, 9999)
			device[index] = Device.DeviceCount{
				T_id: id,
				T_sn: sn,
				Num:  r_maps_num,
			}
			if r_maps_num == 0 {
				return
			}

		}(i)
	}
	jobGroup.Wait()

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

// SyncPDFWatermark 同步水印
func (c *TaskController) SyncPDFWatermark() {
	List, _ := Task.Read_Task_List_For_Watermark("pdf1")
	for _, task := range List {
		GetWatermarkPdf_command(task, task.T_pdf1, "T_pdf1")
		GetSignaturePdf_command(task, task.T_pdf1, "T_pdf1")
	}
	List2, _ := Task.Read_Task_List_For_Watermark("pdf2")
	for _, task := range List2 {
		GetWatermarkPdf_command(task, task.T_pdf2, "T_pdf2")
		GetSignaturePdf_command(task, task.T_pdf2, "T_pdf2")
	}
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
	c.ServeJSON()
	return
}

// 复制设备列表
func CopyDeviceClassList(copy_task, paste_task Task.Task) error {
	// 读取源任务的设备列表
	copyList, _ := Device.Read_DeviceClassList_OrderList(copy_task.T_class, "", "", "", 0, 9999)

	// 遍历源任务的设备列表，为每个设备创建新的 DeviceClassList 并添加到目标任务
	for _, v := range copyList {
		// 读取证书信息
		var pdf Certificate.CertificatePdf
		pdfList, _ := Certificate.Read_CertificatePdf_T_layout_no(v.T_id, "")
		if len(pdfList) > 0 {
			pdf = pdfList[0]
		}

		var_ := Device.DeviceClassList{
			T_class:          paste_task.T_class,
			T_id:             v.T_id,
			T_sn:             v.T_sn,
			T_failure_time:   pdf.T_failure_time,
			T_pdf:            pdf.T_pdf,
			T_Certificate_sn: pdf.T_Certificate_sn,
			T_remark:         v.T_remark,
			T_terminal:       v.T_terminal,
			T_State:          1,
		}

		_, is := Device.Add_DeviceClassList(var_)
		if !is {
			return fmt.Errorf("添加设备列表失败: %s", v.T_id)
		}
	}
	return nil
}

// 自动填写设备备注
func AutoFillDeviceClassRemark(T_task_id string) error {
	task, is := Task.Read_Task(T_task_id)
	if !is {
		return fmt.Errorf("读取任务失败: %s", T_task_id)
	}

	verifyTemplate, is := VerifyTemplate.Read_VerifyTemplate(task.T_VerifyTemplate_id)
	if !is {
		return fmt.Errorf("读取验证模板失败: %s", task.T_VerifyTemplate_id)
	}
	verifyTemplate_R := VerifyTemplate.VerifyTemplateToVerifyTemplate_R(verifyTemplate)
	T_deploy_list := verifyTemplate_R.T_deploy_list

	// 循环查询布点
	deviceClassRemarkMap := make(map[int][]string)
	deviceClassList := Device.Read_DeviceClassList_List_id_By_Terminal(task.T_class, false)
	for _, deploy := range T_deploy_list {
		if len(deploy.T_scope) > 0 {
			dcl := FilterByRange(deviceClassList, deploy.T_scope)
			for _, dc := range dcl {
				deviceClassRemarkMap[dc.Id] = append(deviceClassRemarkMap[dc.Id], deploy.T_name)
			}
		}
	}

	for _, deviceClass := range deviceClassList {
		if remark, ok := deviceClassRemarkMap[deviceClass.Id]; ok {
			deviceClass.T_remark = strings.Join(remark, "|")
			if !Device.Update_DeviceClassList(deviceClass, "T_remark") {
				return fmt.Errorf("修改备注失败: %d", deviceClass.Id)
			}
		}
	}

	return nil
}

// 自动填写布点
func AutoFillDeploy(T_task_id string, T_source int) error {
	task, is := Task.Read_Task(T_task_id)
	if !is {
		return fmt.Errorf("读取任务失败: %s", T_task_id)
	}

	verifyTemplate, is := VerifyTemplate.Read_VerifyTemplate(task.T_VerifyTemplate_id)
	if !is {
		return fmt.Errorf("读取验证模板失败: %s", task.T_VerifyTemplate_id)
	}
	verifyTemplate_R := VerifyTemplate.VerifyTemplateToVerifyTemplate_R(verifyTemplate)

	Map_List := VerifyTemplate.Read_VerifyTemplateMap_List_For_Data(task.T_VerifyTemplate_id, T_source, 0)
	MapData := VerifyTemplate.Read_VerifyTemplateMapData_List(T_source, T_task_id, task.T_VerifyTemplate_id, Map_List)
	T_deploy_list := verifyTemplate_R.T_deploy_list

	// 循环查询布点
	deployMap := make(map[string]string)
	for _, deploy := range T_deploy_list {
		deviceClassList := Device.Read_DeviceClassList_List_ByT_remark(task.T_class, deploy.T_name)
		var snList []string
		for _, v := range deviceClassList {
			snList = append(snList, v.T_sn)
		}
		deployMap[deploy.T_name] = strings.Join(snList, "|")
	}
	MapDataList := make([]VerifyTemplate.VerifyTemplateMapData, 0)

	for _, v := range MapData {
		if snList, ok := deployMap[v.T_name]; ok {
			val := VerifyTemplate.VerifyTemplateMapData{
				T_source:               v.T_source,
				T_task_id:              task.T_task_id,
				T_VerifyTemplate_id:    task.T_VerifyTemplate_id,
				T_VerifyTemplateMap_id: v.T_VerifyTemplateMap_id,
				T_Required:             v.T_Required,
				T_Construction:         v.T_Construction,
				T_flow_sort:            v.T_flow_sort,
				T_max_time:             v.T_max_time,
				T_min_time:             v.T_min_time,

				T_value:      snList,
				T_start_time: v.T_start_time,
			}
			MapDataList = append(MapDataList, val)
		}
	}

	if len(MapDataList) > 0 {
		_, is := VerifyTemplate.AddOrUpdate_VerifyTemplateMapData_ADD_History(MapDataList, T_source, "", 0, 0, 0)
		if !is {
			return fmt.Errorf("保存布点数据失败")
		}
	}

	return nil
}