ERP_storage/controllers/Validation.go

package controllers

import (
	"ERP_storage/Nats/NatsServer"
	"ERP_storage/conf"
	"ERP_storage/logs"
	"ERP_storage/models/Account"
	"ERP_storage/models/Basic"
	"ERP_storage/models/Stock"
	"ERP_storage/models/validationtool"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/beego/beego/v2/adapter/orm"
	beego "github.com/beego/beego/v2/server/web"
	"github.com/xuri/excelize/v2"
	userlibs "gogs.baozhida.cn/zoie/ERP_libs/User"
	"gogs.baozhida.cn/zoie/ERP_libs/lib"
	"math"
	"net/url"
	"os"
	"strconv"
	"strings"
	"time"
)

type ValidationController struct {
	beego.Controller
	User userlibs.User
}

func (c *ValidationController) Prepare() {
	c.User = *Account.User_r
}

func (c *ValidationController) AddValidation() {
	var ValidationList []validationtool.AddValidationTool
	errs := json.Unmarshal(c.Ctx.Input.RequestBody, &ValidationList)
	if errs != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "json 序列化失败!", Data: nil}
		c.ServeJSON()
		return
	}

	o := orm.NewOrm()
	o.Begin() // 开始事务
	vali := validationtool.NewValidationTool(o)
	valiRecord := validationtool.NewValidationToolRecord(o)
	BatchNumber := time.Now().Format("2006-01-02 15:04:05")
	for _, tool := range ValidationList {
		if len(tool.T_sn) == 0 {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "T_sn不能为空!", Data: nil}
			c.ServeJSON()
			return
		}
		validation, err := vali.ReadValidationBytSn(tool.T_sn)
		if err != nil && !errors.Is(err, orm.ErrNoRows) {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "查询失败!", Data: nil}
			c.ServeJSON()
			return
		} else if errors.Is(err, orm.ErrNoRows) {
			var validataiontool validationtool.ValidationTool
			user := Stock.Read_MqttUser(tool.T_sn)
			validataiontool.T_iccid = user.Iccid
			validataiontool.T_imei = user.Imei
			validataiontool.T_uuid = c.User.T_uuid
			validataiontool.Validationnumber = tool.Validationnumber
			validataiontool.T_sn = tool.T_sn
			validataiontool.T_remark = tool.T_remark
			validataiontool.T_state = validationtool.ValidationToolStateStockIn
			validataiontool.T_class = tool.T_class
			validataiontool.UpdateTime = time.Now()
			_, err = vali.ADDValidationTool(validataiontool)
			if err != nil {
				o.Rollback() // 回滚事务
				c.Data["json"] = lib.JSONS{Code: 1201, Msg: "入库失败!", Data: nil}
				c.ServeJSON()
				return
			}
			_, err = valiRecord.ADD(validataiontool, BatchNumber)
			if err != nil {
				o.Rollback() // 回滚事务
				c.Data["json"] = lib.JSONS{Code: 1201, Msg: "保存历史记录失败!", Data: nil}
				c.ServeJSON()
				return
			}
		}

		//修改设备状态
		validation.T_state = validationtool.ValidationToolStateStockIn
		cols := []string{"T_state"}
		if len(tool.T_remark) != 0 {
			validation.T_remark = tool.T_remark
			cols = append(cols, "T_remark")
		} else {
			validation.T_remark = ""
			cols = append(cols, "T_remark")
		}
		if len(tool.Validationnumber) != 0 {
			validation.Validationnumber = tool.Validationnumber
			cols = append(cols, "validationnumber")
		}

		_, err = valiRecord.ADD(validation, BatchNumber)
		if err != nil {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "保存历史记录失败!", Data: nil}
			c.ServeJSON()
			return
		}

		validation.LendUser = ""
		cols = append(cols, "LendUser")

		validation.T_project = ""
		cols = append(cols, "T_project")
		err = vali.UpdateValidationTool(validation, cols...)
		if err != nil {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "入库失败!", Data: nil}
			c.ServeJSON()
			return
		}

	}
	o.Commit() // 提交事务
	NatsServer.AddUserLogs(c.User.T_uuid, "验证工具", "添加", ValidationList)
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "入库成功!", Data: nil}
	c.ServeJSON()
	return

}

func (c *ValidationController) ValidationList() {

	// 分页参数 初始化
	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_state := c.GetString("T_state")
	validationnumber := c.GetString("Validationnumber")
	T_sn := c.GetString("T_sn")
	t_iccid := c.GetString("t_iccid")
	t_imei := c.GetString("t_imei")
	LendUser := c.GetString("LendUser")
	T_project := c.GetString("T_project")
	T_class := c.GetString("T_class")
	vali := validationtool.NewValidationTool(orm.NewOrm())

	R_List, R_cnt := vali.Read_Validation_List(validationnumber, T_sn, t_iccid, t_imei, T_state, LendUser, T_project, T_class, page, page_z)

	var r_jsons lib.R_JSONS
	r_jsons.Num = R_cnt
	r_jsons.Data = R_List
	r_jsons.Page = page
	r_jsons.Page_size = int(math.Ceil(float64(R_cnt) / float64(page_z)))

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: r_jsons}
	c.ServeJSON()
	return
}
func (c *ValidationController) DeleteValidationTool() {
	id := c.GetString("t_sn")
	if len(id) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "t_sn不能为空!", Data: nil}
		c.ServeJSON()
		return
	}
	vali := validationtool.NewValidationTool(orm.NewOrm())
	err := vali.DeleteValidationTool(id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "删除失败!", Data: nil}
		c.ServeJSON()
		return
	}
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "删除成功!", Data: nil}
	c.ServeJSON()
}

