ColdVerify_server/models/Task/Task.go

package Task

import (
	"ColdVerify_server/conf"
	"ColdVerify_server/lib"
	"ColdVerify_server/logs"
	"ColdVerify_server/models/InfoCollection"
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/astaxie/beego/cache"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
)

var (
	TaskSchemeStateWaitSubmit   = 0 // 待提交
	TaskSchemeStateSubmitted    = 5 // 已提交
	TaskSchemeStateClientPass   = 1 // 已通过(客户)
	TaskSchemeStateClientReturn = 2 // 已退回(客户)
	TaskSchemeStatePass         = 3 // 已通过(负责人)
	TaskSchemeStateReturn       = 4 // 已退回(负责人)
	TaskSchemeStateMap          = map[int]string{
		TaskSchemeStateWaitSubmit:   "待提交",
		TaskSchemeStateSubmitted:    "已提交",
		TaskSchemeStateClientPass:   "已通过(客户)",
		TaskSchemeStateClientReturn: "已驳回(客户)",
		TaskSchemeStatePass:         "已通过",
		TaskSchemeStateReturn:       "已退回",
	}

	// 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4-数据编辑已完成(已提交) 5已通过(报告负责人) 6已退回(报告负责人)
	TaskCollectionStateWaitSubmit = 0 // 待提交
	TaskCollectionStateFinish     = 1 // 已完成
	TaskCollectionStateInProgress = 2 // 处理中
	TaskCollectionStateNoData     = 3 // 已采集-无数据
	TaskCollectionStateSubmitted  = 4 // 已提交
	TaskCollectionStatePass       = 5 // 已通过(负责人)
	TaskCollectionStateReturn     = 6 // 已退回(负责人)
	TaskCollectionStateMap        = map[int]string{
		TaskCollectionStateWaitSubmit: "待提交",
		TaskCollectionStateFinish:     "已完成",
		TaskCollectionStateInProgress: "处理中",
		TaskCollectionStateNoData:     "已采集-无数据",
		TaskCollectionStateSubmitted:  "APP已提交",
		TaskCollectionStatePass:       "已通过",
		TaskCollectionStateReturn:     "已退回",
	}

	TaskReportingStateWaitSubmit   = 0 // 待提交
	TaskReportingStateSubmitted    = 5 // 已提交
	TaskReportingStateClientPass   = 1 // 已通过(客户)
	TaskReportingStateClientReturn = 2 // 已退回(客户)
	TaskReportingStatePass         = 3 // 已通过
	TaskReportingStateReturn       = 4 // 已退回
	TaskReportingStateMap          = map[int]string{
		TaskReportingStateWaitSubmit:   "待提交",
		TaskReportingStateSubmitted:    "已提交",
		TaskReportingStateClientPass:   "已通过(客户)",
		TaskReportingStateClientReturn: "已驳回(客户)",
		TaskReportingStatePass:         "已通过",
		TaskReportingStateReturn:       "已退回",
	}

	TaskExaminingReportStateWaitSubmit    = 0 // 待提交
	TaskExaminingReportStateSubmitted     = 5 // 已提交
	TaskExaminingReportStateClientPass    = 1 // 已通过(客户)
	TaskExaminingReportStateClientReturn  = 2 // 已退回(客户)
	TaskExaminingReportStatePass          = 3 // 已通过
	TaskExaminingReportStateReturn        = 4 // 已退回
	TaskExaminingReportStateClickGenerate = 6 // 已退回
	TaskExaminingReportStateMap           = map[int]string{
		TaskExaminingReportStateWaitSubmit:    "待提交",
		TaskExaminingReportStateSubmitted:     "已提交",
		TaskExaminingReportStateClientPass:    "已通过(客户)",
		TaskExaminingReportStateClientReturn:  "已驳回(客户)",
		TaskExaminingReportStatePass:          "已通过",
		TaskExaminingReportStateReturn:        "已退回",
		TaskExaminingReportStateClickGenerate: "已点击报告生成",
	}

	TaskOriginalRecordStateWaitSubmit = 0 // 待提交
	TaskOriginalRecordStateSubmitted  = 5 // 已提交
	TaskOriginalRecordStatePass       = 3 // 已通过
	TaskOriginalRecordStateReturn     = 4 // 已退回
	TaskOriginalRecordStateMap        = map[int]string{
		TaskOriginalRecordStateWaitSubmit: "待提交",
		TaskOriginalRecordStateSubmitted:  "已提交",
		TaskOriginalRecordStatePass:       "已通过",
		TaskOriginalRecordStateReturn:     "已退回",
	}

	TaskDeliveryStateUnfinished = 0 // 未完成
	TaskDeliveryStateFinished   = 1 // 已完成
	TaskDeliveryStateGoing      = 2 // 进行中
	TaskDeliveryStateMap        = map[int]string{
		TaskDeliveryStateUnfinished: "未完成",
		TaskDeliveryStateFinished:   "已完成",
		TaskDeliveryStateGoing:      "处理中",
	}

	TaskMarkingStateUnfinished = 0 // 未完成
	TaskMarkingStateFinished   = 1 // 已完成
	TaskMarkingStateMap        = map[int]string{
		TaskMarkingStateUnfinished: "未完成",
		TaskMarkingStateFinished:   "已完成",
	}
)

var (
	TaskSchemeTimeLimit = map[string]float64{
		"BWX":   30, // 保温箱
		"LDX":   30, // 冷冻箱
		"LCG":   30, // 冷藏柜
		"LDG":   30, // 冷冻柜
		"YLG":   30, // 阴凉柜
		"LDC":   60, // 冷藏车
		"LK":    60, // 冷库
		"BG":    60, // 冰柜
		"DWBWX": 60, // 低温保存箱
		"XT":    30, // 系统验证
		"WZ":    80, // 位置
		"XJ":    0,  // 巡检
		"PX":    0,  // 培训
		"QT":    0,  // 其他
	}

	TaskReportingTimeLimit = map[string]float64{
		"BWX":   180, // 保温箱
		"LDX":   180, // 冷冻箱
		"LCG":   210, // 冷藏柜
		"LDG":   210, // 冷冻柜
		"YLG":   210, // 阴凉柜
		"LDC":   300, // 冷藏车
		"LK":    390, // 冷库
		"BG":    210, // 冰柜
		"DWBWX": 180, // 低温保存箱
		"XT":    300, // 系统验证
		"WZ":    240, // 位置
		"XJ":    0,   // 巡检
		"PX":    0,   // 培训
		"QT":    0,   // 其他

	}

	TaskCollectionTimeLimit float64 = 7 * 24 * 60

	DeviceTypeMap = map[string]string{
		"箱":  "X",
		"柜":  "G",
		"车":  "C",
		"库":  "K",
		"系统": "XT",
		"位置": "WZ",
		"培训": "PX",
		"巡检": "XJ",
		"其他": "QT",
	}
)

type AuditRecord struct {
	T_uuid       string `orm:"size(256);null"`     // 提交人（客户）UUID
	T_uuid_name  string `orm:"size(256);null"`     // 提交人名称
	T_admin      string `orm:"size(256);null"`     // 提交人（报告负责人）UUID
	T_admin_name string `orm:"size(256);null"`     // 提交人名称
	T_state      int    `orm:"size(2);default(0)"` // 状态 1 已完成(客户通过) 2已退回(客户) 3已通过(报告负责人) 4已退回(报告负责人) 5已提交
	T_reason     string `orm:"type(text)"`         // 原因
	T_time       string `orm:"type(256)"`          // 时间
	T_type       string `orm:"type(256)"`          // 退回类型 scheme方案 reporting报告
}

