ERP_storage/controllers/Contract.go

package controllers

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

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

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

func (c *ContractController) Contract_GenT_number() {

	o := orm.NewOrm()
	ContractDao := Contract.NewContract(o)
	T_number := ""
	rand_x := 1
	for true {
		T_number = fmt.Sprintf("GZBZD-%s%03d", time.Now().Format("20060102"), rand_x)
		_, err := ContractDao.Read_Contract_ByT_number(T_number)
		if err != nil && err.Error() == orm.ErrNoRows.Error() {
			break
		}
		rand_x += 1
	}

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

}

func (c *ContractController) Contract_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")
	T_state, _ := c.GetInt("T_state")

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)

	ContractDao := Contract.NewContract(orm.NewOrm())
	R_List, R_cnt := ContractDao.Read_Contract_List("", T_name, T_state, 0, 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 *ContractController) Contract_User_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")
	T_state, _ := c.GetInt("T_state")

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)

	ContractDao := Contract.NewContract(orm.NewOrm())
	R_List, R_cnt := ContractDao.Read_Contract_List(c.User.T_uuid, T_name, T_state, 0, 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 *ContractController) Contract_Get() {

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

	o := orm.NewOrm()
	ContractDao := Contract.NewContract(o)
	DeviceDao := Stock.NewDevice(o)
	ContractProductDao := Contract.NewContractProduct(o)
	contract, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "查询失败!"}
		c.ServeJSON()
		return
	}

	productList := ContractProductDao.Read_ContractProduct_List(contract.T_number)

	var pList []Contract.ContractProduct_R
	for _, v := range productList {
		p := Contract.ContractProductToContractProduct_R(v)
		p.T_device_list, _ = DeviceDao.Read_DeviceSn_List(T_number, v.T_product_id, "", "")
		pList = append(pList, p)
	}

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)

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

func (c *ContractController) Contract_Add() {

	T_number := c.GetString("T_number")
	T_customer := c.GetString("T_customer")
	T_money, _ := c.GetFloat("T_money")       // 总价
	T_discount, _ := c.GetFloat("T_discount") // 优惠价
	T_date := c.GetString("T_date")
	T_product := c.GetString("T_product")
	T_remark := c.GetString("T_remark")
	T_pdf := c.GetString("T_pdf")
	T_project := c.GetString("T_project")
	T_recoveries := c.GetString("T_recoveries")
	T_invoice := c.GetString("T_invoice")
	T_submit := c.GetString("T_submit")
	if len(T_submit) == 0 {
		T_submit = c.User.T_uuid
	}

	var_ := Contract.Contract{
		T_number:     T_number,
		T_customer:   T_customer,
		T_money:      float32(T_money),
		T_discount:   float32(T_discount),
		T_project:    T_project,
		T_type:       1, //合同类型 1-销售合同 2-验证合同
		T_date:       T_date,
		T_out:        1,
		T_State:      3,
		T_remark:     T_remark,
		T_pdf:        T_pdf,
		T_submit:     T_submit,
		T_recoveries: T_recoveries,
		T_invoice:    T_invoice,
	}

	_, var_.T_recoveries_money = Contract.ContractToContractFinance_R(T_recoveries)
	_, var_.T_invoice_money = Contract.ContractToContractFinance_R(T_invoice)

	o := orm.NewOrm()
	o.Begin()
	ContractDao := Contract.NewContract(o)
	ContractProductDao := Contract.NewContractProduct(o)

	_, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err == nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "合同编号重复！"}
		c.ServeJSON()
		return
	}

	_, err = ContractDao.Add_Contract(var_)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
		c.ServeJSON()
		return
	}

	if len(T_product) == 0 {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "合同产品明细不能为空"}
		c.ServeJSON()
		return
	}
	productList := lib.SplitString(T_product, "|")
	for _, v := range productList {
		product_id, _ := strconv.Atoi(strings.Split(v, ",")[0])
		num, _ := strconv.Atoi(strings.Split(v, ",")[1])
		contractProduct := Contract.ContractProduct{
			T_contract_number: T_number,
			T_product_id:      product_id,
			T_product_total:   num,
			T_product_out:     0, // 已出库数量
			T_State:           1, // 1-未出库 2-已部分出库 3-已全部出库
		}
		_, err = ContractProductDao.Add_ContractProduct(contractProduct)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
			c.ServeJSON()
			return
		}

	}

	o.Commit()

	NatsServer.AddUserLogs(c.User.T_uuid, "合同", "添加", var_)

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