// 出库
func (c *ValidationController) UpdateValidationTool() {
	var lendValidationList []validationtool.LendValidationTool
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &lendValidationList)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "json 序列化失败!", Data: nil}
		c.ServeJSON()
		return
	}
	o := orm.NewOrm()
	o.Begin()
	vali := validationtool.NewValidationTool(o)
	valiRecord := validationtool.NewValidationToolRecord(o)
	BatchNumber := time.Now().Format("2006-01-02 15:04:05")

	for _, tool := range lendValidationList {
		if len(tool.T_sn) <= 0 {
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "T_sn不能为空!", Data: nil}
			c.ServeJSON()
			return
		}
		validation, err2 := vali.ReadValidationBytSn(tool.T_sn)
		sprintf := fmt.Sprintf("当前sn:%v 未入库", tool.T_sn)
		if err2 != nil || validation.T_state != validationtool.ValidationToolStateStockIn {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: sprintf, Data: nil}
			c.ServeJSON()
			return
		}
		if validation.T_state == validationtool.ValidationToolStateStockOut {
			continue
		}
		//修改设备状态
		validation.T_state = validationtool.ValidationToolStateStockOut
		cols := []string{"t_state"}
		if len(tool.T_remark) != 0 {
			validation.T_remark = tool.T_remark
			cols = append(cols, "T_remark")
		}
		if len(tool.Validationnumber) != 0 {
			validation.Validationnumber = tool.Validationnumber
			cols = append(cols, "validationnumber")
		}
		if len(tool.LendUser) != 0 {
			validation.LendUser = tool.LendUser
			cols = append(cols, "LendUser")
		}
		if len(tool.T_project) != 0 {
			validation.T_project = tool.T_project
			cols = append(cols, "T_project")
		}
		err = vali.UpdateValidationTool(validation, cols...)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "修改失败!", Data: nil}
			c.ServeJSON()
			return
		}

		_, err = valiRecord.ADD(validation, BatchNumber)
		if err != nil {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "保存历史记录失败!", Data: nil}
			c.ServeJSON()
			return
		}
	}
	err = o.Commit() // 提交事务
	if err != nil {
		o.Rollback() // 回滚事务
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "提交事务失败!", Data: nil}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证工具", "出库", lendValidationList)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "修改成功!", Data: nil}
	c.ServeJSON()
	return
}

// 报废
func (c *ValidationController) ScrapValidationTool() {
	var lendValidationList []validationtool.LendValidationTool
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &lendValidationList)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "json 序列化失败!", Data: nil}
		c.ServeJSON()
		return
	}
	o := orm.NewOrm()
	vali := validationtool.NewValidationTool(o)
	valiRecord := validationtool.NewValidationToolRecord(o)
	BatchNumber := time.Now().Format("2006-01-02 15:04:05")

	o.Begin()
	for _, tool := range lendValidationList {
		if len(tool.T_sn) <= 0 {
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "T_sn不能为空!", Data: nil}
			c.ServeJSON()
			return
		}
		validation, errs := vali.ReadValidationBytSn(tool.T_sn)
		if errs != nil {
			o.Rollback()
			if errs.Error() == orm.ErrNoRows.Error() {
				c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("当前sn:%v 未入库", tool.T_sn), Data: nil}
				c.ServeJSON()
				return
			} else {
				c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("查询sn:%v 失败", tool.T_sn), Data: nil}
				c.ServeJSON()
				return
			}
		}

		//修改设备状态
		validation.T_state = validationtool.ValidationToolStateStockScrap
		cols := []string{"t_state"}
		if len(tool.T_remark) != 0 {
			validation.T_remark = tool.T_remark
			cols = append(cols, "T_remark")
		}
		if len(tool.Validationnumber) != 0 {
			validation.Validationnumber = tool.Validationnumber
			cols = append(cols, "validationnumber")
		}
		if len(tool.LendUser) != 0 {
			validation.LendUser = tool.LendUser
			cols = append(cols, "LendUser")
		}
		if len(tool.T_project) != 0 {
			validation.T_project = tool.T_project
			cols = append(cols, "T_project")
		}
		err = vali.UpdateValidationTool(validation, cols...)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "修改失败!", Data: nil}
			c.ServeJSON()
			return
		}

		_, err = valiRecord.ADD(validation, BatchNumber)
		if err != nil {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "保存历史记录失败!", Data: nil}
			c.ServeJSON()
			return
		}

	}
	err = o.Commit() // 提交事务
	if err != nil {
		o.Rollback() // 回滚事务
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "提交事务失败!", Data: nil}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证工具", "报废", lendValidationList)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "提交成功!", Data: nil}
	c.ServeJSON()
	return
}