// 模版
type Task struct {
	Id                  int    `orm:"column(ID);size(11);auto;pk"`
	T_uid               string `orm:"size(256);null"`       // 文件导入任务的唯一标识
	T_Distributor_id    string `orm:"size(256);null"`       // 分销商id
	T_class             int    `orm:"size(200);default(0)"` // 分类id
	T_InfoCollection_id string `orm:"size(256);null"`       // 信息采集ID
	T_InfoTemplate_id   string `orm:"size(256);null"`       // 信息采集模版ID

	T_task_id                string `orm:"size(256);null"`     // 任务ID
	T_uuid                   string `orm:"size(256);null"`     // 用户 UUID
	T_name                   string `orm:"size(256);null"`     // 标题
	T_VerifyTemplate_class   string `orm:"size(256);null"`     // 模版id
	T_VerifyTemplate_id      string `orm:"size(256);null"`     // 模版id
	T_deadline               string `orm:"size(256);null"`     // 截止时间
	T_scheme                 string `orm:"size(256);null"`     // 实施方案 负责人UUID
	T_collection             string `orm:"size(256);null"`     // 数据采集 负责人UUID
	T_reporting              string `orm:"size(256);null"`     // 报告编写 负责人UUID
	T_delivery               string `orm:"size(256);null"`     // 交付审核 负责人UUID
	T_scheme_state           int    `orm:"size(2);default(0)"` // 实施方案 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交 10 必填项已填写
	T_collection_state       int    `orm:"size(2);default(0)"` // 数据采集 状态 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4 APP已提交 5已通过(负责人) 6已退回(负责人)
	T_reporting_state        int    `orm:"size(2);default(0)"` // 报告编写 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交 6已点报告生成 10 必填项已填写
	T_delivery_state         int    `orm:"size(2);default(0)"` // 交付审核 状态 0 未完成 1 已完成 2 处理中
	T_marking_state          int    `orm:"size(2);default(0)"` // 验证标识 状态 0 未完成 1 已完成
	T_examining_report_state int    `orm:"size(2);default(0)"` // 检测报告 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交 10 必填项已填写
	T_original_record_state  int    `orm:"size(2);default(0)"` // 原始记录 状态 0 未完成 3 已通过(负责人) 4已退回(负责人) 5已提交 10 必填项已填写
	T_record                 string `orm:"type(text);null"`    // 领导备注

	T_collection_submit_time string `orm:"size(256);null"` // 数据采集 提交时间
	T_reporting_submit_time  string `orm:"size(256);null"` // 报告编写 提交时间

	T_VerifyDeviceDataStartTime string `orm:"size(256);null"` // 验证设备数据开始时间
	T_VerifyDeviceDataEndTime   string `orm:"size(256);null"` // 验证设备数据结束时间
	T_BindDeviceDataStartTime   string `orm:"size(256);null"` // 绑定设备数据开始时间
	T_BindDeviceDataEndTime     string `orm:"size(256);null"` // 绑定设备数据结束时间

	T_doc1                string `orm:"type(text);null"` // 封面
	T_pdf1                string `orm:"type(text);null"` // 验证方案
	T_pdf1_watermark      string `orm:"type(text);null"` // 验证方案 带水印
	T_pdf1_signature      string `orm:"type(text);null"` // 验证方案 带公章
	T_pdf1_elec_signature string `orm:"type(text);null"` // 验证方案 带电子签名及公章
	T_doc2                string `orm:"type(text);null"` // 报告
	T_pdf2                string `orm:"type(text);null"` // 验证报告
	T_pdf2_watermark      string `orm:"type(text);null"` // 验证报告 带水印
	T_pdf2_signature      string `orm:"type(text);null"` // 验证报告 带公章
	T_pdf2_elec_signature string `orm:"type(text);null"` // 验证报告 带电子签名及公章
	T_doc3                string `orm:"type(text);null"` // 证书
	T_pdf3                string `orm:"type(text);null"` // 证书
	T_pdf4                string `orm:"type(text);null"` // 验证标识
	T_pdf5                string `orm:"type(text);null"` // 检测报告
	T_pdf5_watermark      string `orm:"type(text);null"` // 检测报告 带水印
	T_pdf6                string `orm:"type(text);null"` // 原始记录

	T_Show  int `orm:"size(2);default(1)"`   // 0 隐藏   1 公开
	T_Visit int `orm:"size(200);default(0)"` // 浏览量
	T_State int `orm:"size(2);default(1)"`   // 0 删除   1 正常

	T_step int `orm:"size(2);default(-1)"` // 验证步骤

	T_sn                        string `orm:"size(256);null"` // sn
	T_CalibrationExpirationTime string `orm:"size(256);null"` // 校准到期时间

	T_project        string `orm:"size(256);null"` // 项目 负责人UUID
	T_province       string `orm:"size(256);null"` // 省
	T_city           string `orm:"size(256);null"` // 市
	T_district       string `orm:"size(256);null"` // 区
	T_province_code  string `orm:"size(256);null"` // 省 code
	T_city_code      string `orm:"size(256);null"` // 市 code
	T_district_code  string `orm:"size(256);null"` // 区 code
	T_category       string `orm:"size(256);null"` // 类别
	T_device_type    string `orm:"size(256);null"` // 设备类型
	T_volume         string `orm:"size(256);null"` // 规格/容积
	T_verify_type    string `orm:"size(256);null"` // 验证类型
	T_subject_matter string `orm:"size(256);null"` // 标的物名称
	T_temp_range     string `orm:"size(256);null"` // 验证温度范围
	T_report_number  string `orm:"size(256);null"` // 报告编号
	T_report_type    string `orm:"size(256);null"` // 报告类型
	T_belong_year    string `orm:"size(256);null"` // 所属年份

	T_start_time    string  `orm:"size(256);null"`  // 项目开始时间
	T_end_time      string  `orm:"size(256);null"`  // 结束时间 报告审核通过时间
	T_time_interval float64 `orm:"size(256);null"`  // 时间间隔 单位分钟
	T_reject_times  int     `orm:"size(256);null"`  // 驳回次数 客户退回方案和报告时
	T_reject_record string  `orm:"type(text);null"` // 驳回记录

	// 方案
	T_scheme_start_time    string  `orm:"size(256);null"`  // 验证方案开始时间 接收信息采集表的时间
	T_scheme_end_time      string  `orm:"size(256);null"`  // 验证方案结束时间 负责人审核通过后最后一次上传时间
	T_scheme_time_interval float64 `orm:"size(256);null"`  // 时间间隔 单位分钟
	T_scheme_overtime      float64 `orm:"size(256);null"`  // 验证方案超时时间 单位分钟
	T_scheme_signature     string  `orm:"type(text);null"` // 验证方案客户签字确认图片
	T_scheme_return_times  int     `orm:"size(256);null"`  // 验证方案退回次数
	T_scheme_audit_record  string  `orm:"type(text);null"` // 验证方案审核记录

	// 实施
	T_enter_area_time          string  `orm:"size(256);null"`  // 进场时间
	T_collection_start_time    string  `orm:"size(256);null"`  // 实施开始时间（app开始验证时间）
	T_collection_end_time      string  `orm:"size(256);null"`  // 实施结束时间 （审核通过后签字确认提交时间）
	T_collection_time_interval float64 `orm:"size(256);null"`  // 时间间隔 单位分钟
	T_collection_overtime      float64 `orm:"size(256);null"`  // 实施超时时间 单位分钟
	T_collection_signature     string  `orm:"type(text);null"` // 实施人员签字确认图片
	T_collection_return_times  int     `orm:"size(256);null"`  // 实施方案退回次数
	T_collection_audit_record  string  `orm:"type(text);null"` // 实施方案审核记录

	// 报告
	T_reporting_start_time    string  `orm:"size(256);null"`  // 验证报告开始时间 接收信息采集表的时间
	T_reporting_end_time      string  `orm:"size(256);null"`  // 验证报告结束时间 负责人审核通过前最后一次上传时间
	T_reporting_time_interval float64 `orm:"size(256);null"`  // 时间间隔 单位分钟
	T_reporting_overtime      float64 `orm:"size(256);null"`  // 验证报告超时时间 单位分钟
	T_reporting_signature     string  `orm:"type(text);null"` // 验证报告客户签字确认图片
	T_reporting_return_times  int     `orm:"size(256);null"`  // 验证报告退回次数
	T_reporting_audit_record  string  `orm:"type(text);null"` // 验证报告审核记录
	T_reporting_pass_time     string  `orm:"size(256);null"`  // 验证报告负责人通过时间

	// 检测报告
	T_examining_report_start_time    string  `orm:"size(256);null"`  // 检测报告开始时间 接收信息采集表的时间
	T_examining_report_end_time      string  `orm:"size(256);null"`  // 检测报告结束时间 负责人审核通过前最后一次上传时间
	T_examining_report_time_interval float64 `orm:"size(256);null"`  // 时间间隔 单位分钟
	T_examining_report_signature     string  `orm:"type(text);null"` // 检测报告客户签字确认图片
	T_examining_report_return_times  int     `orm:"size(256);null"`  // 检测报告退回次数
	T_examining_report_audit_record  string  `orm:"type(text);null"` // 检测报告审核记录

	// 原始记录
	T_original_record_start_time    string  `orm:"size(256);null"`  // 原始记录开始时间 接收信息采集表的时间
	T_original_record_end_time      string  `orm:"size(256);null"`  // 原始记录结束时间 负责人审核通过前最后一次上传时间
	T_original_record_time_interval float64 `orm:"size(256);null"`  // 时间间隔 单位分钟
	T_original_record_signature     string  `orm:"type(text);null"` // 原始记录客户签字确认图片
	T_original_record_return_times  int     `orm:"size(256);null"`  // 原始记录退回次数
	T_original_record_audit_record  string  `orm:"type(text);null"` // 原始记录审核记录

	T_device_quantity int `orm:"size(20);default(0)"`  //  终端数量 T_device_type=WZ 必填
	T_cnas            int `orm:"size(256);default(0)"` // 0-否 1-是

	T_cover  int    `orm:"size(20);default(0)"` // 是否覆盖询问
	T_backup string `orm:"size(256);null"`      // 历史数据记录

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

type Task_ struct {
	Id                       int
	T_Distributor_id         string // 信息采集ID
	T_class                  int    // 分类ID
	T_InfoCollection_id      string // 信息采集ID
	T_task_id                string // 任务ID
	T_uuid                   string // 用户 UUID
	T_user_name              string // 用户 UUID
	T_name                   string // 标题
	T_VerifyTemplate_class   string // 任务模版id
	T_VerifyTemplate_id      string // 任务模版id
	T_deadline               string // 截止时间
	T_scheme                 string // 实施方案 负责人UUID
	T_collection             string // 数据采集 负责人UUID
	T_reporting              string // 报告编写 负责人UUID
	T_delivery               string // 交付审核 负责人UUID
	T_scheme_state           int    // 实施方案 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_collection_state       int    // 数据采集 状态 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4-数据编辑已完成(已提交) 5已通过(负责人) 6已退回(负责人)
	T_reporting_state        int    // 报告编写 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_delivery_state         int    // 交付审核 状态 0 未完成 1 已完成 2 处理中
	T_marking_state          int    // 验证标识 状态 0 未完成 1 已完成
	T_examining_report_state int    // 检测报告 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_original_record_state  int    // 原始记录 状态 0 未完成 3 已通过(负责人) 4已退回(负责人) 5已提交

	T_scheme_state_str           string // 实施方案 状态 字符串
	T_collection_state_str       string // 数据采集 状态 字符串
	T_reporting_state_str        string // 报告编写 状态 字符串
	T_delivery_state_str         string // 交付审核 状态 字符串
	T_marking_state_str          string // 验证标识 状态 字符串
	T_examining_report_state_str string // 检测报告 状态 字符串
	T_original_record_state_str  string // 原始记录 状态 字符串
	T_scheme_name                string // 实施方案 负责人姓名
	T_collection_name            string // 数据采集 负责人姓名
	T_reporting_name             string // 报告编写 负责人姓名
	T_delivery_name              string // 交付审核 负责人姓名
	T_VerifyDeviceDataStartTime  string
	T_VerifyDeviceDataEndTime    string
	T_VerifyDeviceDataTime       [2]string // 验证设备数据开始-结束时间
	T_BindDeviceDataTime         [2]string // 绑定设备数据开始-结束时间
	T_doc1                       string    // 封面
	T_pdf1                       string    // 验证方案
	T_pdf1_signature             string    // 验证方案 带公章
	T_doc2                       string    // 报告
	T_pdf2                       string    // 报告
	T_pdf2_signature             string    // 报告 带公章
	T_doc3                       string    // 证书
	T_pdf3                       string    // 证书
	T_pdf4                       string    // 验证标识
	T_pdf5                       string    // 检测报告

	T_Show                      int    // 0 公开 1 隐藏
	T_Visit                     int    // 浏览量
	T_State                     int    // 0 删除 1 正常
	T_sn                        string // sn
	T_CalibrationExpirationTime string // 校准到期时间

	T_project       string                        // 项目 负责人UUID
	T_project_name  string                        // 项目 负责人姓名
	T_province      string                        // 省
	T_city          string                        // 市
	T_district      string                        // 区
	T_area          []string                      // 省市区
	T_province_code string                        // 省 code
	T_city_code     string                        // 市 code
	T_district_code string                        // 区 code
	T_area_code     []string                      // 省市区
	InfoCollection  InfoCollection.InfoCollection //信息采集
	T_record        string                        //

	T_device_type         string
	T_verify_type         string
	T_reporting_pass_time string

	T_device_quantity int
	T_cnas            int // cnas实验室

	T_cover  int    // 是否覆盖询问
	T_backup string // 历史数据记录

}

type Task_Stat struct {
	Id                  int
	T_Distributor_id    string // 信息采集ID
	T_class             int    // 分类ID
	T_InfoCollection_id string // 信息采集ID
	T_InfoTemplate_id   string // 信息采集模版ID

	T_task_id                    string // 任务ID
	T_uuid                       string // 用户 UUID
	T_user_name                  string // 用户 UUID
	T_name                       string // 标题
	T_VerifyTemplate_class       string // 任务模版id
	T_VerifyTemplate_id          string // 任务模版id
	T_deadline                   string // 截止时间
	T_scheme                     string // 实施方案 负责人UUID
	T_collection                 string // 数据采集 负责人UUID
	T_reporting                  string // 报告编写 负责人UUID
	T_delivery                   string // 交付审核 负责人UUID
	T_scheme_state               int    // 实施方案 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_collection_state           int    // 数据采集 状态 0 未完成 1 数据来源已完成 2 处理中 3 已采集-无数据 4-数据编辑已完成(已提交) 5已通过(负责人) 6已退回(负责人)
	T_reporting_state            int    // 报告编写 状态 0 未完成 1 已完成(客户通过) 2已退回(客户) 3已通过(负责人) 4已退回(负责人) 5已提交
	T_delivery_state             int    // 交付审核 状态 0 未完成 1 已完成 2 处理中
	T_marking_state              int    // 验证标识 状态 0 未完成 1 已完成
	T_scheme_state_str           string // 实施方案 状态 字符串
	T_collection_state_str       string // 数据采集 状态 字符串
	T_reporting_state_str        string // 报告编写 状态 字符串
	T_delivery_state_str         string // 交付审核 状态 字符串
	T_marking_state_str          string // 验证标识 状态 字符串
	T_examining_report_state_str string // 检测报告 状态 字符串
	T_original_record_state_str  string // 原始记录 状态 字符串
	T_scheme_name                string // 实施方案 负责人姓名
	T_collection_name            string // 数据采集 负责人姓名
	T_reporting_name             string // 报告编写 负责人姓名
	T_delivery_name              string // 交付审核 负责人姓名

	T_VerifyDeviceDataTime [2]string // 验证设备数据开始-结束时间
	T_BindDeviceDataTime   [2]string // 绑定设备数据开始-结束时间

	T_doc1 string // 封面
	T_pdf1 string // 验证方案
	T_doc2 string // 报告
	T_pdf2 string // 报告
	T_doc3 string // 证书
	T_pdf3 string // 证书
	T_pdf4 string // 验证标识

	T_Show                      int    // 0 公开 1 隐藏
	T_Visit                     int    // 浏览量
	T_State                     int    // 0 删除 1 正常
	T_sn                        string // sn
	T_CalibrationExpirationTime string // 校准到期时间

	T_project        string   // 项目 负责人UUID
	T_project_name   string   // 项目 负责人姓名
	T_province       string   // 省
	T_city           string   // 市
	T_district       string   // 区
	T_area           []string // 省市区
	T_province_code  string   // 省 code
	T_city_code      string   // 市 code
	T_district_code  string   // 区 code
	T_area_code      []string // 省市区
	T_category       string   // 类别
	T_device_type    string   // 设备类型
	T_volume         string   // 规格/容积
	T_verify_type    string   // 验证类型
	T_subject_matter string   // 标的物名称
	T_temp_range     string   // 验证温度范围
	T_report_number  string   // 报告编号
	T_report_type    string   // 报告类型
	T_start_time     string   // 项目开始时间
	T_end_time       string   // 结束时间 报告审核通过时间
	T_time_interval  string   // 时间间隔 单位分钟
	T_reject_times   int      // 驳回次数 客户退回方案和报告时
	T_reject_record  string   // 驳回记录
	// 方案
	T_scheme_start_time    string // 验证方案开始时间 接收信息采集表的时间
	T_scheme_end_time      string // 验证方案结束时间
	T_scheme_time_interval string // 时间间隔 单位分钟
	T_scheme_overtime      string // 验证方案超时时间 单位分钟
	T_scheme_signature     string // 验证方案客户签字确认图片
	T_scheme_return_times  int    // 验证方案退回次数
	T_scheme_audit_record  string // 验证方案审核记录
	// 实施
	T_enter_area_time          string // 进场时间
	T_collection_start_time    string // 实施开始时间（app开始验证时间）
	T_collection_end_time      string // 实施结束时间 （签字确认提交时间）
	T_collection_time_interval string // 时间间隔 单位分钟
	T_collection_overtime      string // 实施超时时间 单位分钟
	T_collection_signature     string // 实施人员签字确认图片
	T_collection_return_times  int    // 实施方案退回次数
	T_collection_audit_record  string // 实施方案审核记录
	// 报告
	T_reporting_start_time    string                          // 验证报告开始时间 接收信息采集表的时间
	T_reporting_end_time      string                          // 验证报告结束时间
	T_reporting_time_interval string                          // 时间间隔 单位分钟
	T_reporting_overtime      string                          // 验证报告超时时间 单位分钟
	T_reporting_signature     string                          // 验证报告客户签字确认图片
	T_reporting_return_times  int                             // 验证报告退回次数
	T_reporting_audit_record  string                          // 验证报告审核记录
	InfoCollection            InfoCollection.InfoCollection_R //信息菜鸡

	T_record string //

	T_device_quantity int
	T_cnas            int // cnas实验室

	T_cover  int    // 是否覆盖询问
	T_backup string // 历史数据记录

}

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

var redisCache_Task cache.Cache

func init() {

	//注册模型
	orm.RegisterModel(new(Task))

	config := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_"+"Task", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	logs.Println(config)
	var err error
	redisCache_Task, err = cache.NewCache("redis", config)
	if err != nil || redisCache_Task == nil {
		errMsg := "failed to init redis"
		logs.Println(errMsg, err)
	}
}

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

// selectPdf 根据条件选择PDF文件
// 返回选中的PDF和signature PDF
func selectPdf(watermark, original, signature, elecSignature string, isReturnedMoney bool, hasInfoCollection bool) (selectedPdf, selectedSignature string) {
	// 默认使用watermark版本
	selectedPdf = watermark

	// 如果满足以下任一条件，使用原始版本：退款状态、无InfoCollection、watermark为空
	if isReturnedMoney || !hasInfoCollection || len(watermark) == 0 {
		selectedPdf = original

		// 如果是退款状态，优先选择签名版本（电子签名优先于普通签名）
		if isReturnedMoney {
			if len(elecSignature) > 0 {
				selectedPdf = elecSignature
			} else if len(signature) > 0 {
				selectedPdf = signature
			}
		}
	}

	// 设置signature，如果为空则使用原始版本
	selectedSignature = signature
	if len(selectedSignature) == 0 {
		selectedSignature = original
	}

	return selectedPdf, selectedSignature
}

func TaskToTask_(T Task, userMap, adminMap map[string]string) (T_ Task_) {
	T_.Id = T.Id
	T_.T_Distributor_id = T.T_Distributor_id
	T_.T_class = T.T_class
	T_.T_InfoCollection_id = T.T_InfoCollection_id
	if len(T.T_InfoCollection_id) > 0 {
		T_.InfoCollection, _ = InfoCollection.Read_InfoCollection(T.T_InfoCollection_id)
	}

	T_.T_task_id = T.T_task_id
	T_.T_uuid = T.T_uuid
	T_.T_user_name = userMap[T.T_uuid]
	T_.T_name = T.T_name
	T_.T_VerifyTemplate_class = T.T_VerifyTemplate_class
	T_.T_VerifyTemplate_id = T.T_VerifyTemplate_id
	T_.T_deadline = T.T_deadline
	T_.T_scheme = T.T_scheme
	T_.T_collection = T.T_collection
	T_.T_reporting = T.T_reporting
	T_.T_delivery = T.T_delivery
	T_.T_project = T.T_project
	T_.T_scheme_state = T.T_scheme_state
	T_.T_collection_state = T.T_collection_state
	T_.T_reporting_state = T.T_reporting_state
	T_.T_delivery_state = T.T_delivery_state
	T_.T_marking_state = T.T_marking_state
	T_.T_examining_report_state = T.T_examining_report_state
	T_.T_original_record_state = T.T_original_record_state
	T_.T_scheme_state_str = TaskSchemeStateMap[T.T_scheme_state]
	T_.T_collection_state_str = TaskCollectionStateMap[T.T_collection_state]
	T_.T_reporting_state_str = TaskReportingStateMap[T.T_reporting_state]
	T_.T_delivery_state_str = TaskDeliveryStateMap[T.T_delivery_state]
	T_.T_marking_state_str = TaskMarkingStateMap[T.T_marking_state]
	T_.T_examining_report_state_str = TaskExaminingReportStateMap[T.T_examining_report_state]
	T_.T_original_record_state_str = TaskOriginalRecordStateMap[T.T_original_record_state]
	T_.T_scheme_name = adminMap[T.T_scheme]
	T_.T_collection_name = adminMap[T.T_collection]
	T_.T_reporting_name = adminMap[T.T_reporting]
	T_.T_delivery_name = adminMap[T.T_delivery]
	T_.T_project_name = adminMap[T.T_project]
	T_.T_VerifyDeviceDataStartTime = T.T_VerifyDeviceDataStartTime
	T_.T_VerifyDeviceDataEndTime = T.T_VerifyDeviceDataEndTime
	T_.T_VerifyDeviceDataTime = [2]string{T.T_VerifyDeviceDataStartTime, T.T_VerifyDeviceDataEndTime}
	T_.T_BindDeviceDataTime = [2]string{T.T_BindDeviceDataStartTime, T.T_BindDeviceDataEndTime}
	T_.T_doc1 = T.T_doc1
	T_.T_doc2 = T.T_doc2
	T_.T_doc3 = T.T_doc3

	// 处理PDF1和PDF2的选择逻辑
	isReturnedMoney := T_.InfoCollection.T_status == InfoCollection.InfoCollectionStatusReturnedMoney
	hasInfoCollection := len(T.T_InfoCollection_id) > 0

	T_.T_pdf1, T_.T_pdf1_signature = selectPdf(
		T.T_pdf1_watermark,
		T.T_pdf1,
		T.T_pdf1_signature,
		T.T_pdf1_elec_signature,
		isReturnedMoney,
		hasInfoCollection,
	)

	T_.T_pdf2, T_.T_pdf2_signature = selectPdf(
		T.T_pdf2_watermark,
		T.T_pdf2,
		T.T_pdf2_signature,
		T.T_pdf2_elec_signature,
		isReturnedMoney,
		hasInfoCollection,
	)
	T_.T_pdf3 = T.T_pdf3
	T_.T_pdf4 = T.T_pdf4
	T_.T_pdf5 = T.T_pdf5_watermark
	if T_.InfoCollection.T_status == InfoCollection.InfoCollectionStatusReturnedMoney || len(T.T_InfoCollection_id) == 0 || len(T.T_pdf2_watermark) == 0 {
	}
	T_.T_Show = T.T_Show
	T_.T_Visit = T.T_Visit
	T_.T_State = T.T_State

	T_.T_sn = T.T_sn
	T_.T_CalibrationExpirationTime = T.T_CalibrationExpirationTime
	T_.T_record = T.T_record

	T_.T_device_type = T.T_device_type
	T_.T_verify_type = T.T_verify_type
	T_.T_reporting_pass_time = T.T_reporting_pass_time
	T_.T_device_quantity = T.T_device_quantity
	T_.T_cnas = T.T_cnas

	T_.T_cover = T.T_cover
	T_.T_backup = T.T_backup

	return T_
}
func TaskToTask_Stat(T Task, userMap, adminMap map[string]string) (T_ Task_Stat) {
	T_.Id = T.Id
	T_.T_Distributor_id = T.T_Distributor_id
	T_.T_class = T.T_class
	T_.T_InfoCollection_id = T.T_InfoCollection_id
	if len(T.T_InfoCollection_id) > 0 {
		infoCollection, _ := InfoCollection.Read_InfoCollection(T.T_InfoCollection_id)
		T_.InfoCollection = InfoCollection.InfoCollectionToInfoCollection_R(infoCollection, userMap, adminMap, map[string]string{}, map[string]string{})
	}

	T_.T_task_id = T.T_task_id
	T_.T_uuid = T.T_uuid
	T_.T_user_name = userMap[T.T_uuid]
	T_.T_name = T.T_name
	T_.T_VerifyTemplate_class = T.T_VerifyTemplate_class
	T_.T_VerifyTemplate_id = T.T_VerifyTemplate_id
	T_.T_deadline = T.T_deadline
	T_.T_scheme = T.T_scheme
	T_.T_collection = T.T_collection
	T_.T_reporting = T.T_reporting
	T_.T_delivery = T.T_delivery
	T_.T_scheme_state = T.T_scheme_state
	T_.T_collection_state = T.T_collection_state
	T_.T_reporting_state = T.T_reporting_state
	T_.T_delivery_state = T.T_delivery_state
	T_.T_marking_state = T.T_marking_state
	T_.T_scheme_state_str = TaskSchemeStateMap[T.T_scheme_state]
	T_.T_collection_state_str = TaskCollectionStateMap[T.T_collection_state]
	T_.T_reporting_state_str = TaskReportingStateMap[T.T_reporting_state]
	T_.T_delivery_state_str = TaskDeliveryStateMap[T.T_delivery_state]
	T_.T_marking_state_str = TaskMarkingStateMap[T.T_marking_state]
	T_.T_examining_report_state_str = TaskExaminingReportStateMap[T.T_examining_report_state]
	T_.T_original_record_state_str = TaskOriginalRecordStateMap[T.T_original_record_state]

	T_.T_project_name = adminMap[T.T_project]
	T_.T_scheme_name = adminMap[T.T_scheme]
	T_.T_collection_name = adminMap[T.T_collection]
	T_.T_reporting_name = adminMap[T.T_reporting]
	T_.T_delivery_name = adminMap[T.T_delivery]
	T_.T_VerifyDeviceDataTime = [2]string{T.T_VerifyDeviceDataStartTime, T.T_VerifyDeviceDataEndTime}
	T_.T_BindDeviceDataTime = [2]string{T.T_BindDeviceDataStartTime, T.T_BindDeviceDataEndTime}
	T_.T_doc1 = T.T_doc1
	T_.T_doc2 = T.T_doc2
	T_.T_doc3 = T.T_doc3

	T_.T_pdf1 = T.T_pdf1_watermark
	if T_.InfoCollection.T_status == InfoCollection.InfoCollectionStatusReturnedMoney || len(T.T_InfoCollection_id) == 0 || len(T.T_pdf1_watermark) == 0 {
		T_.T_pdf1 = T.T_pdf1
	}
	T_.T_pdf2 = T.T_pdf2_watermark
	if T_.InfoCollection.T_status == InfoCollection.InfoCollectionStatusReturnedMoney || len(T.T_InfoCollection_id) == 0 || len(T.T_pdf2_watermark) == 0 {
		T_.T_pdf2 = T.T_pdf2
	}
	T_.T_pdf3 = T.T_pdf3
	T_.T_pdf4 = T.T_pdf4
	T_.T_Show = T.T_Show
	T_.T_Visit = T.T_Visit
	T_.T_State = T.T_State

	T_.T_sn = T.T_sn
	T_.T_CalibrationExpirationTime = T.T_CalibrationExpirationTime

	T_.T_project = T.T_project
	T_.T_province = T.T_province
	T_.T_city = T.T_city
	T_.T_district = T.T_district
	T_.T_area = []string{T.T_province, T.T_city, T.T_district}
	T_.T_province_code = T.T_province_code
	T_.T_city_code = T.T_city_code
	T_.T_district_code = T.T_district_code
	T_.T_area_code = []string{T.T_province_code, T.T_city_code, T.T_district_code}
	T_.T_category = T.T_category
	T_.T_device_type = T.T_device_type
	T_.T_volume = T.T_volume
	T_.T_verify_type = T.T_verify_type
	T_.T_subject_matter = T.T_subject_matter
	T_.T_temp_range = T.T_temp_range
	T_.T_report_number = T.T_report_number
	T_.T_report_type = T.T_report_type
	T_.T_start_time = T.T_start_time
	T_.T_end_time = T.T_end_time
	T_.T_time_interval = lib.ConvertMinutesToDHM(int(T.T_time_interval))
	T_.T_reject_times = T.T_reject_times
	T_.T_reject_record = T.T_reject_record

	// 方案
	T_.T_scheme_start_time = T.T_scheme_start_time
	T_.T_scheme_end_time = T.T_scheme_end_time

	if T.T_scheme_state == TaskSchemeStateSubmitted ||
		T.T_scheme_state == TaskSchemeStateClientPass ||
		T.T_scheme_state == TaskSchemeStatePass {
		T_.T_scheme_time_interval = lib.ConvertMinutesToDHM(int(T.T_scheme_time_interval))
		T_.T_scheme_overtime = lib.ConvertMinutesToDHM(int(T.T_scheme_overtime))
	}

	T_.T_scheme_signature = T.T_scheme_signature
	T_.T_scheme_return_times = T.T_scheme_return_times
	T_.T_scheme_audit_record = T.T_scheme_audit_record

	// 实施
	T_.T_enter_area_time = T.T_enter_area_time
	T_.T_collection_start_time = T.T_collection_start_time
	T_.T_collection_end_time = T.T_collection_end_time
	if T.T_collection_state == TaskCollectionStatePass ||
		T.T_collection_state == TaskCollectionStateSubmitted {
		T_.T_collection_time_interval = lib.ConvertMinutesToDHM(int(T.T_collection_time_interval))
		T_.T_collection_overtime = lib.ConvertMinutesToDHM(int(T.T_collection_overtime))
	}
	T_.T_collection_signature = T.T_collection_signature
	T_.T_collection_return_times = T.T_collection_return_times
	T_.T_collection_audit_record = T.T_collection_audit_record

	// 报告
	T_.T_reporting_start_time = T.T_reporting_start_time
	T_.T_reporting_end_time = T.T_reporting_end_time

	if T.T_reporting_state == TaskReportingStateClientPass ||
		T.T_reporting_state == TaskReportingStateSubmitted ||
		T.T_reporting_state == TaskReportingStateClientReturn ||
		T.T_reporting_state == TaskReportingStatePass {
		T_.T_reporting_time_interval = lib.ConvertMinutesToDHM(int(T.T_reporting_time_interval))
		T_.T_reporting_overtime = lib.ConvertMinutesToDHM(int(T.T_reporting_overtime))
	}

	T_.T_reporting_signature = T.T_reporting_signature
	T_.T_reporting_return_times = T.T_reporting_return_times
	T_.T_reporting_audit_record = T.T_reporting_audit_record
	T_.T_record = T.T_record
	T_.T_device_quantity = T.T_device_quantity
	T_.T_cnas = T.T_cnas

	T_.T_cover = T.T_cover
	T_.T_backup = T.T_backup

	return T_
}

// ---------------- Redis -------------------

func Redis_Task_Set(key string, r Task) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}
	err = redisCache_Task.Put(key, str, 24*time.Hour)
	if err != nil {
		logs.Println("set key:", key, ",value:", str, err)
	}
	return
}
func Redis_Task_Get(key string) (r Task, is bool) {
	if redisCache_Task.IsExist(key) {
		logs.Println("找到key:", key)
		v := redisCache_Task.Get(key)
		json.Unmarshal(v.([]byte), &r)
		return r, true
	}
	logs.Println("没有 找到key:", key)
	return Task{}, false
}
func Redis_Task_DelK(key string) (err error) {
	err = redisCache_Task.Delete(key)
	return
}