func (c *ContractController) Contract_Approval() {

	T_number := c.GetString("T_number")
	T_state, _ := c.GetInt("T_state")

	o := orm.NewOrm()
	ContractDao := Contract.NewContract(o)

	contract, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败！"}
		c.ServeJSON()
		return
	}
	// 1-已通过 2-未通过
	contract.T_State = T_state
	contract.T_approver = c.User.T_uuid
	err = ContractDao.Update_Contract(contract, "T_State", "T_approver")
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
		c.ServeJSON()
		return
	}
	if T_state == 1 {
		NatsServer.AddNews(contract.T_submit, fmt.Sprintf("【合同审核】您提交的合同(%s)审核已通过", T_number), conf.ContractApprovalUrl)
	}
	if T_state == 2 {
		NatsServer.AddNews(contract.T_submit, fmt.Sprintf("【合同审核】您提交的合同(%s)审核未通过", T_number), conf.ContractApprovalUrl)
	}
	NatsServer.AddUserLogs(c.User.T_uuid, "合同", "审核", contract)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: T_number}
	c.ServeJSON()
	return
}
func (c *ContractController) Contract_Edit() {
	T_number := c.GetString("T_number")
	T_customer := c.GetString("T_customer")
	T_money, _ := c.GetFloat("T_money")
	T_discount, _ := c.GetFloat("T_discount") // 优惠价
	T_date := c.GetString("T_date")
	T_product := c.GetString("T_product")
	T_remark := c.GetString("T_remark")
	T_pdf := c.GetString("T_pdf")
	T_project := c.GetString("T_project")
	T_recoveries := c.GetString("T_recoveries")
	T_invoice := c.GetString("T_invoice")
	T_submit := c.GetString("T_submit")

	o := orm.NewOrm()
	o.Begin()
	ContractDao := Contract.NewContract(o)
	ContractProductDao := Contract.NewContractProduct(o)

	contract, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_number Err！"}
		c.ServeJSON()
		return
	}

	if len(T_customer) > 0 {
		contract.T_customer = T_customer
	}
	if T_money > 0 {
		contract.T_money = float32(T_money)
	}
	if T_discount > 0 {
		contract.T_discount = float32(T_discount)
	}
	if len(T_date) > 0 {
		contract.T_date = T_date
	}
	if len(T_remark) > 0 {
		contract.T_remark = T_remark
	}
	if len(T_pdf) > 0 {
		contract.T_pdf = T_pdf
	}
	if len(T_project) > 0 {
		contract.T_project = T_project
	}
	if len(T_recoveries) > 0 {
		contract.T_recoveries = T_recoveries
		_, contract.T_recoveries_money = Contract.ContractToContractFinance_R(T_recoveries)
	}
	if len(T_invoice) > 0 {
		contract.T_invoice = T_invoice
		_, contract.T_invoice_money = Contract.ContractToContractFinance_R(T_invoice)
	}
	if len(T_submit) > 0 {
		contract.T_submit = T_submit
	}

	//1-已通过 2-未通过 3-待审核 合同状态为未通过，修改之后将状态更改为待审核
	if contract.T_State == 2 {
		contract.T_State = 3
	}

	err = ContractDao.Update_Contract(contract, "T_customer", "T_money", "T_discount", "T_date", "T_remark", "T_pdf", "T_State",
		"T_project", "T_recoveries", "T_recoveries_money", "T_invoice", "T_invoice_money", "T_submit")
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
		c.ServeJSON()
		return
	}

	if len(T_product) == 0 {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "合同产品明细不能为空"}
		c.ServeJSON()
		return
	}
	productList := lib.SplitString(T_product, "|")

	cpl, _ := ContractProductDao.Read_ContractProductList_ByT_number(T_number)
	needToDeleteList, allList := Check_NeedToDelete_Product_List(productList, cpl)
	// 检查编辑时需要修改的产品
	for k, v := range needToDeleteList {
		id, _ := strconv.Atoi(strings.Split(k, "-")[0])
		productId, _ := strconv.Atoi(strings.Split(k, "-")[1])
		if v > 0 {
			o.Rollback()
			product, _ := Basic.Read_Product_ById(productId)
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("%s已(部分)出库，禁止删除！", product.T_name)}
			c.ServeJSON()
			return
		}
		cp := Contract.ContractProduct{Id: id}
		err = ContractProductDao.Delete_ContractProduct(cp)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
			c.ServeJSON()
			return
		}
	}
	for _, v := range productList {
		product_id, _ := strconv.Atoi(strings.Split(v, ",")[0])
		num, _ := strconv.Atoi(strings.Split(v, ",")[1])
		oldContractProduct, ok := allList[product_id]
		if !ok {
			contractProduct := Contract.ContractProduct{
				T_contract_number: T_number,
				T_product_id:      product_id,
				T_product_total:   num,
				T_product_out:     0, // 已出库数量
				T_State:           1, // 1-未出库 2-已部分出库 3-已全部出库
			}
			_, err = ContractProductDao.Add_ContractProduct(contractProduct)
			if err != nil {
				o.Rollback()
				c.Data["json"] = lib.JSONS{Code: 203, Msg: "修改失败"}
				c.ServeJSON()
				return
			} else {
				continue
			}
		}

		// 修改产品总数量
		contractProductId, _ := strconv.Atoi(strings.Split(oldContractProduct, "-")[0])
		oldNum, _ := strconv.Atoi(strings.Split(oldContractProduct, "-")[1])
		if oldNum == num {
			continue
		}
		cp := Contract.ContractProduct{Id: contractProductId, T_product_total: num}
		err = ContractProductDao.Update_ContractProduct(cp, "T_product_total")
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 203, Msg: "修改失败"}
			c.ServeJSON()
			return
		}

	}

	o.Commit()

	NatsServer.AddUserLogs(c.User.T_uuid, "合同", "修改", contract)

	c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!", Data: contract.Id}
	c.ServeJSON()
	return
}
func (c *ContractController) Contract_Del() {

	T_number := c.GetString("T_number")

	o := orm.NewOrm()
	o.Begin()
	ContractDao := Contract.NewContract(o)
	ContractProductDao := Contract.NewContractProduct(o)

	contract, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_number Err！"}
		c.ServeJSON()
		return
	}
	//1-已通过 2-未通过 3-待审核 审核状态
	if contract.T_State == 1 {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "合同已审核通过，禁止删除！"}
		c.ServeJSON()
		return
	}

	err = ContractDao.Delete_Contract(contract)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
		c.ServeJSON()
		return
	}
	//合同类型 1-销售合同 2-验证合同

	cpList := ContractProductDao.Read_ContractProduct_List(T_number)
	for _, v := range cpList {
		err = ContractProductDao.Delete_ContractProduct(v)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
			c.ServeJSON()
			return
		}
	}

	o.Commit()

	NatsServer.AddUserLogs(c.User.T_uuid, "合同", "删除", T_number)

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