// 维修
func (c *ValidationController) RepairValidationTool() {
	var lendValidationList []validationtool.LendValidationTool
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &lendValidationList)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "json 序列化失败!", Data: nil}
		c.ServeJSON()
		return
	}
	o := orm.NewOrm()
	o.Begin()
	vali := validationtool.NewValidationTool(o)
	valiRecord := validationtool.NewValidationToolRecord(o)
	BatchNumber := time.Now().Format("2006-01-02 15:04:05")

	for _, tool := range lendValidationList {
		if len(tool.T_sn) <= 0 {
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "T_sn不能为空!", Data: nil}
			c.ServeJSON()
			return
		}
		validation, errs := vali.ReadValidationBytSn(tool.T_sn)
		if errs != nil {
			o.Rollback()
			if errs.Error() == orm.ErrNoRows.Error() {
				c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("当前sn:%v 未入库", tool.T_sn), Data: nil}
				c.ServeJSON()
				return
			} else {
				c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("查询sn:%v 失败", tool.T_sn), Data: nil}
				c.ServeJSON()
				return
			}
		}
		//修改设备状态
		validation.T_state = validationtool.ValidationToolStateStockRepair
		cols := []string{"t_state"}
		if len(tool.T_remark) != 0 {
			validation.T_remark = tool.T_remark
			cols = append(cols, "T_remark")
		}
		if len(tool.Validationnumber) != 0 {
			validation.Validationnumber = tool.Validationnumber
			cols = append(cols, "validationnumber")
		}
		if len(tool.LendUser) != 0 {
			validation.LendUser = tool.LendUser
			cols = append(cols, "LendUser")
		}
		if len(tool.T_project) != 0 {
			validation.T_project = tool.T_project
			cols = append(cols, "T_project")
		}
		err = vali.UpdateValidationTool(validation, cols...)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "修改失败!", Data: nil}
			c.ServeJSON()
			return
		}

		_, err = valiRecord.ADD(validation, BatchNumber)
		if err != nil {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "保存历史记录失败!", Data: nil}
			c.ServeJSON()
			return
		}

	}
	err = o.Commit() // 提交事务
	if err != nil {
		o.Rollback() // 回滚事务
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "提交事务失败!", Data: nil}
		c.ServeJSON()
		return
	}
	NatsServer.AddUserLogs(c.User.T_uuid, "验证工具", "维修", lendValidationList)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "提交成功!", Data: nil}
	c.ServeJSON()
	return
}

// GetValidationToolBySn 根据sn获取设备信息
func (c *ValidationController) GetValidationToolBySn() {
	sn := c.GetString("sn")
	if len(sn) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "sn不能为空!", Data: nil}
		c.ServeJSON()
		return
	}
	vali := validationtool.NewValidationTool(orm.NewOrm())
	r, err := vali.ReadValidationBytSn(sn)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "当前设备不存在!", Data: nil}
		c.ServeJSON()
		return
	}
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "成功!", Data: r}
	c.ServeJSON()
}