func Redis_Task_T_report_number_Set(key string) (err error) {
	err = redisCache_Task.Put(key, "", 24*time.Hour)
	if err != nil {
		logs.Println("set key:", key)
	}
	return
}
func Redis_Task_T_report_number_Get(key string) (is bool) {
	if redisCache_Task.IsExist(key) {
		return true
	}
	logs.Println("没有 找到key:", key)
	return false
}
func Redis_Task_T_report_number_DelK(key string) (err error) {
	err = redisCache_Task.Delete(key)
	return
}

// ---------------- 特殊方法 -------------------

// 获取 ById
func Read_Task_ById(id int) (r Task, is bool) {
	o := orm.NewOrm()
	r = Task{Id: id}
	err := o.Read(&r) // o.Read(&r,"Tokey") 如果不是 主键 就得指定字段名
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, false
	}
	return r, true
}

// 获取 By
func Read_Task(T_task_id string) (r Task, is bool) {
	if r, is = Redis_Task_Get(T_task_id); is == true {
		return r, true
	}

	o := orm.NewOrm()
	qs := o.QueryTable(new(Task))
	//err := qs.Filter("T_task_id", T_task_id).Filter("T_State", 1).One(&r)
	err := qs.Filter("T_task_id", T_task_id).Filter("T_State", 1).One(&r)
	if err != nil {
		return r, false
	}

	Redis_Task_Set(T_task_id, r)
	return r, true
}