func (c *ContractController) Contract_List_For_Out() {

	// 分页参数 初始化
	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")

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)

	ContractDao := Contract.NewContract(orm.NewOrm())
	R_List, R_cnt := ContractDao.Read_Contract_List("", T_name, 1, 1, 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 *ContractController) Contract_Product_List() {

	// 查询
	T_number := c.GetString("T_number")
	T_depot_id, _ := c.GetInt("T_depot_id")

	o := orm.NewOrm()
	ContractDao := Contract.NewContract(o)
	ContractProductDao := Contract.NewContractProduct(o)
	contract, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "查询失败!"}
		c.ServeJSON()
		return
	}

	productList := ContractProductDao.Read_ContractProduct_OutList(contract.T_number)
	Stock.Read_Stock_All_Map(T_depot_id)

	var pList []Contract.ContractProduct_Out
	for _, v := range productList {
		p := Contract.ContractProductToContractProduct_Out(v)
		p.T_stock_total = Stock.Read_Stock_Get(T_depot_id, p.T_product_id)
		pList = append(pList, p)
	}

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

// 检查需要删除的合同产品列表
func Check_NeedToDelete_Product_List(list []string, newList []Contract.ContractProduct) (needToDelete map[string]int, all map[int]string) {

	var productMap = map[int]int{}
	needToDelete = make(map[string]int)
	all = make(map[int]string)
	for _, v := range list {
		product_id, _ := strconv.Atoi(strings.Split(v, ",")[0])
		num, _ := strconv.Atoi(strings.Split(v, ",")[1])
		productMap[product_id] = num
	}

	for _, product := range newList {
		all[product.T_product_id] = fmt.Sprintf("%d-%d", product.Id, product.T_product_total)
		_, ok := productMap[product.T_product_id]
		if !ok {
			id := fmt.Sprintf("%d-%d", product.Id, product.T_product_id)
			needToDelete[id] = product.T_product_out
		}

	}
	return

}

// 验证合同
func (c *ContractController) VerifyContract_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_customer_id := c.GetString("T_customer_id")

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

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)

	ContractDao := Contract.NewContract(orm.NewOrm())
	R_List, R_cnt := ContractDao.Read_VerifyContract_List(T_name, T_customer_id, 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 *ContractController) VerifyContract_Add() {

	T_number := c.GetString("T_number")
	T_customer_id := c.GetString("T_customer_id")
	T_money, _ := c.GetFloat("T_money")
	T_discount, _ := c.GetFloat("T_discount")
	T_date := c.GetString("T_date")
	T_product := c.GetString("T_product")
	T_submit := c.GetString("T_submit")
	T_remark := c.GetString("T_remark")
	T_pdf := c.GetString("T_pdf")
	T_project := c.GetString("T_project")
	T_recoveries := c.GetString("T_recoveries")
	T_invoice := c.GetString("T_invoice")
	T_start_date := c.GetString("T_start_date")
	T_end_date := c.GetString("T_end_date")
	T_stamping_date := c.GetString("T_stamping_date")
	T_payment_method := c.GetString("T_payment_method")

	var_ := Contract.Contract{
		T_number:         T_number,
		T_customer_id:    T_customer_id,
		T_money:          float32(T_money),
		T_discount:       float32(T_discount),
		T_project:        T_project,
		T_type:           2, //合同类型 1-销售合同 2-验证合同
		T_date:           T_date,
		T_State:          1,
		T_remark:         T_remark,
		T_pdf:            T_pdf,
		T_submit:         T_submit,
		T_recoveries:     T_recoveries,
		T_invoice:        T_invoice,
		T_start_date:     T_start_date,
		T_end_date:       T_end_date,
		T_stamping_date:  T_stamping_date,
		T_payment_method: T_payment_method,
	}
	_, var_.T_recoveries_money = Contract.ContractToContractFinance_R(T_recoveries)
	_, var_.T_invoice_money = Contract.ContractToContractFinance_R(T_invoice)
	o := orm.NewOrm()
	o.Begin()
	ContractDao := Contract.NewContract(o)
	ContractProductDao := Contract.NewContractProduct(o)

	_, err := ContractDao.Read_Contract_ByT_date(T_customer_id, T_start_date, T_end_date)
	if err == nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "合同签约时间重复！"}
		c.ServeJSON()
		return
	}
	_, err = ContractDao.Read_Contract_ByT_number(T_number)
	if err == nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "合同编号重复！"}
		c.ServeJSON()
		return
	}

	ContractID, err := ContractDao.Add_Contract(var_)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
		c.ServeJSON()
		return
	}

	if len(T_product) == 0 {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "验证合同明细不能为空"}
		c.ServeJSON()
		return
	}
	productList := lib.SplitString(T_product, "|")
	ContractOut := 0
	for _, v := range productList {
		product_id, _ := strconv.Atoi(strings.Split(v, ",")[0])
		num, _ := strconv.Atoi(strings.Split(v, ",")[1])
		price := lib.StringToFloat64TwoDecimal(strings.Split(v, ",")[2])
		product, _ := Basic.Read_Product_ById(product_id)
		contractProduct := Contract.ContractProduct{
			T_contract_number: T_number,
			T_product_id:      product_id,
			T_product_total:   num,
			T_product_out:     0,              // 已出库数量
			T_price:           float32(price), // 价格
			T_State:           1,              // 1-未出库 2-已部分出库 3-已全部出库
		}
		if product.T_class < 0 {
			contractProduct.T_State = 3
		}
		if product.T_class == 0 {
			ContractOut = 1
		}
		_, err = ContractProductDao.Add_ContractProduct(contractProduct)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败"}
			c.ServeJSON()
			return
		}

	}

	o.Commit()
	o2 := orm.NewOrm()
	ContractDao2 := Contract.NewContract(o2)
	if ContractOut == 1 {
		err = ContractDao2.Update_Contract(Contract.Contract{Id: int(ContractID), T_out: ContractOut}, "T_out")
		if err != nil {
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "更新合同出库状态失败"}
			c.ServeJSON()
			return
		}
	}

	err = Update_VerifyContract_State(T_customer_id, "ADD")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "更新状态失败"}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证合同", "添加", var_)

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