// UpdateValidationToolBySn  根据sn修改设备信息
func (c *ValidationController) UpdateValidationToolBySn() {
	sn := c.GetString("T_sn")
	Id := c.GetString("Id")
	Validationnumber := c.GetString("Validationnumber")
	T_remark := c.GetString("T_remark")
	T_state, _ := c.GetInt("T_state")
	T_class, _ := c.GetInt("T_class")
	if len(sn) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "sn不能为空!", Data: nil}
		c.ServeJSON()
		return
	}
	if len(Id) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "Id不能为空!", Data: nil}
		c.ServeJSON()
		return
	}

	vali := validationtool.NewValidationTool(orm.NewOrm())
	valiRecord := validationtool.NewValidationToolRecord(orm.NewOrm())

	r, err := vali.ReadValidationById(Id)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "当前设备不存在!", Data: nil}
		c.ServeJSON()
		return
	}

	cols := []string{}
	if len(Validationnumber) > 0 {
		r.Validationnumber = Validationnumber
		cols = append(cols, "Validationnumber")
	}
	if len(T_remark) > 0 {
		r.T_remark = T_remark
		cols = append(cols, "T_remark")
	}
	if T_state > 0 {
		r.T_state = T_state
		cols = append(cols, "T_state")
	}
	if T_class > 0 {
		r.T_class = T_class
		cols = append(cols, "T_class")

	}

	if !strings.EqualFold(r.T_sn, sn) {
		r.T_sn = sn
		user := Stock.Read_MqttUser(sn)
		r.T_iccid = user.Iccid
		r.T_imei = user.Imei
		cols = append(cols, "T_sn", "T_iccid", "T_imei")

	}
	err = vali.UpdateValidationTool(r, cols...)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "当前设备不存在!", Data: nil}
		c.ServeJSON()
		return
	}

	BatchNumber := time.Now().Format("2006-01-02 15:04:05")

	_, err = valiRecord.ADD(r, BatchNumber)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "保存历史记录失败!", Data: nil}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证工具", "通过sn修改验证工具", r)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "成功!", Data: nil}
	c.ServeJSON()
}
func (c *ValidationController) ImportExcel() {
	// 获取上传的文件
	vali := validationtool.NewValidationTool(orm.NewOrm())
	f, _, err := c.GetFile("excelFile")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "读取文件失败!", Data: nil}
		c.ServeJSON()
		return
	}
	defer f.Close()

	// 读取 Excel 文件
	reader, err := excelize.OpenReader(f)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "打开文件失败!", Data: nil}
		c.ServeJSON()
		return
	}
	defer func() {
		if err := reader.Close(); err != nil {
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "关闭文件失败!", Data: nil}
			c.ServeJSON()
			return
		}
	}()
	// 读取工作表中的数据
	rows, err := reader.GetRows("Sheet1")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "读取文件失败!", Data: nil}
		c.ServeJSON()
		return
	}
	for i, row := range rows {
		if i == 0 {
			continue // 忽略第一排
		}
		if len(row) >= 4 {
			atoi, _ := strconv.Atoi(row[2])
			isout, _ := strconv.Atoi(row[3])
			user := Stock.Read_MqttUser(row[0])
			tool := validationtool.ValidationTool{
				T_sn:             row[0],
				T_class:          atoi,
				Validationnumber: row[1],
				T_uuid:           c.User.T_uuid,
				T_state:          isout,
				T_iccid:          user.Iccid,
				T_imei:           user.Imei,
			}
			_, err := vali.ADDValidationTool(tool)
			if err != nil {
				sprintf := fmt.Sprintf("设备sn添加失败%v", row[0])
				c.Data["json"] = lib.JSONS{Code: 1201, Msg: sprintf, Data: nil}
				c.ServeJSON()
				return
			}
		}
	}
	c.Data["json"] = lib.JSONS{Code: 200, Msg: "成功!", Data: nil}
	c.ServeJSON()
}
func (c *ValidationController) ExportValidationListExcel() {

	// 分页参数 初始化
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = 9999
	}

	T_state := c.GetString("T_state")
	validationnumber := c.GetString("validationnumber")
	T_sn := c.GetString("T_sn")
	t_iccid := c.GetString("t_iccid")
	t_imei := c.GetString("t_imei")
	LendUser := c.GetString("LendUser")
	T_project := c.GetString("T_project")
	T_class := c.GetString("T_class")
	vali := validationtool.NewValidationTool(orm.NewOrm())

	R_List, _ := vali.Read_Validation_List(validationnumber, T_sn, t_iccid, t_imei, T_state, LendUser, T_project, T_class, page, page_z)

	f := excelize.NewFile() //设置单元格值
	// 这里设置表头ÒÒ
	f.SetCellValue("Sheet1", "A1", "序号")
	f.SetCellValue("Sheet1", "B1", "SN")
	f.SetCellValue("Sheet1", "C1", "编号")
	f.SetCellValue("Sheet1", "D1", "模组imei")
	f.SetCellValue("Sheet1", "E1", "物联网卡号")
	f.SetCellValue("Sheet1", "F1", "设备类型")
	f.SetCellValue("Sheet1", "G1", "借出人")
	f.SetCellValue("Sheet1", "H1", "借出项目")
	f.SetCellValue("Sheet1", "I1", "备注")

	// 设置列宽
	f.SetColWidth("Sheet1", "A", "A", 6)
	f.SetColWidth("Sheet1", "B", "B", 20)
	f.SetColWidth("Sheet1", "C", "C", 15)
	f.SetColWidth("Sheet1", "D", "D", 15)
	f.SetColWidth("Sheet1", "E", "E", 30)
	f.SetColWidth("Sheet1", "F", "F", 15)
	f.SetColWidth("Sheet1", "G", "G", 15)
	f.SetColWidth("Sheet1", "H", "H", 30)
	f.SetColWidth("Sheet1", "I", "J", 15)

	line := 1
	for i, v := range R_List {
		line++
		r, _ := Basic.Read_ProductClass_ById(v.T_class)
		f.SetCellValue("Sheet1", fmt.Sprintf("A%d", line), i+1)
		f.SetCellValue("Sheet1", fmt.Sprintf("B%d", line), v.T_sn)
		f.SetCellValue("Sheet1", fmt.Sprintf("C%d", line), v.Validationnumber)
		f.SetCellValue("Sheet1", fmt.Sprintf("D%d", line), v.T_imei)
		f.SetCellValue("Sheet1", fmt.Sprintf("E%d", line), v.T_iccid)
		f.SetCellValue("Sheet1", fmt.Sprintf("F%d", line), r.T_name)
		f.SetCellValue("Sheet1", fmt.Sprintf("G%d", line), v.LendUser)
		f.SetCellValue("Sheet1", fmt.Sprintf("H%d", line), v.T_project)
		f.SetCellValue("Sheet1", fmt.Sprintf("I%d", line), v.T_remark)
	}
	timeStr := time.Now().Format("20060102150405")
	fileName := fmt.Sprintf("验证工具记录表%v.xlsx", timeStr)
	filePath := "ofile/" + "验证工具记录表" + timeStr + ".xlsx"
	// 保存文件
	if err := f.SaveAs(filePath); err != nil {
		logs.Error("文件失败:", err)
	}
	defer func() {
		os.Remove(filePath)
	}()
	c.Ctx.Output.Header("Content-Type", "application/vnd.ms-excel;charset=utf8")
	c.Ctx.Output.Header("Content-Disposition", "attachment; filename="+url.PathEscape(fileName))
	c.Ctx.Output.Header("Content-Transfer-Encoding", "binary")
	c.Ctx.Output.Download(filePath, fileName)
}
func (c *ValidationController) Read_ValidationClass_List() {

	// 分页参数 初始化
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = conf.Page_size
	}

	// 查询
	T_name := c.GetString("T_name")

	R_List, R_cnt := validationtool.Read_ValidationToolClass_List(T_name, page, page_z)

	var r_jsons lib.R_JSONS
	r_jsons.Num = R_cnt
	r_jsons.Data = R_List
	r_jsons.Page = page
	r_jsons.Page_size = int(math.Ceil(float64(R_cnt) / float64(page_z)))

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