// 批量获取任务
func Read_Task_List_By_TaskIds(taskIds []string) ([]Task, error) {
	cleanIds := make([]string, 0, len(taskIds))
	seen := make(map[string]struct{}, len(taskIds))
	for _, id := range taskIds {
		id = strings.TrimSpace(id)
		if len(id) == 0 {
			continue
		}
		if _, ok := seen[id]; ok {
			continue
		}
		seen[id] = struct{}{}
		cleanIds = append(cleanIds, id)
	}

	if len(cleanIds) == 0 {
		return []Task{}, nil
	}

	o := orm.NewOrm()
	var tasks []Task
	_, err := o.QueryTable(new(Task)).Filter("T_task_id__in", cleanIds).Filter("T_State", 1).All(&tasks)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return nil, err
	}

	return tasks, nil
}

// 获取 By T_uid
func Read_Task_ByUid(T_uid string) (r Task, is bool) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Task))
	err := qs.Filter("T_uid", T_uid).Filter("T_State", 1).One(&r)
	if err != nil {
		return r, false
	}
	return r, true
}

// 获取 By T_class
func Read_Task_ByT_class(T_class int) (r Task, is bool) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Task))
	err := qs.Filter("T_class", T_class).Filter("T_State", 1).One(&r)
	if err != nil {
		return r, false
	}
	return r, true
}