// 验证合同呢修改
func (c *ContractController) VerifyContract_Edit() {
	Id, _ := c.GetInt("Id")
	T_number := c.GetString("T_number")
	T_money, _ := c.GetFloat("T_money")
	T_discount, _ := c.GetFloat("T_discount")
	T_date := c.GetString("T_date")
	T_product := c.GetString("T_product")
	T_remark := c.GetString("T_remark")
	T_pdf := c.GetString("T_pdf")
	T_project := c.GetString("T_project")
	T_recoveries := c.GetString("T_recoveries")
	T_invoice := c.GetString("T_invoice")
	T_start_date := c.GetString("T_start_date")
	T_end_date := c.GetString("T_end_date")
	T_submit := c.GetString("T_submit")
	T_stamping_date := c.GetString("T_stamping_date")
	T_payment_method := c.GetString("T_payment_method")

	o := orm.NewOrm()
	o.Begin()
	ContractDao := Contract.NewContract(o)
	ContractProductDao := Contract.NewContractProduct(o)

	contract, err := ContractDao.Read_Contract_ById(Id)
	if err != nil || contract.T_type == 1 {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_number Err！"}
		c.ServeJSON()
		return
	}
	oldT_number := contract.T_number
	if T_number != oldT_number {
		_, err1 := ContractDao.Read_Contract_ByT_number(T_number)
		if err1 == nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("合同编号%s已存在！", T_number)}
			c.ServeJSON()
			return
		}
		contract.T_number = T_number
	}

	if T_money > 0 {
		contract.T_money = float32(T_money)
	}
	if T_discount > 0 {
		contract.T_discount = float32(T_discount)
	}
	if len(T_date) > 0 {
		contract.T_date = T_date
	}
	if len(T_remark) > 0 {
		contract.T_remark = T_remark
	}
	if len(T_pdf) > 0 {
		contract.T_pdf = T_pdf
	}
	if len(T_project) > 0 {
		contract.T_project = T_project
	}
	if len(T_recoveries) > 0 {
		contract.T_recoveries = T_recoveries
		_, contract.T_recoveries_money = Contract.ContractToContractFinance_R(T_recoveries)
	}
	if len(T_invoice) > 0 {
		contract.T_invoice = T_invoice
		_, contract.T_invoice_money = Contract.ContractToContractFinance_R(T_invoice)
	}
	if len(T_start_date) > 0 {
		contract.T_start_date = T_start_date
	}
	if len(T_end_date) > 0 {
		contract.T_end_date = T_end_date
	}
	if len(T_submit) > 0 {
		contract.T_submit = T_submit
	}
	if len(T_stamping_date) > 0 {
		contract.T_stamping_date = T_stamping_date
	}
	if len(T_payment_method) > 0 {
		contract.T_payment_method = T_payment_method
	}

	err = ContractDao.Update_Contract(contract, "T_number", "T_money", "T_discount", "T_date", "T_remark", "T_pdf", "T_State", "T_project",
		"T_recoveries", "T_recoveries_money", "T_invoice", "T_invoice_money", "T_start_date", "T_end_date", "T_submit", "T_stamping_date", "T_payment_method")
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
		c.ServeJSON()
		return
	}

	if len(T_product) == 0 {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "产品明细不能为空"}
		c.ServeJSON()
		return
	}
	productList := lib.SplitString(T_product, "|")

	cpl, _ := ContractProductDao.Read_ContractProductList_ByT_number(oldT_number)
	needToDeleteList, allList := Check_NeedToDelete_Product_List(productList, cpl)
	// 检查编辑时需要修改的产品
	for k, v := range needToDeleteList {
		id, _ := strconv.Atoi(strings.Split(k, "-")[0])
		productId, _ := strconv.Atoi(strings.Split(k, "-")[1])
		if v > 0 {
			o.Rollback()
			product, _ := Basic.Read_Product_ById(productId)
			c.Data["json"] = lib.JSONS{Code: 202, Msg: fmt.Sprintf("%s已(部分)出库，禁止删除！", product.T_name)}
			c.ServeJSON()
			return
		}
		cp := Contract.ContractProduct{Id: id}
		err = ContractProductDao.Delete_ContractProduct(cp)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改失败!"}
			c.ServeJSON()
			return
		}
	}
	for _, v := range productList {
		product_id, _ := strconv.Atoi(strings.Split(v, ",")[0])
		num, _ := strconv.Atoi(strings.Split(v, ",")[1])
		price := lib.StringToFloat64TwoDecimal(strings.Split(v, ",")[2])
		oldContractProduct, ok := allList[product_id]
		if !ok {
			contractProduct := Contract.ContractProduct{
				T_contract_number: T_number,
				T_product_id:      product_id,
				T_product_total:   num,
				T_product_out:     0, // 已出库数量
				T_State:           1, // 1-未出库 2-已部分出库 3-已全部出库
			}
			_, err = ContractProductDao.Add_ContractProduct(contractProduct)
			if err != nil {
				o.Rollback()
				c.Data["json"] = lib.JSONS{Code: 203, Msg: "修改失败"}
				c.ServeJSON()
				return
			} else {
				continue
			}
		}

		// 修改产品总数量
		contractProductId, _ := strconv.Atoi(strings.Split(oldContractProduct, "-")[0])
		oldNum, _ := strconv.Atoi(strings.Split(oldContractProduct, "-")[1])
		if oldNum == num && T_number == oldT_number {
			continue
		}
		cp := Contract.ContractProduct{
			Id:                contractProductId,
			T_contract_number: T_number,
			T_product_total:   num,
			T_price:           float32(price), // 价格
		}
		err = ContractProductDao.Update_ContractProduct(cp, "T_product_total", "T_contract_number")
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 203, Msg: "修改失败"}
			c.ServeJSON()
			return
		}

	}

	o.Commit()

	err = Update_VerifyContract_State(contract.T_customer_id, "UPDATE")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "更新状态失败"}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证合同", "修改", contract)

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