// 统计验证工具
func (c *ValidationController) Validation_stat() {
	// 分页参数 初始化
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = conf.Page_size
	}
	LendUser := c.GetString("LendUser")
	T_project := c.GetString("T_project")
	vali := validationtool.NewValidationTool(orm.NewOrm())
	R_List, R_cnt := vali.Validation_stat(LendUser, T_project, page, page_z)

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

func (c *ValidationController) User_List() {
	var r_jsons lib.R_JSONS
	// 分页参数 初始化
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = conf.Page_size
	}

	T_name := c.GetString("T_name")

	vali := validationtool.NewValidationTool(orm.NewOrm())

	R_List, R_cnt := vali.Read_lend_user_List(T_name, page, page_z)

	for i := 0; i < len(R_List); i++ {
		if R_List[i].LendUser == "" {
			R_List[i].LendUser = "未出库"
		}
	}

	r_jsons.Num = R_cnt
	r_jsons.Data = R_List
	r_jsons.Page = page
	r_jsons.Page_size = int(math.Ceil(float64(R_cnt) / float64(page_z)))

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

func (c *ValidationController) Record_List() {
	// 分页参数 初始化
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = conf.Page_size
	}
	T_state := c.GetString("T_state")
	validationnumber := c.GetString("Validationnumber")
	T_sn := c.GetString("T_sn")
	t_iccid := c.GetString("t_iccid")
	t_imei := c.GetString("t_imei")
	LendUser := c.GetString("LendUser")
	T_project := c.GetString("T_project")
	T_class := c.GetString("T_class")
	valiRecord := validationtool.NewValidationToolRecord(orm.NewOrm())

	R_List, R_cnt := valiRecord.Read_Validation_List(validationnumber, T_sn, t_iccid, t_imei, T_state, LendUser, T_project, T_class, page, page_z)

	var r_jsons lib.R_JSONS
	r_jsons.Num = R_cnt
	r_jsons.Data = R_List
	r_jsons.Page = page
	r_jsons.Page_size = int(math.Ceil(float64(R_cnt) / float64(page_z)))

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