// 添加
func Add_Task(r Task) (string, bool) {
	o := orm.NewOrm()

	// 生成编号
	rand_x := 0
	for true {
		r.T_task_id = lib.GetRandstring(12, "abcdefghijklmnopqrstuvwxyz0123456789", int64(rand_x)) // 1,336,336
		err := o.Read(&r, "T_task_id")                                                             // o.Read(&r,"Tokey") 如果不是 主键 就得指定字段名
		if err != nil {
			break
		}
		rand_x += 1
	}

	_, err := o.Insert(&r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return "", false
	}
	if !CREATE_TaskData(r.T_task_id) {
		return "", false
	}
	Redis_Task_Set(r.T_task_id, r)
	return r.T_task_id, true
}
func Add_Task_Tool(r Task) (string, bool) {
	o := orm.NewOrm()
	_, err := o.Insert(&r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return "", false
	}
	return r.T_task_id, true
}

// 删除
func Delete_Task(v Task) bool {
	o := orm.NewOrm()
	if num, err := o.Delete(&v); err == nil {
		logs.Println("Number of records deleted in database:", num)
	} else {
		logs.Error(lib.FuncName(), err)
		return false
	}

	Redis_Task_DelK(v.T_task_id)
	return true
}

// 删除
func Delete_Task_(v Task) bool {
	o := orm.NewOrm()
	v.T_State = 0
	if num, err := o.Update(&v, "T_State"); err == nil {
		logs.Println("Number of records updated in database:", num)
	} else {
		logs.Error(lib.FuncName(), err)
		return false
	}

	Redis_Task_DelK(v.T_task_id)
	return true
}