func (c *ContractController) VerifyContract_Del() {

	T_number := c.GetString("T_number")

	o := orm.NewOrm()
	o.Begin()
	ContractDao := Contract.NewContract(o)
	ContractProductDao := Contract.NewContractProduct(o)

	contract, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_number Err！"}
		c.ServeJSON()
		return
	}
	err = ContractDao.Delete_Contract(contract)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
		c.ServeJSON()
		return
	}

	cpList := ContractProductDao.Read_ContractProduct_List(T_number)
	for _, v := range cpList {
		err = ContractProductDao.Delete_ContractProduct(v)
		if err != nil {
			o.Rollback()
			c.Data["json"] = lib.JSONS{Code: 202, Msg: "删除失败!"}
			c.ServeJSON()
			return
		}
	}
	o.Commit()

	err = Update_VerifyContract_State(contract.T_customer_id, "DELETE")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "修改状态失败"}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证合同", "删除", T_number)

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

// 导出验证合同
func (c *ContractController) VerifyContract_Excel() {

	// 分页参数 初始化
	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_state, _ := c.GetInt("T_state")           // 签约状态
	T_start_date := c.GetString("T_start_date") // 盖章开始时间
	T_end_date := c.GetString("T_end_date")     // 盖章结束时间

	data := ""
	if len(T_start_date) > 0 || len(T_end_date) > 0 {
		data = fmt.Sprintf("%s - %s", T_start_date, T_end_date)
	}

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)
	Contract.Read_VerifyContract_All_Map()
	ContractDao := Contract.NewContract(orm.NewOrm())
	R_List := ContractDao.Read_VerifyContract_Excel(T_state, T_name, T_start_date, T_end_date)
	f := excelize.NewFile() //设置单元格值
	// 这里设置表头ÒÒ
	Style1, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Size: 20, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
		})
	Style2, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Size: 15, 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{"D9D9D9"}, Pattern: 1},
		})
	Style3, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Size: 15, 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.MergeCell("Sheet1", "A1", "T1")
	f.SetCellValue("Sheet1", "A1", data+"合同明细")
	f.SetCellStyle("Sheet1", "A1", "T1", Style1)

	// 写入表头
	headers := []string{"合同编号", "客户名称", "销售人员", "签订时间", "起始时间", "终止时间", "盖章时间", "合同名称", "验证明细",
		"合同金额", "优惠金额", "付款方式/预付款", "回款时间", "以往回款", "回款金额", "未回款金额", "开票时间", "已开票金额", "未开票金额",
		"状态"}
	for col, header := range headers {
		cell := fmt.Sprintf("%c%d", rune('A'+col), 2)
		f.SetCellValue("Sheet1", cell, header)
	}
	// 这里设置表头
	f.SetCellStyle("Sheet1", "A2", "T2", Style2)
	f.SetRowHeight("Sheet1", 1, 50)
	f.SetRowHeight("Sheet1", 2, 50)

	colsWidth := []float64{15, 15, 12, 12, 12, 12, 12, 15, 50, 12, 12, 12, 12, 25, 12, 10, 25, 10, 10, 10}

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

	for col, width := range colsWidth {
		cell := fmt.Sprintf("%c", rune('A'+col))
		f.SetColWidth("Sheet1", cell, cell, width)
	}
	line := 2
	for _, v := range R_List {
		valueList := []interface{}{
			v.T_number, v.T_customer, v.T_submit_name, v.T_date, v.T_start_date, v.T_end_date, v.T_stamping_date, "冷链验证合同",
			v.T_Product, v.T_money, v.T_discount, Contract.Get_Contract_payment_method(v.T_payment_method), v.T_recoveries_time, v.T_recoveries, v.T_discount - v.T_no_recoveries_money,
			v.T_no_recoveries_money, v.T_invoice, v.T_discount - v.T_no_invoice_money, v.T_no_invoice_money, v.T_verify_state,
		}

		line++
		for col, value := range valueList {
			cell := fmt.Sprintf("%c", rune('A'+col))
			if cell == "N" || cell == "Q" {
				ll := value.([]Contract.ContractFinance_R)
				var sv []string
				for _, info := range ll {
					sv = append(sv, fmt.Sprintf("%s  %s", info.T_date, FormatFloat(float64(info.T_money))))
				}
				f.SetCellValue("Sheet1", fmt.Sprintf("%s%d", cell, line), strings.Join(sv, "\n"))
				continue
			}
			if cell == "I" {
				ll := value.([]Contract.ContractProduct_R)
				var sv []string
				for _, info := range ll {
					sv = append(sv, fmt.Sprintf("%s %s*%d=%s", info.T_product_name, FormatFloat(float64(info.T_price)), info.T_product_total, FormatFloat(float64(info.T_price)*float64(info.T_product_total))))
				}
				f.SetCellValue("Sheet1", fmt.Sprintf("%s%d", cell, line), strings.Join(sv, "\n"))
				continue
			}
			f.SetCellValue("Sheet1", fmt.Sprintf("%s%d", cell, line), value)
		}

	}

	f.SetCellStyle("Sheet1", "A3", fmt.Sprintf("T%d", line), Style3)

	timeStr := time.Now().Format("20060102150405")

	fileName := fmt.Sprintf("%s合同明细%v.xlsx", data, timeStr)
	filePath := "ofile/" + fileName
	// 保存文件
	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 Update_VerifyContract_State(T_customer_id, flag string) error {
	o := orm.NewOrm()
	ContractDao := Contract.NewContract(o)
	VerifyContractDao := Contract.NewVerifyContract(o)
	vcn := ContractDao.Read_VerifyContract_Newest(T_customer_id)
	vc, err := VerifyContractDao.Read_VerifyContract_ByT_customer_id(T_customer_id)
	if err != nil {
		return err
	}
	if vcn.Id == 0 {
		vc.T_sign_times = 0
		vc.T_start_date = ""
		vc.T_end_date = ""
		vc.T_State = 1
		err = VerifyContractDao.Update_VerifyContract(vc, "T_start_date", "T_end_date", "T_sign_times", "T_State")
		return err
	}
	if flag == "ADD" {
		vc.T_sign_times += 1
	} else if flag == "DELETE" {
		vc.T_sign_times -= 1
	}
	if len(vc.T_start_date) == 0 {
		vc.T_start_date = vcn.T_start_date
	}
	if vc.T_end_date != vcn.T_end_date {
		vc.T_end_date = vcn.T_end_date
	}
	nowTime := time.Now()
	now := time.Date(nowTime.Year(), nowTime.Month(), nowTime.Day(), 0, 0, 0, 0, time.Local)
	end, _ := lib.DateStrToTime(vcn.T_end_date)
	now2Month := now.AddDate(0, 2, 0)
	// 1-未签约 2-已作废 3-已签约 4-即将到期
	state := 1
	// 结束时间<今天 已过期
	if end.Before(now) {
		state = 2
	} else {
		// 结束时间<今天+2月 即将到期 && 结束时间>今天
		if end.Before(now2Month) || end.Equal(now) {
			state = 4
			NatsServer.AddNews(vcn.T_approver, fmt.Sprintf("【合同即将过期提醒】%s的验证合同将于%s过期!", vc.T_customer, vc.T_end_date), conf.VerifyContractUrl)
		}
		// 结束时间>今天+2月 已签约
		if end.After(now2Month) || end.Equal(now2Month) {
			state = 3
		}
	}
	vc.T_State = state
	err = VerifyContractDao.Update_VerifyContract(vc, "T_start_date", "T_end_date", "T_sign_times", "T_State")
	return err
}