func (c *ValidationController) Operation_List() {
	// 分页参数 初始化
	page, _ := c.GetInt("page")
	if page < 1 {
		page = 1
	}
	page_z, _ := c.GetInt("page_z")
	if page_z < 1 {
		page_z = conf.Page_size
	}
	T_state := c.GetString("T_state")
	T_sn := c.GetString("T_sn")
	LendUser := c.GetString("LendUser")
	T_project := c.GetString("T_project")
	valiRecord := validationtool.NewValidationToolRecord(orm.NewOrm())

	R_List, R_cnt := valiRecord.Read_Operation_List(T_sn, T_state, LendUser, T_project, page, page_z)

	var r_jsons lib.R_JSONS
	r_jsons.Num = R_cnt
	r_jsons.Data = R_List
	r_jsons.Page = page
	r_jsons.Page_size = int(math.Ceil(float64(R_cnt) / float64(page_z)))

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

// 下载操作记录
func (c *ValidationController) Operation_Excel() {

	T_state := c.GetString("T_state")
	T_sn := c.GetString("T_sn")
	LendUser := c.GetString("LendUser")
	T_project := c.GetString("T_project")
	valiRecord := validationtool.NewValidationToolRecord(orm.NewOrm())

	R_List, _ := valiRecord.Read_Operation_List(T_sn, T_state, LendUser, T_project, 0, 9999)

	f := excelize.NewFile() //设置单元格值
	// 这里设置表头ÒÒ

	Style2, _ := 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},
			},
		})
	Style4, _ := 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.SetCellValue("Sheet1", "A1", "序号")
	f.SetCellValue("Sheet1", "B1", "操作时间")
	f.SetCellValue("Sheet1", "C1", "操作")
	f.SetCellValue("Sheet1", "D1", "借出(归还)人")
	f.SetCellValue("Sheet1", "E1", "关联项目")
	f.SetCellValue("Sheet1", "F1", "备注")
	f.SetCellValue("Sheet1", "G1", "设备数量")
	f.SetCellValue("Sheet1", "H1", "SN关联项目")
	f.SetCellValue("Sheet1", "I1", "SN数量")
	f.SetCellValue("Sheet1", "J1", "SN")
	// 这里设置表头
	f.SetCellStyle("Sheet1", "A1", "J1", Style2)
	f.SetRowHeight("Sheet1", 2, 20)

	// 设置列宽
	f.SetColWidth("Sheet1", "A", "A", 6)
	f.SetColWidth("Sheet1", "B", "B", 20)
	f.SetColWidth("Sheet1", "C", "C", 15)
	f.SetColWidth("Sheet1", "D", "D", 15)
	f.SetColWidth("Sheet1", "E", "E", 20)
	f.SetColWidth("Sheet1", "F", "F", 20)
	f.SetColWidth("Sheet1", "G", "G", 12)
	f.SetColWidth("Sheet1", "H", "H", 20)
	f.SetColWidth("Sheet1", "I", "I", 15)
	f.SetColWidth("Sheet1", "J", "J", 15)

	line := 1
	for i, v := range R_List {
		startRow := line + 1
		for _, sn := range v.T_sn_List {
			startRow2 := line + 1
			for _, v2 := range sn.T_sn {
				line++
				f.SetCellValue("Sheet1", fmt.Sprintf("J%d", line), v2)
			}
			f.MergeCell("Sheet1", fmt.Sprintf("H%d", startRow2), fmt.Sprintf("H%d", line))
			f.SetCellValue("Sheet1", fmt.Sprintf("H%d", line), sn.T_project)
			f.MergeCell("Sheet1", fmt.Sprintf("I%d", startRow2), fmt.Sprintf("I%d", line))
			f.SetCellValue("Sheet1", fmt.Sprintf("I%d", line), len(sn.T_sn))
		}

		f.MergeCell("Sheet1", fmt.Sprintf("A%d", startRow), fmt.Sprintf("A%d", line))
		f.SetCellValue("Sheet1", fmt.Sprintf("A%d", line), i+1)

		f.MergeCell("Sheet1", fmt.Sprintf("B%d", startRow), fmt.Sprintf("B%d", line))
		f.SetCellValue("Sheet1", fmt.Sprintf("B%d", line), v.BatchNumber)

		var state string
		switch v.T_state {
		case 1:
			state = "出库"
		case 2:
			state = "入库"
		case 3:
			state = "维修"
		case 4:
			state = "报废"
		case 5:
			state = "损坏"

		}
		f.MergeCell("Sheet1", fmt.Sprintf("C%d", startRow), fmt.Sprintf("C%d", line))
		f.SetCellValue("Sheet1", fmt.Sprintf("C%d", line), state)
		f.MergeCell("Sheet1", fmt.Sprintf("D%d", startRow), fmt.Sprintf("D%d", line))
		f.SetCellValue("Sheet1", fmt.Sprintf("D%d", line), v.LendUser)
		f.MergeCell("Sheet1", fmt.Sprintf("E%d", startRow), fmt.Sprintf("E%d", line))
		f.SetCellValue("Sheet1", fmt.Sprintf("E%d", line), strings.Join(v.T_project, "\r\n"))
		f.MergeCell("Sheet1", fmt.Sprintf("F%d", startRow), fmt.Sprintf("F%d", line))
		f.SetCellValue("Sheet1", fmt.Sprintf("F%d", line), v.T_remark)
		f.MergeCell("Sheet1", fmt.Sprintf("G%d", startRow), fmt.Sprintf("G%d", line))
		f.SetCellValue("Sheet1", fmt.Sprintf("G%d", line), v.T_sn_quantity)

	}

	f.SetCellStyle("Sheet1", "A2", fmt.Sprintf("J%d", line), Style4)

	timeStr := time.Now().Format("20060102150405")
	fileName := fmt.Sprintf("验证工具操作记录表%v.xlsx", timeStr)
	filePath := "ofile/" + "验证工具操作记录表" + timeStr + ".xlsx"
	// 保存文件
	if err := f.SaveAs(filePath); err != nil {
		logs.Error("保存文件失败:", err)
	}
	defer func() {
		os.Remove(filePath)
	}()
	c.Ctx.Output.Header("Content-Type", "application/vnd.ms-excel;charset=utf8")
	c.Ctx.Output.Header("Content-Disposition", "attachment; filename="+url.PathEscape(fileName))
	c.Ctx.Output.Header("Content-Transfer-Encoding", "binary")
	c.Ctx.Output.Download(filePath, fileName)
}

// 设备转移请求结构体
type TransferValidationToolRequest struct {
	T_sn          []string `json:"T_sn"`
	CurrentUser   string `json:"CurrentUser"`
	TargetUser    string `json:"TargetUser"`
	TransferRemark string `json:"TransferRemark"` // 转移备注
}

// 设备转移结果结构体
type TransferResult struct {
	T_sn         string `json:"T_sn"`
	Success      bool   `json:"success"`
	Message      string `json:"message"`
	Status       string `json:"status"`
}

// 检查所有转移结果是否都失败
func allFailed(results []TransferResult) bool {
	for _, r := range results {
		if r.Success {
			return false
		}
	}
	return true
}