// 修改
func Update_Task(m Task, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&m, cols...); err == nil {
		logs.Println("Number of records updated in database:", num)
		Redis_Task_Set(m.T_task_id, m)
		return true
	} else {
		logs.Error(lib.FuncName(), err)
	}
	return false
}

// 添加浏览量
func Add_Task_Visit(m Task) bool {
	o := orm.NewOrm()
	m.T_Visit += 1
	if num, err := o.Update(&m, "T_Visit"); err == nil {
		logs.Println("Number of records updated in database:", num)
		Redis_Task_Set(m.T_task_id, m)
		return true
	} else {
		logs.Error(lib.FuncName(), err)
	}
	return false
}

// 获取用户任务列表
func Read_Task_List_All() ([]Task, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task

	cond := orm.NewCondition()
	//cond1 := cond.And("T_name__icontains", T_name).And("T_State", 1)
	cond1 := cond.And("T_State", 1)

	qs.Limit(10, 0).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	return r, int(cnt)
}

// 获取用户任务列表
func Read_UserTask_List(T_uuid string, T_name string, userMap, adminMap map[string]string, page int, page_z int) ([]Task_, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task
	var offset int64
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}
	cond := orm.NewCondition()
	cond1 := cond.And("T_name__icontains", T_name).And("T_Show", 1).And("T_State", 1)
	if len(T_uuid) > 0 {
		cond1 = cond1.And("T_uuid", T_uuid)
	}

	qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	// 转换
	var TaskList []Task_
	for _, v := range r {
		TaskList = append(TaskList, TaskToTask_(v, userMap, adminMap))
	}

	return TaskList, int(cnt)
}