// 验证合同-添加客户
func (c *ContractController) VerifyContract_Add_Customer() {

	T_customer := c.GetString("T_customer")

	o := orm.NewOrm()
	VerifyContractDao := Contract.NewVerifyContract(o)

	T_number := ""
	for true {
		rand_x := 1
		T_number = fmt.Sprintf("YZKH-%s", lib.GetRandstring(8, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", int64(rand_x)))
		_, err := VerifyContractDao.Read_VerifyContract_ByT_customer_id(T_number)
		if err != nil && err.Error() == orm.ErrNoRows.Error() {
			break
		}
		rand_x += 1
	}

	var_ := Contract.VerifyContract{
		T_customer:    T_customer,
		T_customer_id: T_number,
		T_State:       1,
	}

	_, err := VerifyContractDao.Add_VerifyContract(var_)
	if err != nil {
		o.Rollback()
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败！"}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证合同", "添加客户", var_)

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

// 验证合同-编辑客户
func (c *ContractController) VerifyContract_Update_Customer() {

	T_customer_id := c.GetString("T_customer_id")
	T_customer := c.GetString("T_customer")

	o := orm.NewOrm()
	VerifyContractDao := Contract.NewVerifyContract(o)
	vc, err := VerifyContractDao.Read_VerifyContract_ByT_customer_id(T_customer_id)

	vc.T_customer = T_customer

	err = VerifyContractDao.Update_VerifyContract(vc)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "添加失败！"}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证合同", "编辑客户", vc)

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

// 验证合同-客户列表
func (c *ContractController) VerifyContract_Customer_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")
	T_state, _ := c.GetInt("T_state")

	VerifyContractDao := Contract.NewVerifyContract(orm.NewOrm())
	R_List, R_cnt := VerifyContractDao.Read_VerifyContract_List(T_name, T_state, 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 *ContractController) Contract_List_RecoveriesMoney() {

	// 分页参数 初始化
	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_submit := c.GetString("T_submit")
	T_name := c.GetString("T_name")
	T_start_date := c.GetString("T_start_date")             // 回款开始日期
	T_end_date := c.GetString("T_end_date")                 // 回款结束日期
	T_recoveries_state, _ := c.GetInt("T_recoveries_state") // 回款状态 1 未回款 2 部分回款 3 全部回款
	T_invoice_state, _ := c.GetInt("T_invoice_state")       // 开票状态 1 未开票 2 部分开票 3 全部开票
	T_percentage_state, _ := c.GetInt("T_percentage_state") // 提成状态 1-未打款 2-已打款
	T_mine, _ := c.GetInt("T_mine")                         // 我的 用于合同提成显示

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)
	Contract.Read_VerifyContract_All_Map()

	ContractDao := Contract.NewContract(orm.NewOrm())
	R_List, R_cnt := ContractDao.Read_Contract_List_For_RecoveriesAndInvoice(c.User.T_uuid, T_submit, T_mine, T_name, T_start_date, T_end_date, T_recoveries_state, T_invoice_state, T_percentage_state, 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 *ContractController) Contract_List_RecoveriesMoney_Export() {

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

	T_name := c.GetString("T_name")
	T_start_date := c.GetString("T_start_date")             // 回款开始日期
	T_end_date := c.GetString("T_end_date")                 // 回款结束日期
	T_recoveries_state, _ := c.GetInt("T_recoveries_state") // 回款状态 1 未回款 2 部分回款 3 全部回款
	T_invoice_state, _ := c.GetInt("T_invoice_state")       // 开票状态 1 未开票 2 部分开票 3 全部开票
	T_percentage_state, _ := c.GetInt("T_percentage_state") // 提成状态 1-未打款 2-已打款
	T_mine, _ := c.GetInt("T_mine")                         // 我的 用于合同提成显示

	userList, _ := NatsServer.Read_User_List_All()
	Account.Read_User_All_Map(userList)
	Contract.Read_VerifyContract_All_Map()

	ContractDao := Contract.NewContract(orm.NewOrm())
	R_List, _ := ContractDao.Read_Contract_List_For_RecoveriesAndInvoice(c.User.T_uuid, T_submit, T_mine, T_name, T_start_date, T_end_date, T_recoveries_state, T_invoice_state, T_percentage_state, 0, 9999)
	title := "销售提成明细表"
	if T_mine == 1 {
		title = fmt.Sprintf("%s-销售提成明细表", c.User.T_name)
	}
	filename := fmt.Sprintf("%s(%s)", title, lib.GetRandstring(6, "0123456789", 0))

	f := excelize.NewFile() // 设置单元格的值
	Style1, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 12, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
		})
	Style2, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Bold: true, Size: 11, Family: "宋体"},
			Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
			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},
			},
		})

	Style3, _ := f.NewStyle(
		&excelize.Style{
			Font:      &excelize.Font{Size: 11, 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.MergeCell("Sheet1", "A1", "J1")
	f.SetRowStyle("Sheet1", 1, 1, Style1)

	f.SetCellValue("Sheet1", "A1", title)
	f.SetRowHeight("Sheet1", 1, 30)
	// 这里设置表头
	f.SetCellStyle("Sheet1", "A2", "J2", Style2)
	f.SetRowHeight("Sheet1", 2, 20)

	f.SetCellValue("Sheet1", "A2", "公司名称")
	f.SetCellValue("Sheet1", "B2", "合同编号")
	f.SetCellValue("Sheet1", "C2", "签约时间")
	f.SetCellValue("Sheet1", "D2", "合同金额")
	f.SetCellValue("Sheet1", "E2", "回款金额")
	f.SetCellValue("Sheet1", "F2", "回款比例")
	f.SetCellValue("Sheet1", "G2", "销售类型")
	f.SetCellValue("Sheet1", "H2", "销售提成5%")
	f.SetCellValue("Sheet1", "I2", "提成金额")
	f.SetCellValue("Sheet1", "J2", "提成状态")

	// 设置列宽
	f.SetColWidth("Sheet1", "A", "A", 25)
	f.SetColWidth("Sheet1", "B", "I", 15)

	line := 2

	for _, contract := range R_List {
		line += 1
		f.SetCellValue("Sheet1", fmt.Sprintf("A%d", line), line-2)
		f.SetCellValue("Sheet1", fmt.Sprintf("A%d", line), contract.T_customer)
		f.SetCellValue("Sheet1", fmt.Sprintf("B%d", line), contract.T_number)
		f.SetCellValue("Sheet1", fmt.Sprintf("C%d", line), contract.T_date)
		f.SetCellValue("Sheet1", fmt.Sprintf("D%d", line), contract.T_discount)
		f.SetCellValue("Sheet1", fmt.Sprintf("E%d", line), contract.T_recoveries_money)
		f.SetCellValue("Sheet1", fmt.Sprintf("F%d", line), fmt.Sprintf("%.02f%%", contract.T_recoveries_money/contract.T_discount*100))
		T_type_str := "验证合同"
		if contract.T_type == 1 {
			T_type_str = "销售合同"
		}
		f.SetCellValue("Sheet1", fmt.Sprintf("G%d", line), T_type_str)
		f.SetCellValue("Sheet1", fmt.Sprintf("H%d", line), fmt.Sprintf("%.02f", contract.T_discount*0.05))
		f.SetCellValue("Sheet1", fmt.Sprintf("I%d", line), fmt.Sprintf("%.02f", contract.T_discount*0.05))
		T_percentage_str := "未打款"
		if contract.T_percentage_state == 2 {
			T_percentage_str = "已打款"
		}
		f.SetCellValue("Sheet1", fmt.Sprintf("J%d", line), T_percentage_str)

	}
	f.SetCellStyle("Sheet1", "A3", fmt.Sprintf("J%d", line), Style3)

	// 保存文件
	if err := f.SaveAs("ofile/" + filename + ".xlsx"); err != nil {
		fmt.Println(err)
	}
	var url string
	//// 上传 OSS
	nats := natslibs.NewNats(Nats.Nats, conf.NatsSubj_Prefix)
	url, is := nats.Qiniu_UploadFile(lib.GetCurrentDirectory()+"/ofile/"+filename+".xlsx", "ofile/"+filename+".xlsx")
	if !is {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "oss!"}
		c.ServeJSON()
		return
	}
	//删除目录
	err := os.Remove("ofile/" + filename + ".xlsx")
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}

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

	T_type, _ := c.GetInt("T_type")
	T_year, _ := c.GetInt("T_year")

	type R_JSONS struct {
		ContractMoneyByYear   interface{}
		TotalMoneyByYear      float32
		RecoveriesMoneyByYear float32
		ContractNumByYear     interface{}
		TotalMumByYear        int64

		ContractMoneyByMonth   interface{}
		TotalMoneyByMonth      float32
		RecoveriesMoneyByMonth float32
		ContractNumByMonth     interface{}
		TotalMumByMonth        int64

		TotalMoneyByThisYear      float32 // 今年合同总金额
		RecoveriesMoneyByThisYear float32 // 今年回款总金额
		TotalMumByThisYear        int64   // 今年合同总数

		TotalMoneyByLastYear      float32 // 去年合同总金额
		RecoveriesMoneyByLastYear float32 // 去年回款总金额
		TotalMumByLastYear        int64   // 去年合同总数
	}

	var r_jsons R_JSONS
	thisYear := time.Now().Year()
	if T_year == 0 {
		T_year = thisYear
	}

	ContractDao := Contract.NewContract(orm.NewOrm())
	monryStat, moneyTotal, moneyRecoveries := ContractDao.Stat_ContractMoney_ByYear(T_type)
	numStat, numTotal := ContractDao.Stat_ContractNum_ByYear(T_type)

	monryMonthStat, moneyMonthTotal, moneyMonthRecoveries := ContractDao.Stat_ContractMoney_ByMonth(T_type, T_year)
	numMonthStat, numMonthTotal := ContractDao.Stat_ContractNum_ByMonth(T_type, T_year)
	// 去年
	_, r_jsons.TotalMoneyByLastYear, r_jsons.RecoveriesMoneyByLastYear = ContractDao.Stat_ContractMoney_ByMonth(T_type, T_year-1)
	_, r_jsons.TotalMumByLastYear = ContractDao.Stat_ContractNum_ByMonth(T_type, T_year-1)

	r_jsons.ContractMoneyByYear = monryStat
	r_jsons.TotalMoneyByYear = moneyTotal
	r_jsons.RecoveriesMoneyByYear = moneyRecoveries
	r_jsons.ContractNumByYear = numStat
	r_jsons.TotalMumByYear = numTotal

	r_jsons.ContractMoneyByMonth = monryMonthStat
	r_jsons.TotalMoneyByMonth = moneyMonthTotal
	r_jsons.RecoveriesMoneyByMonth = moneyMonthRecoveries
	r_jsons.ContractNumByMonth = numMonthStat
	r_jsons.TotalMumByMonth = numMonthTotal

	r_jsons.TotalMoneyByThisYear = moneyMonthTotal
	r_jsons.RecoveriesMoneyByThisYear = moneyMonthRecoveries
	r_jsons.TotalMumByThisYear = numMonthTotal

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

func Cron_VerifyContract() {

	//创建一个定时任务对象
	c := cron.New(cron.WithSeconds())
	//给对象增加定时任务
	//c.AddFunc("0 */1 * * * ?", Cron_VerifyContract_ChangeState)
	c.AddFunc("@daily", Cron_VerifyContract_ChangeState)

	//启动定时任务
	c.Start()
	defer c.Stop()

	//查询语句，阻塞，让main函数不退出，保持程序运行
	select {}

}

// 修改合同状态
func Cron_VerifyContract_ChangeState() {

	T_date := time.Now().Format("2006-01-02")
	logs.Info("开始处理" + T_date + "验证合同状态")
	VerifyContractDao := Contract.NewVerifyContract(orm.NewOrm())
	R_List, _ := VerifyContractDao.Read_VerifyContract_List("", 0, 0, 999)
	for _, v := range R_List {
		err := Update_VerifyContract_State(v.T_customer_id, "UPDATE")
		if err != nil {
			logs.Error("修改合同状态失败")
		}
	}
}

// 修改回款金额及开票金额
func UpdateVerifyContract_RecoveriesInvoice_Money() {
	ContractDao := Contract.NewContract(orm.NewOrm())

	R_List, _ := ContractDao.Read_VerifyContract_List("", "", 0, 9999)

	for _, verify := range R_List {
		R := Contract.Contract{Id: verify.Id}

		_, R.T_recoveries_money = Contract.ContractToContractFinance_R(verify.T_recoveries)
		_, R.T_invoice_money = Contract.ContractToContractFinance_R(verify.T_invoice)

		ContractDao.Update_Contract(R, "T_recoveries_money", "T_invoice_money")
	}
}

// 修改回款时间
func UpdateVerifyContract_RecoveriesInvoice_Time() {
	ContractDao := Contract.NewContract(orm.NewOrm())

	R_List, _ := ContractDao.Read_VerifyContract_List("", "", 0, 9999)

	for _, verify := range R_List {
		R := Contract.Contract{Id: verify.Id}

		if verify.T_discount == verify.T_recoveries_money {
			recoveriesList, _ := Contract.ContractToContractFinance_R(verify.T_recoveries)
			if len(recoveriesList) > 0 {
				R.T_recoveries_time = recoveriesList[len(recoveriesList)-1].T_date
				ContractDao.Update_Contract(R, "T_recoveries_time")
			}
		}

	}
}

// 合同提成打款
func (c *ContractController) Contract_Percentage_Remit() {
	T_number := c.GetString("T_number")

	o := orm.NewOrm()
	ContractDao := Contract.NewContract(o)

	contract, err := ContractDao.Read_Contract_ByT_number(T_number)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "T_number Err！"}
		c.ServeJSON()
		return
	}
	if contract.T_recoveries_money != contract.T_discount {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "合同未回款，不可打款！"}
		c.ServeJSON()
		return
	}
	contract.T_percentage_state = 2 // 已打款

	err = ContractDao.Update_Contract(contract, "T_percentage_state")
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 203, Msg: "添加失败"}
		c.ServeJSON()
		return
	}

	NatsServer.AddUserLogs(c.User.T_uuid, "验证合同", "打款", contract)

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

func (c *ContractController) 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")

	ContractDao := Contract.NewContract(orm.NewOrm())

	uuidList := ContractDao.Read_T_submit_List()
	if len(uuidList) == 0 {
		c.Data["json"] = lib.JSONS{Code: 200, Msg: "ok!"}
		c.ServeJSON()
		return
	}

	R_List, R_cnt, err := NatsServer.Read_User_List_T_uuid(T_name, uuidList, page, page_z)
	if err != nil {
		c.Data["json"] = lib.JSONS{Code: 202, Msg: "查询失败"}
		c.ServeJSON()
		return
	}

	var U_List []userlibs.User
	for _, user := range R_List {
		U_List = append(U_List, user)
	}

	r_jsons.Num = R_cnt
	r_jsons.Data = U_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 FormatFloat(f float64) string {
	// 先判断是否为整数
	if f == math.Trunc(f) {
		return strconv.FormatFloat(f, 'f', 0, 64)
	}
	// 否则保留2位小数
	return strconv.FormatFloat(f, 'f', 2, 64)
}