// 检查是否有任何转移结果成功
func anySuccess(results []TransferResult) bool {
	for _, r := range results {
		if r.Success {
			return true
		}
	}
	return false
}

// 设备转移请求
func (c *ValidationController) TransferValidationTool() {
	var request TransferValidationToolRequest
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &request)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "json 序列化失败!", Data: nil}
		c.ServeJSON()
		return
	}

	// 验证参数
	if len(request.T_sn) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "T_sn不能为空!", Data: nil}
		c.ServeJSON()
		return
	}

	if len(request.TargetUser) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "目标借出用户不能为空!", Data: nil}
		c.ServeJSON()
		return
	}

	if request.CurrentUser == request.TargetUser {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "目标用户不能与当前用户相同!", Data: nil}
		c.ServeJSON()
		return
	}

	o := orm.NewOrm()
	o.Begin()
	vali := validationtool.NewValidationTool(o)
	valiRecord := validationtool.NewValidationToolRecord(o)
	BatchNumber := time.Now().Format("2006-01-02 15:04:05")

	var results []TransferResult

	// 遍历所有SN进行检查和更新
	for _, sn := range request.T_sn {
		result := TransferResult{T_sn: sn, Success: false, Status: "failed"}

		validation, err2 := vali.ReadValidationBytSn(sn)
		if err2 != nil {
			if err2.Error() == orm.ErrNoRows.Error() {
				result.Message = fmt.Sprintf("当前sn:%v 未入库", sn)
			} else {
				result.Message = fmt.Sprintf("查询sn:%v 失败", sn)
			}
			results = append(results, result)
			continue
		}

		// 检查设备当前状态是否为已出库
		if validation.T_state != validationtool.ValidationToolStateStockOut {
			result.Message = fmt.Sprintf("当前sn:%v 未出库，无法进行转移", sn)
			results = append(results, result)
			continue
		}

		// 检查当前借出用户是否匹配
		if validation.LendUser != request.CurrentUser {
			result.Message = fmt.Sprintf("当前sn:%v 的借出用户与请求不符", sn)
			results = append(results, result)
			continue
		}

		// 检查设备是否已经在转移中
		if validation.T_state == validationtool.ValidationToolStateTransferring {
			result.Message = fmt.Sprintf("当前sn:%v 正在转移中，请等待对方确认或取消当前转移", sn)
			results = append(results, result)
			continue
		}

		// 修改设备状态和备注，记录转移信息
		originalRemark := validation.T_remark
		transferInfo := fmt.Sprintf("[转移请求] 从 %s 转移至 %s", request.CurrentUser, request.TargetUser)
		if len(request.TransferRemark) > 0 {
			transferInfo += fmt.Sprintf("，备注：%s", request.TransferRemark)
		}
		if len(originalRemark) > 0 {
			validation.T_remark = originalRemark + "\n" + transferInfo
		} else {
			validation.T_remark = transferInfo
		}

		// 设置转移中的状态
		validation.T_state = validationtool.ValidationToolStateTransferring
		
		cols := []string{"T_remark", "T_state"}
		err = vali.UpdateValidationTool(validation, cols...)
		if err != nil {
			result.Message = fmt.Sprintf("更新设备sn:%v 状态失败", sn)
			results = append(results, result)
			continue
		}
		
		_, err = valiRecord.ADD(validation, BatchNumber)
		if err != nil {
			result.Message = fmt.Sprintf("保存sn:%v 历史记录失败", sn)
			results = append(results, result)
			continue
		}
		result.Success = true
		result.Status = "pending"
		result.Message = fmt.Sprintf("sn:%v 转移请求已发送", sn)
		results = append(results, result)

	}

	if anySuccess(results) {
		// 创建转移记录到新表
		snListJSON, err := json.Marshal(request.T_sn)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "T_sn列表序列化失败!", Data: nil}
			c.ServeJSON()
			return
		}
		transferRecord := validationtool.ValidationToolTransfer{
			T_sn:     string(snListJSON),
			FromUser: request.CurrentUser,
			ToUser:   request.TargetUser,
			Status:   "pending",
			Remark:   request.TransferRemark,
		}

		transferTool := validationtool.NewValidationToolTransfer(o)
		_, err = transferTool.Add(&transferRecord)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "创建转移记录失败!", Data: nil}
			c.ServeJSON()
			return
		}

		err = o.Commit() // 提交事务
		if err != nil {
			o.Rollback() // 回滚事务
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "提交事务失败!", Data: nil}
			c.ServeJSON()
			return
		}

		NatsServer.AddUserLogs(c.User.T_uuid, "验证工具", "转移请求", request.T_sn)
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "批量转移请求处理完成", Data: results}
		c.ServeJSON()
		return
	}

	o.Rollback() // 如果没有一个成功，则回滚所有操作
	c.Data["json"] = lib.JSONS{Code: 1201, Msg: "所有SN转移失败", Data: results}
	c.ServeJSON()
	return
}

// 确认接收设备请求结构体
type ConfirmTransferValidationTool struct {
	T_sn         []string `json:"T_sn"`
	ConfirmUser  string `json:"ConfirmUser"`  // 确认接收的用户
	// 添加设备信息字段用于比对
	DeviceInfo   map[string]interface{} `json:"DeviceInfo"` // 设备信息用于比对
}