// 获取任务列表
func Read_Task_List(T_Distributor_id, T_uuid, T_admin, T_name, T_InfoCollection_id string, T_scheme, T_collection, T_reporting, T_delivery,
	T_scheme_state, T_collection_state, T_reporting_state, T_delivery_state, T_marking_state string,
	T_company_list []string, userMap, adminMap map[string]string, CreateTime string, page int, page_z int) ([]Task_, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task
	var offset int64
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}
	cond := orm.NewCondition()
	cond1 := cond.AndCond(cond.Or("T_name__icontains", T_name).Or("T_task_id__icontains", T_name)).And("T_State", 1)
	if len(T_uuid) > 0 {
		cond1 = cond1.And("T_uuid", T_uuid)
	}
	if len(T_Distributor_id) > 0 {
		cond1 = cond1.And("T_Distributor_id", T_Distributor_id)
	}
	if len(T_InfoCollection_id) > 0 {
		cond1 = cond1.And("T_InfoCollection_id", T_InfoCollection_id)
	}
	if len(T_admin) > 0 {
		cond1 = cond1.AndCond(cond.Or("T_scheme", T_admin).Or("T_collection", T_admin).
			Or("T_reporting", T_admin).Or("T_delivery", T_admin))
	}
	if len(T_company_list) > 0 {
		cond1 = cond1.And("T_uuid__in", T_company_list)
	}

	if len(T_scheme) > 0 {
		cond1 = cond1.And("T_scheme", T_scheme)
	}
	if len(T_collection) > 0 {
		cond1 = cond1.And("T_collection", T_collection)
	}
	if len(T_reporting) > 0 {
		cond1 = cond1.And("T_reporting", T_reporting)
	}
	if len(T_delivery) > 0 {
		cond1 = cond1.And("T_delivery", T_delivery)
	}

	if len(T_scheme_state) > 0 {
		cond1 = cond1.And("T_scheme_state", T_scheme_state)
	}
	if len(T_collection_state) > 0 {
		cond1 = cond1.And("T_collection_state", T_collection_state)
	}
	if len(T_reporting_state) > 0 {
		cond1 = cond1.And("T_reporting_state", T_reporting_state)
	}
	if len(T_delivery_state) > 0 {
		cond1 = cond1.And("T_delivery_state", T_delivery_state)
	}
	if len(T_marking_state) > 0 {
		cond1 = cond1.And("T_marking_state", T_marking_state)
	}
	if len(CreateTime) > 0 {
		CreateTime_s := strings.Split(CreateTime, "-")

		if len(CreateTime_s) == 2 {
			// 定义开始和结束时间
			start := time.Date(lib.To_int(CreateTime_s[0]), time.Month(lib.To_int(CreateTime_s[1])), 1, 0, 0, 0, 0, time.UTC)
			end := start.AddDate(0, 1, 0) // 下个月的第一天
			logs.Println("CreateTime_s:", start.Format("2006-01-02 15:04:05"), end.Format("2006-01-02 15:04:05"))
			cond1 = cond1.And("CreateTime__gte", start).And("CreateTime__lt", end)
		}

	}

	qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	// 转换
	var TaskList []Task_
	for _, v := range r {
		TaskList = append(TaskList, TaskToTask_(v, userMap, adminMap))
	}

	return TaskList, int(cnt)
}
func Read_Task_BySN(sn string) (r Task, err error) {
	if task, is := Redis_Task_Get(sn); is == true {
		return task, nil
	}

	o := orm.NewOrm()
	qs := o.QueryTable(new(Task))
	err = qs.Filter("T_sn", sn).Filter("T_State", 1).One(&r)
	if err != nil {
		return r, err
	}

	Redis_Task_Set(sn, r)
	return r, nil
}

// 修改
func Update_Task_T_InfoTemplate_id(T_InfoCollection_id, T_InfoTemplate_id string) error {
	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task
	o.Begin()
	qs.Filter("T_InfoCollection_id", T_InfoCollection_id).All(&r)
	for _, task := range r {
		task.T_InfoTemplate_id = T_InfoTemplate_id
		if _, err := o.Update(&task, "T_InfoTemplate_id"); err == nil {
			Redis_Task_Set(task.T_task_id, task)
		} else {
			o.Rollback()
			logs.Error(lib.FuncName(), err)
			return err
		}
	}
	o.Commit()
	return nil

}

func Add_AuditRecord(T_audit_record string, T_uuid, T_admin string, T_scheme_state int, T_reason string, T_type string) (string, error) {

	auditRecord := AuditRecord{
		T_uuid:   T_uuid,
		T_admin:  T_admin,
		T_state:  T_scheme_state,
		T_reason: T_reason,
		T_type:   T_type,
		T_time:   time.Now().Format("2006-01-02 15:04:05"),
	}

	var returnRecordList []AuditRecord
	if len(T_audit_record) > 0 {
		err := json.Unmarshal([]byte(T_audit_record), &returnRecordList)
		if err != nil {
			logs.Error("JSON 反序列化失败:", err)
			return "", errors.New("JSON 反序列化失败")
		}
	}

	returnRecordList = append(returnRecordList, auditRecord)
	returnRecordJson, err := json.Marshal(returnRecordList)
	if err != nil {
		logs.Error("JSON 反序列化失败:", err)
		return "", errors.New("JSON 反序列化失败")
	}
	return string(returnRecordJson), nil
}

// 获取项目负责人列表
func Get_Task_UserList(T_type string) []string {
	o := orm.NewOrm()
	var err error
	var pl_lists []string
	switch T_type {
	case "T_project":
		_, err = o.Raw("SELECT DISTINCT t_project FROM task LIMIT 0,1000").QueryRows(&pl_lists)
	case "T_scheme":
		_, err = o.Raw("SELECT DISTINCT t_scheme FROM task LIMIT 0,1000").QueryRows(&pl_lists)
	case "T_collection":
		_, err = o.Raw("SELECT DISTINCT t_collection FROM task LIMIT 0,1000").QueryRows(&pl_lists)
	case "T_reporting":
		_, err = o.Raw("SELECT DISTINCT t_reporting FROM task LIMIT 0,1000").QueryRows(&pl_lists)

	}
	if err != nil {
		logs.Error("获取项目负责人列表失败:", err)
	}
	return pl_lists
}

func Read_Task_Stat(T_Distributor_id, T_uuid, T_admin, T_name, T_InfoCollection_id string, 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 string,
	T_company_list []string, userMap, adminMap map[string]string, CreateTime string, page int, page_z int) ([]Task_Stat, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task
	var offset int64
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}
	cond := orm.NewCondition()
	cond1 := cond.AndCond(cond.Or("T_name__icontains", T_name).Or("T_task_id__icontains", T_name)).And("T_State", 1)
	if len(T_uuid) > 0 {
		cond1 = cond1.And("T_uuid", T_uuid)
	}
	if len(T_Distributor_id) > 0 {
		cond1 = cond1.And("T_Distributor_id", T_Distributor_id)
	}
	if len(T_InfoCollection_id) > 0 {
		cond1 = cond1.And("T_InfoCollection_id", T_InfoCollection_id)
	}
	if len(T_admin) > 0 {
		cond1 = cond1.AndCond(cond.Or("T_scheme", T_admin).Or("T_collection", T_admin).
			Or("T_reporting", T_admin).Or("T_delivery", T_admin))
	}
	if len(T_company_list) > 0 {
		cond1 = cond1.And("T_uuid__in", T_company_list)
	}

	if len(T_project) > 0 {
		cond1 = cond1.And("T_project", T_project)
	}
	if len(T_scheme) > 0 {
		cond1 = cond1.And("T_scheme", T_scheme)
	}
	if len(T_collection) > 0 {
		cond1 = cond1.And("T_collection", T_collection)
	}
	if len(T_reporting) > 0 {
		cond1 = cond1.And("T_reporting", T_reporting)
	}
	if len(T_delivery) > 0 {
		cond1 = cond1.And("T_delivery", T_delivery)
	}

	if len(T_scheme_state) > 0 {
		cond1 = cond1.And("T_scheme_state", T_scheme_state)
	}
	if len(T_collection_state) > 0 {
		cond1 = cond1.And("T_collection_state", T_collection_state)
	}
	if len(T_reporting_state) > 0 {
		cond1 = cond1.And("T_reporting_state", T_reporting_state)
	}
	if len(T_delivery_state) > 0 {
		cond1 = cond1.And("T_delivery_state", T_delivery_state)
	}
	if len(T_marking_state) > 0 {
		cond1 = cond1.And("T_marking_state", T_marking_state)
	}
	if len(CreateTime) > 0 {
		CreateTime_s := strings.Split(CreateTime, "-")

		if len(CreateTime_s) == 2 {
			// 定义开始和结束时间
			start := time.Date(lib.To_int(CreateTime_s[0]), time.Month(lib.To_int(CreateTime_s[1])), 1, 0, 0, 0, 0, time.UTC)
			end := start.AddDate(0, 1, 0) // 下个月的第一天
			logs.Println("CreateTime_s:", start.Format("2006-01-02 15:04:05"), end.Format("2006-01-02 15:04:05"))
			cond1 = cond1.And("CreateTime__gte", start).And("CreateTime__lt", end)
		}

	}
	if page_z == 9999 {
		qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	} else {
		qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	}
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	// 转换
	var TaskList []Task_Stat
	for _, v := range r {
		TaskList = append(TaskList, TaskToTask_Stat(v, userMap, adminMap))
	}

	return TaskList, int(cnt)
}