// 设备一致性比对结果结构体
type DeviceComparisonResult struct {
	Field       string `json:"field"`
	Expected    string `json:"expected"`
	Actual      string `json:"actual"`
}

// 确认接收设备
func (c *ValidationController) ConfirmTransferValidationTool() {
	var request ConfirmTransferValidationTool
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &request)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "json 序列化失败!", Data: nil}
		c.ServeJSON()
		return
	}

	// 验证参数
	if len(request.T_sn) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "T_sn不能为空!", Data: nil}
		c.ServeJSON()
		return
	}

	if len(request.ConfirmUser) <= 0 {
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "确认用户不能为空!", Data: nil}
		c.ServeJSON()
		return
	}

	o := orm.NewOrm()
	o.Begin()
	vali := validationtool.NewValidationTool(o)
	valiRecord := validationtool.NewValidationToolRecord(o)
	BatchNumber := time.Now().Format("2006-01-02 15:04:05")

	// 查询设备信息
	validation, err2 := vali.ReadValidationBytSn(request.T_sn)
	if err2 != nil {
		o.Rollback()
		if err2.Error() == orm.ErrNoRows.Error() {
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("当前sn:%v 未入库", request.T_sn), Data: nil}
			c.ServeJSON()
			return
		} else {
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("查询sn:%v 失败", request.T_sn), Data: nil}
			c.ServeJSON()
			return
		}
	}

	// 检查设备是否在转移中
	if validation.T_state != validationtool.ValidationToolStateTransferring {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("当前sn:%v 不在转移状态", request.T_sn), Data: nil}
		c.ServeJSON()
		return
	}

	// 查询待处理的转移记录
	transfer := validationtool.NewValidationToolTransfer(o)
	transferRecord, err := transfer.GetPendingTransferBySn(request.T_sn)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("当前sn:%v 没有待确认的转移请求", request.T_sn), Data: nil}
		c.ServeJSON()
		return
	}

	// 检查确认用户是否为目标用户
	if transferRecord.ToUser != request.ConfirmUser {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: fmt.Sprintf("您不是当前sn:%v 的目标接收用户", request.T_sn), Data: nil}
		c.ServeJSON()
		return
	}

	// 设备一致性比对
	var comparisonResults []DeviceComparisonResult

	// 如果提供了设备信息进行比对
	if request.DeviceInfo != nil {
		// 比对T_iccid
		if iccid, ok := request.DeviceInfo["T_iccid"].(string); ok && iccid != validation.T_iccid {
			comparisonResults = append(comparisonResults, DeviceComparisonResult{
				Field:    "T_iccid",
				Expected: validation.T_iccid,
				Actual:   iccid,
			})
		}

		// 比对T_imei
		if imei, ok := request.DeviceInfo["T_imei"].(string); ok && imei != validation.T_imei {
			comparisonResults = append(comparisonResults, DeviceComparisonResult{
				Field:    "T_imei",
				Expected: validation.T_imei,
				Actual:   imei,
			})
		}

		// 比对T_class
		if class, ok := request.DeviceInfo["T_class"]; ok {
			classStr := fmt.Sprintf("%v", class)
			if classStr != fmt.Sprintf("%v", validation.T_class) {
				comparisonResults = append(comparisonResults, DeviceComparisonResult{
					Field:    "T_class",
					Expected: fmt.Sprintf("%v", validation.T_class),
					Actual:   classStr,
				})
			}
		}

		// 如果比对结果不一致，返回不一致信息
		if len(comparisonResults) > 0 {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 1201, Msg: "设备信息比对不一致", Data: comparisonResults}
			c.ServeJSON()
			return
		}
	}

	// 更新借出用户
	validation.LendUser = request.ConfirmUser
	// 将状态改回已出库
	validation.T_state = validationtool.ValidationToolStateStockOut
	// 在备注中记录转移确认信息
	confirmInfo := fmt.Sprintf("[转移完成] %s 确认接收", request.ConfirmUser)
	validation.T_remark += "\n" + confirmInfo

	cols := []string{"LendUser", "T_remark", "T_state"}
	err = vali.UpdateValidationTool(validation, cols...)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "修改失败!", Data: nil}
		c.ServeJSON()
		return
	}

	_, err = valiRecord.ADD(validation, BatchNumber)
	if err != nil {
		o.Rollback() // 回滚事务
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "保存历史记录失败!", Data: nil}
		c.ServeJSON()
		return
	}

	err = o.Commit() // 提交事务
	if err != nil {
		o.Rollback() // 回滚事务
		c.Data["json"] = lib.JSONS{Code: 1201, Msg: "提交事务失败!", Data: nil}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证工具", "确认转移", []string{request.T_sn})

	// 返回转移结果
	result := TransferResult{
		T_sn:    request.T_sn,
		Success: true,
		Message: "设备转移确认成功!",
		Status:  "completed",
	}

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "设备转移确认成功!", Data: result}
	c.ServeJSON()
	return
}

// ... existing code ...