// 获取用户任务列表
func Read_UserTask_StatisticalRanking(T_uuid, T_scheme string) []Task {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task

	cond := orm.NewCondition()
	//cond_T_uuid := orm.NewCondition().Or("T_scheme", T_uuid).Or("T_collection", T_uuid).Or("T_reporting", T_uuid)
	//cond1 := cond.And("T_name__icontains", T_name).And("T_State", 1)
	cond1 := cond.And("T_State", 1).And(T_scheme, T_uuid)

	qs.Limit(500, 0).SetCond((*orm2.Condition)(cond1)).OrderBy("-UpdateTime").All(&r)
	qs.SetCond((*orm2.Condition)(cond1)).Count()

	return r
}

// 获取任务列表
func Read_Task_List_For_ERP(start_time, end_time string) ([]Task_, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task

	cond := orm.NewCondition()
	cond1 := cond.And("T_State", 1).And("T_reporting_state", TaskReportingStatePass)
	if len(start_time) > 0 {
		cond1 = cond1.And("T_reporting_pass_time__gte", start_time)
	}
	if len(end_time) > 0 {
		cond1 = cond1.And("T_reporting_pass_time__lte", end_time)
	}

	qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	// 转换
	var TaskList []Task_
	for _, v := range r {
		TaskList = append(TaskList, TaskToTask_(v, map[string]string{}, map[string]string{}))
	}

	return TaskList, int(cnt)
}

// 获取任务列表
func Read_Task_List_For_ERP_By_Type(T_type string, start_time, end_time string) ([]Task_, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task

	cond := orm.NewCondition()
	cond1 := cond.And("T_State", 1)

	if T_type == "collection" {
		cond1 = cond1.And("T_collection_submit_time__gte", start_time).And("T_collection_submit_time__lte", end_time)
	}
	if T_type == "reporting" {
		cond1 = cond1.And("T_reporting_submit_time__gte", start_time).And("T_reporting_submit_time__lte", end_time)
	}

	qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	// 转换
	var TaskList []Task_
	for _, v := range r {
		TaskList = append(TaskList, TaskToTask_(v, map[string]string{}, map[string]string{}))
	}

	return TaskList, int(cnt)
}

// GenerateNextT_report_number 生成下一个编号
func GenerateNextT_report_number(T_device_type string) (string, error) {
	o := orm.NewOrm()

	// 获取当前年份和季度
	currentYear := time.Now().Year()
	currentQuarter := int(time.Now().Month()-1)/3 + 1 // 1,2,3,4 对应 A,B,C,D
	quarterChar := string(rune('A' + currentQuarter - 1))
	yearQuarter := fmt.Sprintf("%s%d%s", T_device_type, currentYear, quarterChar)
	var lastRecord Task
	err := o.QueryTable(new(Task)).
		Filter("T_report_number__startswith", yearQuarter).
		OrderBy("-T_report_number").
		Limit(1).
		One(&lastRecord)
	if err != nil && err.Error() != orm.ErrNoRows.Error() {
		return "", fmt.Errorf("报告编号-查询当前年季度最后编号失败: %v", err)
	}

	// 初始化新编号
	var newSeq = 1

	if lastRecord.T_report_number != "" {
		// 提取序号部分，例如 "2025A00001" -> "00001"
		lastSeqStr := lastRecord.T_report_number[len(lastRecord.T_report_number)-5:]
		lastSeq, _ := strconv.Atoi(lastSeqStr)
		newSeq = lastSeq + 1
	}

	var newCode string
	for {
		// 格式化新编号
		newCode = fmt.Sprintf("%s%05d", yearQuarter, newSeq)
		if Redis_Task_T_report_number_Get(newCode) {
			newSeq += 1
		} else {
			err = Redis_Task_T_report_number_Set(newCode)
			if err != nil {
				return "", fmt.Errorf("报告编号-存入redis失败: %v", err)
			}
			break
		}
	}

	return newCode, nil
}

// 获取 By
func Read_TaskbyT_report_number(T_report_number string) (r Task, is bool) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Task))
	//err := qs.Filter("T_task_id", T_task_id).Filter("T_State", 1).One(&r)
	err := qs.Filter("T_report_number", T_report_number).Filter("T_State", 1).One(&r)
	if err != nil {
		return r, false
	}

	return r, true
}

func Read_Task_List_For_Watermark(pdfType string) ([]Task, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task

	cond := orm.NewCondition()
	if pdfType == "pdf1" {

		cond = cond.And("T_State", 1).And("T_pdf1__icontains", ".pdf").And("t_pdf1_signature__isnull", true)
	}

	if pdfType == "pdf2" {

		cond = cond.And("T_State", 1).And("T_pdf2__icontains", ".pdf").And("t_pdf2_signature__isnull", true)
	}

	qs.SetCond((*orm2.Condition)(cond)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond)).Count()

	return r, int(cnt)
}

func Read_Task_List_By_T_InfoCollection_id(T_InfoCollection_id string) ([]Task, int) {

	o := orm.NewOrm()

	qs := o.QueryTable(new(Task))
	var r []Task

	cond := orm.NewCondition()
	cond1 := cond.And("T_InfoCollection_id", T_InfoCollection_id).And("T_State", 1)

	qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	return r, int(cnt)
}

// 删除的重复数据
func DeleteDeduplicate(T_task_id string) (int64, error) {
	localOrm := orm.NewOrm()
	tb_name := "z_task_data_" + T_task_id
	var cnt int64
	// 创建临时表
	sqlCreate := "CREATE TABLE `tmp_table_" + T_task_id + "` AS (SELECT MIN(`ID`) AS `min_id` FROM " + tb_name + " GROUP BY `t_sn`,`t_id`,`t_time`);"
	_, err := localOrm.Raw(sqlCreate).Exec()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return cnt, err
	}
	sqlDelete := "DELETE FROM " + tb_name + "  WHERE `ID` NOT IN (SELECT `min_id` FROM `tmp_table_" + T_task_id + "`);"
	res, err := localOrm.Raw(sqlDelete).Exec()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return cnt, err
	}
	cnt, _ = res.RowsAffected()
	sqlDrop := "DROP TABLE `tmp_table_" + T_task_id + "`;"
	_, err = localOrm.Raw(sqlDrop).Exec()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return cnt, err
	}
	return cnt, nil
}

// 修正秒数
func CorrectionSecond(T_task_id string) error {
	o := orm.NewOrm()
	tb_name := "z_task_data_" + T_task_id
	// 创建临时表
	sqlCreate := "UPDATE " + tb_name + " SET t_time = t_time - INTERVAL SECOND(t_time) SECOND WHERE SECOND(t_time) != 0"
	_, err := o.Raw(sqlCreate).Exec()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return err
	}

	return nil
}

// 查询T_uuid匹配且T_InfoCollection_id为空的任务列表
func Read_Task_List_By_T_uuid_And_Empty_InfoCollection_id(T_uuid string) ([]Task, int) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Task))
	var r []Task

	cond := orm.NewCondition()
	// 查询T_InfoCollection_id为NULL或空字符串
	cond1 := cond.And("T_uuid", T_uuid).And("T_State", 1).AndCond(cond.Or("T_InfoCollection_id__isnull", true).Or("T_InfoCollection_id", ""))

	qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	return r, int(cnt)
}

// 批量更新任务的T_InfoCollection_id
func Update_Task_T_InfoCollection_id_By_T_uuid(T_uuid, T_InfoCollection_id string) error {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Task))
	var r []Task
	o.Begin()

	cond := orm.NewCondition()
	cond1 := cond.And("T_uuid", T_uuid).And("T_State", 1).AndCond(cond.Or("T_InfoCollection_id__isnull", true).Or("T_InfoCollection_id", ""))
	qs.SetCond((*orm2.Condition)(cond1)).All(&r)

	for _, task := range r {
		task.T_InfoCollection_id = T_InfoCollection_id
		if _, err := o.Update(&task, "T_InfoCollection_id"); err == nil {
			Redis_Task_Set(task.T_task_id, task)
		} else {
			o.Rollback()
			logs.Error(lib.FuncName(), err)
			return err
		}
	}
	o.Commit()
	return nil
}