package admin

import (
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
	"sync/atomic"
	"time"
	"zhiyuan/models"
	"zhiyuan/models/budget2"
	"zhiyuan/models/final"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/config"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/logger"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/structs"
	"zhiyuan/services/user"

	"github.com/Knetic/govaluate"
	"github.com/gin-gonic/gin"
	"github.com/tealeg/xlsx/v3"
	"github.com/w3liu/go-common/constant/timeformat"
	"github.com/xuri/excelize/v2"
)

func statistQuery(post map[string]interface{}) (db.Select, []final.FinalType, []final.FinalMatAuxiliary, []map[string]interface{}) {

	finaltypes := make([]final.FinalType, 0)
	db.GetModel(map[string]interface{}{
		"state":      1,
		"deleted_at": 0,
	}, &finaltypes)

	auxiliarytypes := make([]final.FinalMatAuxiliary, 0)
	db.GetModel(map[string]interface{}{
		"type":       0,
		"deleted_at": 0,
	}, &auxiliarytypes)

	mattypes := map[string][]string{
		"瓷砖":   {"东鹏瓷砖", "马可波罗", "新恒隆瓷砖", "冠珠陶瓷"},
		"地板":   {"圣象地板", "剑牌地板", "富林地板", "大自然地板", "生活家地板"},
		"木门":   {"欧铂尼木门", "TATA木门", "福和美木门"},
		"橱柜":   {"欧派橱柜", "德莎橱柜", "阳光木业"},
		"卫浴":   {"彪马卫浴", "箭牌卫浴", "安华卫浴", "雪雨卫浴"},
		"铝合金门": {"铂兰西尼", "鑫兴门业"},
		"开关面板": {"伊诺开关", "西门子"},
		"石材":   {"诚明石材"},
		"衣柜":   {"爱逸德家居", "谛凡衣柜"},
		"扣板":   {"邻邦扣板"},
		"淋浴隔断": {"德亦淋浴房"},
		"灯具":   {"鑫盛灯饰"},
		"窗帘":   {"鸟巢", "布蓝德"},
		"家具":   {"全友", "喜临门"},
		"电器":   {"海尔", "美的", "方太"},
	}

	s := db.ModelQuery(db.Type(final.FinalSite{}), post, false)

	tableTableName := "(select `table`.`site_id` as `site_id`, "
	controlTableName := "(select `control`.`site_id` as `site_id`, "
	for _, t := range finaltypes {
		controlTableName += fmt.Sprintf("ifnull(sum(if(`control`.`type_id` = %s,`control`.`budget`,0)),0) as `budget_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
		s.Select["table_budget_"+db.ToString(t.ID)] = fmt.Sprintf("`control`.`budget_%s`", db.ToString(t.ID))
		if t.LivingCount != 0 {
			tableTableName += fmt.Sprintf("ifnull(sum(if(`table`.`type_id` = %s and `table`.`type` = 0,`table`.`total`,0)),0) as `total_0_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
			tableTableName += fmt.Sprintf("ifnull(sum(if(`table`.`type_id` = %s and `table`.`type` = 1,`table`.`total`,0)),0) as `total_1_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
			tableTableName += fmt.Sprintf("ifnull(group_concat(distinct if(`table`.`type_id` = %s and `table`.`type` = 0,`table`.`state`,null)),\"\") as `state_0_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
			tableTableName += fmt.Sprintf("ifnull(group_concat(distinct if(`table`.`type_id` = %s and `table`.`type` = 1,`table`.`state`,null)),\"\") as `state_1_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
			s.Select["table_total_0_"+db.ToString(t.ID)] = fmt.Sprintf("`table`.`total_0_%s`", db.ToString(t.ID))
			s.Select["table_total_1_"+db.ToString(t.ID)] = fmt.Sprintf("`table`.`total_1_%s`", db.ToString(t.ID))
			s.Select["table_state_0_"+db.ToString(t.ID)] = fmt.Sprintf("`table`.`state_0_%s`", db.ToString(t.ID))
			s.Select["table_state_1_"+db.ToString(t.ID)] = fmt.Sprintf("`table`.`state_1_%s`", db.ToString(t.ID))
		}
		tableTableName += fmt.Sprintf("ifnull(sum(if(`table`.`type_id` = %s,`table`.`total`,0)),0) as `total_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
		tableTableName += fmt.Sprintf("ifnull(group_concat(distinct if(`table`.`type_id` = %s,`table`.`state`,null)),\"\") as `state_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
		s.Select["table_total_"+db.ToString(t.ID)] = fmt.Sprintf("`table`.`total_%s`", db.ToString(t.ID))
		s.Select["table_state_"+db.ToString(t.ID)] = fmt.Sprintf("`table`.`state_%s`", db.ToString(t.ID))

		/*s.Select["table_total_"+db.ToString(t.ID)] = "ROUND(sum(distinct(IF(`table`.`type_id`=" + db.ToString(t.ID) + ",`item`.`price`*`item`.`num`,null))))"
		s.Select["table_state_"+db.ToString(t.ID)] = "ROUND(sum(distinct(IF(`table`.`type_id`=" + db.ToString(t.ID) + ",`table`.`state`,null))))"*/
	}
	tableTableName += "ifnull(sum(`table`.`total`),0) as `total` from `zy_final_site_table` as `table` where `table`.`deleted_at` = 0 and `table`.`state` != -1 group by `table`.`site_id`)"
	controlTableName += "ifnull(sum(`control`.`budget`),0) as `budget` from `zy_final_site_control` as `control` where `control`.`deleted_at` = 0 group by `control`.`site_id`)"

	orderTableName := "(select `order`.`site_id` as `site_id`, "
	materialTableName := "(select `material`.`site_id` as `site_id`, "
	for _, t := range auxiliarytypes {
		materialTableName += fmt.Sprintf("ifnull(sum(if(`material`.`type_id` = %s,`material`.`budget`,0)),0) as `budget_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
		s.Select["material_budget_"+db.ToString(t.ID)] = fmt.Sprintf("`material`.`budget_%s`", db.ToString(t.ID))
		orderTableName += fmt.Sprintf("ifnull(sum(if(`material`.`type_id` = %s,`order`.`total`,0)),0) as `total_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
		orderTableName += fmt.Sprintf("ifnull(group_concat(distinct if(`material`.`type_id` = %s,`supplier`.`name`,null)),\"\") as `supplier_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
		orderTableName += fmt.Sprintf("ifnull(group_concat(distinct if(`material`.`type_id` = %s,`order`.`state`,null)),\"\") as `state_%s`, ", db.ToString(t.ID), db.ToString(t.ID))
		s.Select["order_total_"+db.ToString(t.ID)] = fmt.Sprintf("`order`.`total_%s`", db.ToString(t.ID))
		s.Select["order_supplier_"+db.ToString(t.ID)] = fmt.Sprintf("`order`.`supplier_%s`", db.ToString(t.ID))
		s.Select["order_state_"+db.ToString(t.ID)] = fmt.Sprintf("`order`.`state_%s`", db.ToString(t.ID))
	}
	matTypes := make([]map[string]interface{}, 0)
	for name, suppliers := range mattypes {
		id := len(matTypes)

		orderTableName += fmt.Sprintf("ifnull(sum(if(`supplier`.`name` in %s,`order`.`total`,0)),0) as `stotal_%s`, ", s.Param(suppliers), db.ToString(id))
		orderTableName += fmt.Sprintf("ifnull(group_concat(distinct if(`supplier`.`name` in %s,`supplier`.`name`,null)),\"\") as `ssupplier_%s`, ", s.Param(suppliers), db.ToString(id))
		orderTableName += fmt.Sprintf("ifnull(group_concat(distinct if(`supplier`.`name` in %s,`order`.`state`,null)),\"\") as `sstate_%s`, ", s.Param(suppliers), db.ToString(id))
		s.Select["order_stotal_"+db.ToString(id)] = fmt.Sprintf("`order`.`stotal_%s`", db.ToString(id))
		s.Select["order_ssupplier_"+db.ToString(id)] = fmt.Sprintf("`order`.`ssupplier_%s`", db.ToString(id))
		s.Select["order_sstate_"+db.ToString(id)] = fmt.Sprintf("`order`.`sstate_%s`", db.ToString(id))
		matTypes = append(matTypes, map[string]interface{}{
			"id":   id,
			"name": name,
		})
	}
	orderTableName += "ifnull(sum(`order`.`total`),0) as `total` from `zy_final_material_order` as `order` left join `zy_final_material` as `material` on `material`.`id` = `order`.`type_id` left join `zy_final_supplier` as `supplier` on `supplier`.`id` = `order`.`supplier_id` where `order`.`deleted_at` = 0 and `order`.`state` != -1 group by `order`.`site_id`)"
	materialTableName += "ifnull(sum(`material`.`budget`),0) as `budget` from `zy_final_material` as `material` where `material`.`deleted_at` = 0 group by `material`.`site_id`)"

	/*materialTableName := "(select `order`.`site_id` as `site_id`, ifnull(sum(if(`order`.`type` = 0 and `order`.`state` != -1,`order`.`total`,0)),0) as `total_0`, ifnull(sum(if(`order`.`type` = 1 and `order`.`state` != -1,`order`.`total`,0)),0) as `total_1`, ifnull(sum(if(`order`.`state` != -1,`order`.`total`,0)),0) as `total`, ifnull(sum(`process`.`count`),0) as `process_count`, ifnull(sum(`process`.`count_6`),0) as `process_count_6`, ifnull(sum(`process`.`count_7`),0) as `process_count_7` from `zy_final_material_order` as `order` left join (select `process`.`order_id`, ifnull(count(`process`.`id`),0) as `count`, ifnull(count(if(`process`.`type` = 6,`process`.`id`,null)),0) as `count_6`, ifnull(count(if(`process`.`type` = 7,`process`.`id`,null)),0) as `count_7` from `zy_final_material_order_process` as `process` where `process`.`deleted_at` = 0  and ((`process`.`type` = 6 and `process`.`check` = 0 and `process`.`check2` = 0 and `process`.`check3` = 0) or (`process`.`type` = 7 and `process`.`check` = 0)) group by `process`.`order_id`) as `process` on `process`.`order_id` = `order`.`id` where `order`.`deleted_at` = 0 group by `order`.`site_id`)"
	s.Select["material_total_0"] = "`material`.`total_0`"
	s.Select["material_total_1"] = "`material`.`total_1`"
	s.Select["material_total"] = "`material`.`total`"
	s.Select["material_process_count"] = "`material`.`process_count`"
	s.Select["material_process_count_6"] = "`material`.`process_count_6`"
	s.Select["material_process_count_7"] = "`material`.`process_count_7`"*/

	paymentTableName := "(select `payment`.`site_id` as `site_id`, group_concat(`type`.`name`) as `name`, group_concat(`type`.`id`) as `id` from `zy_final_site_payment` as `payment` left join `zy_final_payment_type` as `type` on `type`.`id` = `payment`.`type_id` where `payment`.`deleted_at` = 0 and `payment`.`state` = 1 group by `payment`.`site_id`)"

	s.Select["payment_name"] = "`payment`.`name`"
	s.Select["payment_id"] = "`payment`.`id`"
	s.Select["manager_price"] = "sum(`managerprice`.`price`)"

	s.Select["settle_total"] = "settle.total"
	s.Select["settle_state"] = "settle.state"
	s.Select["shop_name"] = "shop.shop_name"
	s.Select["manager_name"] = "manager.username"
	s.Select["project_leader_name"] = "project_leader.username"
	s.Select["designer_name"] = "designer.username"

	s.LeftJoin = []db.Join{
		{
			TableName: tableTableName,
			As:        "table",
			On: []string{
				"`table`.`site_id` = " + final.FinalSite{}.TableName() + ".`id`",
			},
		},
		{
			TableName: controlTableName,
			As:        "control",
			On: []string{
				"`control`.`site_id` = " + final.FinalSite{}.TableName() + ".`id`",
			},
		},
		{
			TableName: orderTableName,
			As:        "order",
			On: []string{
				"`order`.`site_id` = " + final.FinalSite{}.TableName() + ".`id`",
			},
		},
		{
			TableName: materialTableName,
			As:        "material",
			On: []string{
				"`material`.`site_id` = " + final.FinalSite{}.TableName() + ".`id`",
			},
		},
		{
			TableName: paymentTableName,
			As:        "payment",
			On: []string{
				"`payment`.`site_id` = " + final.FinalSite{}.TableName() + ".`id`",
			},
		},
		{
			TableName: final.FinalManagerPrice{}.TableName(),
			As:        "managerprice",
			On: []string{
				"`managerprice`.`deleted_at` = 0",
				"`managerprice`.`site_id` = " + final.FinalSite{}.TableName() + ".`id`",
			},
		},
		{
			TableName: final.FinalSettle{}.TableName(),
			As:        "settle",
			On: []string{
				"`settle`.`deleted_at` = 0",
				"`settle`.`site_id` = " + final.FinalSite{}.TableName() + ".`id`",
			},
		},
		{
			TableName: final.JoinShop{}.TableName(),
			As:        "shop",
			On: []string{
				"`shop`.`id` = " + final.FinalSite{}.TableName() + ".`shop_id`",
			},
		},
		{
			TableName: final.JoinAdmin{}.TableName(),
			As:        "manager",
			On: []string{
				"`manager`.`id` = " + final.FinalSite{}.TableName() + ".`manager_id`",
			},
		},
		{
			TableName: final.JoinAdmin{}.TableName(),
			As:        "project_leader",
			On: []string{
				"`project_leader`.`id` = " + final.FinalSite{}.TableName() + ".`project_leader_id`",
			},
		},
		{
			TableName: final.JoinAdmin{}.TableName(),
			As:        "designer",
			On: []string{
				"`designer`.`id` = " + final.FinalSite{}.TableName() + ".`designer_id`",
			},
		},
	}

	s.GroupBy = final.FinalSite{}.TableName() + ".`id`"

	if starttime1s, ok := post["starttime1"]; ok {
		if starttime1, ok := db.ToInt64(starttime1s); ok {
			s.Where = append(s.Where, fmt.Sprintf("`%s`.`starttime` >= %s", final.FinalSite{}.TableName(), s.Param(starttime1)))
		}
	}
	if starttime2s, ok := post["starttime2"]; ok {
		if starttime2, ok := db.ToInt64(starttime2s); ok {
			s.Where = append(s.Where, fmt.Sprintf("`%s`.`starttime` < %s", final.FinalSite{}.TableName(), s.Param(starttime2+60*60*24)))
		}
	}
	if payment_id, ok := post["payment_id"]; ok {
		if payment_id, ok := db.ToInt64(payment_id); ok {
			s.Where = append(s.Where, fmt.Sprintf("FIND_IN_SET(%s, `payment`.`id`)", s.Param(payment_id)))
		}
	}

	return s, finaltypes, auxiliarytypes, matTypes
}

func FinalStatist(c *gin.Context) {
	var post map[string]interface{}
	if err := c.ShouldBindJSON(&post); err != nil {
	}

	s, finaltypes, auxiliarytypes, matTypes := statistQuery(post)
	query, params := s.Query()
	list, err := db.QueryMap(query, params, models.Daily{}.DB())
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	if list == nil {
		list = make([]map[string]interface{}, 0)
	}
	data := gin.H{
		"types":          finaltypes,
		"auxiliarytypes": auxiliarytypes,
		"mattypes":       matTypes,
		"list":           list,
	}
	count, err := db.GetCount(s, models.Daily{}.DB())
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	data["count"] = count
	app.Success(c, data)
}

func tableState(s string) string {
	states := []string{"未提交", "工程队长审核", "财务审核", "店长审核", "财务付款", "已完成"}
	rets := make([]string, 0)
	for _, ss := range strings.Split(s, ",") {
		if ss != "" {
			sss, _ := db.ToInt64(ss)
			if len(states) > int(sss) {
				rets = append(rets, states[sss])
			}
		}
	}
	return strings.Join(rets, ",")
}

func materialState(s string) string {
	states := []string{"待备货", "已备货", "待配送", "待收货", "已收货", "待安装", "待验收", "已完成", "已下单", "待测量", "待审核"}
	rets := make([]string, 0)
	for _, ss := range strings.Split(s, ",") {
		if ss != "" {
			sss, _ := db.ToInt64(ss)
			if len(states) > int(sss) {
				rets = append(rets, states[sss])
			}
		}
	}
	return strings.Join(rets, ",")
}
func FinalStatistExport(c *gin.Context) {
	var post map[string]interface{}
	if err := c.ShouldBindJSON(&post); err != nil {
	}

	s, finaltypes, auxiliarytypes, matTypes := statistQuery(post)
	query, params := s.Query()
	list, err := db.QueryMap(query, params, models.Daily{}.DB())
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	if list == nil {
		list = make([]map[string]interface{}, 0)
	}
	export := excelize.NewFile()
	header := []string{"ID", "业主姓名", "手机号码", "工地", "门店", "项目经理", "工程队长", "设计师", "到款", "承包额"}
	for _, t := range finaltypes {
		header = append(header, t.Name+" 控额")
		if t.LivingCount != 0 {
			header = append(header, t.Name+" 费用")
			header = append(header, t.Name+" 费用状态")
			header = append(header, t.Name+" 结算")
			header = append(header, t.Name+" 结算状态")
		} else {
			header = append(header, t.Name+" 状态")
		}
		header = append(header, t.Name+" 合计")
	}
	for _, t := range auxiliarytypes {
		header = append(header, t.Name+" 控额")
		header = append(header, t.Name+" 订单品牌")
		header = append(header, t.Name+" 订单状态")
		header = append(header, t.Name+" 订单金额")
	}
	for _, t := range matTypes {
		header = append(header, db.ToString(t["name"])+" 订单品牌")
		header = append(header, db.ToString(t["name"])+" 订单状态")
		header = append(header, db.ToString(t["name"])+" 订单金额")
	}
	for i, _ := range header {
		col, _ := excelize.ColumnNumberToName(i + 1)
		export.SetColWidth("Sheet1", col, col, 30)
	}
	export.SetSheetRow("Sheet1", "A1", &header)
	for i, v := range list {
		address := db.ToString(v["address"]) + " " + db.ToString(v["village"]) + " " + db.ToString(v["room_no"])
		area, _ := db.ToFloat64(v["area"])
		if area != 0 {
			address += " " + db.ToString(area) + "㎡"
		}
		row := []string{db.ToString(v["id"]), db.ToString(v["username"]), db.ToString(v["phone"]), address, db.ToString(v["shop_name"]), db.ToString(v["manager_name"]), db.ToString(v["project_leader_name"]), db.ToString(v["designer_name"]), db.ToString(v["payment_name"]), db.ToString(v["manager_price"])}

		for _, t := range finaltypes {
			row = append(row, db.ToString(v["table_budget_"+db.ToString(t.ID)]))
			if t.LivingCount != 0 {
				row = append(row, db.ToString(v["table_total_1_"+db.ToString(t.ID)]))
				row = append(row, tableState(db.ToString(v["table_state_1_"+db.ToString(t.ID)])))
				row = append(row, db.ToString(v["table_total_0_"+db.ToString(t.ID)]))
				row = append(row, tableState(db.ToString(v["table_state_0_"+db.ToString(t.ID)])))
			} else {
				row = append(row, tableState(db.ToString(v["table_state_"+db.ToString(t.ID)])))
			}
			row = append(row, db.ToString(v["table_total_"+db.ToString(t.ID)]))
		}
		for _, t := range auxiliarytypes {
			row = append(row, db.ToString(v["material_budget_"+db.ToString(t.ID)]))
			row = append(row, db.ToString(v["order_supplier_"+db.ToString(t.ID)]))
			row = append(row, materialState(db.ToString(v["order_state_"+db.ToString(t.ID)])))
			row = append(row, db.ToString(v["order_total_"+db.ToString(t.ID)]))
		}
		for _, t := range matTypes {
			row = append(row, db.ToString(v["order_ssupplier_"+db.ToString(t["id"])]))
			row = append(row, materialState(db.ToString(v["order_sstate_"+db.ToString(t["id"])])))
			row = append(row, db.ToString(v["order_stotal_"+db.ToString(t["id"])]))
		}
		export.SetSheetRow("Sheet1", "A"+strconv.Itoa(i+2), &row)
	}
	style, err := export.NewStyle(&excelize.Style{
		Alignment: &excelize.Alignment{
			Horizontal: "center",
			Vertical:   "center",
		},
	})
	export.SetRowStyle("Sheet1", 1, len(list)+1, style)
	exportFileName := utils.ToStr(time.Now().UnixNano()) + ".xlsx"
	b, err := export.WriteToBuffer()
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	f, err := os.Create(config.Cfg.App.ExportPath + exportFileName)
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	defer f.Close()
	_, _ = b.WriteTo(f)
	app.Success(c, gin.H{"path": "export/" + exportFileName, "filename": exportFileName})
}

func FinalMatImport(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		app.Error(c, fmt.Sprintf("get form err: %s", err.Error()))
		return
	}
	fileExt := utils.FileExt(file.Filename)
	attachKey := utils.RandomStr() + fileExt
	file.Filename = "data/" + attachKey
	if err := c.SaveUploadedFile(file, file.Filename); err != nil {
		app.Error(c, fmt.Sprintf("上传文件失败%s", err.Error()))
		return
	}
	wb, err := xlsx.OpenFile(file.Filename)
	if err != nil {
		app.Error(c, err.Error())
		return
	}

	areaId, _ := db.ToInt64(c.PostForm("area_id"))
	if areaId <= 0 {
		app.ErrorMsg(c, "导入区域错误", nil)
		return
	}

	types := make([]final.FinalMatType, 0)
	db.GetModel(map[string]interface{}{
		"deleted_at": 0,
	}, &types)

	suppliers := make([]final.FinalSupplier, 0)
	db.GetModel(map[string]interface{}{
		"deleted_at": 0,
	}, &suppliers)

	supplierMap := make(map[string]int64)
	for _, s := range suppliers {
		supplierMap[s.Name] = s.ID
	}

	for _, sh := range wb.Sheet {
		//datas := make([]map[string]interface{}, 0)
		headers := make([]string, 0)
		err := sh.ForEachRow(func(r *xlsx.Row) error {
			if r.GetCoordinate() <= 0 {
				err := r.ForEachCell(func(c *xlsx.Cell) error {
					headers = append(headers, c.String())
					return nil
				})
				if err != nil {
					return err
				}
			} else {
				var data final.FinalMat
				for i, header := range headers {
					value := r.GetCell(i).String()
					switch header {
					case "品牌":
						data.Brand = value
					case "系列":
						data.Series = value
					case "型号":
						data.Model = value
					case "规格":
						data.Specs = value
					case "颜色":
						data.Color = value
					case "SKU":
						data.SKU = value
					case "类型":
						typs := strings.Split(value, "/")
						pid := int64(0)
						path := ""
						for _, t := range typs {
							if t == "" {
								continue
							}
							var ts final.FinalMatType
							for _, typ := range types {
								if typ.Name == t && typ.Pid == pid {
									ts = typ
									break
								}
							}
							if ts.ID == 0 {
								id, err := db.InsertModel(db.Type(ts), map[string]interface{}{
									"name": t,
									"pid":  pid,
									"path": path + db.ToString(pid) + ",",
								})
								if err != nil {
									return err
								}
								ts.ID = id
								ts.Name = t
								ts.Pid = pid
								ts.Path = path + db.ToString(pid) + ","
								types = append(types, ts)
							}
							pid = ts.ID
							path = ts.Path
						}
						data.TypeId = pid
					case "材料商":
						data.SupplierId = supplierMap[value]
					case "供货价":
						data.Price, _ = db.ToFloat64(value)
					case "控价":
						if value == "" {
							data.ControlPrice = -1
						} else {
							data.ControlPrice, _ = db.ToFloat64(value)
						}
					case "销售价":
						if value == "" {
							data.SalesPrice = -1
						} else {
							data.SalesPrice, _ = db.ToFloat64(value)
						}
					case "代购价":
						if value == "" {
							data.PurchasePrice = -1
						} else {
							data.PurchasePrice, _ = db.ToFloat64(value)
						}
					default:
					}
				}
				if data.Brand == "" || data.Model == "" || data.SupplierId == 0 {
					return nil
				}
				var mat final.FinalMat
				db.GetModel(map[string]interface{}{
					"area_id":    areaId,
					"brand":      data.Brand,
					"series":     data.Series,
					"model":      data.Model,
					"specs":      data.Specs,
					"color":      data.Color,
					"deleted_at": 0,
				}, &mat)
				da := map[string]interface{}{
					"area_id":     areaId,
					"brand":       data.Brand,
					"series":      data.Series,
					"model":       data.Model,
					"specs":       data.Specs,
					"color":       data.Color,
					"type_id":     data.TypeId,
					"supplier_id": data.SupplierId,
					"sku":         data.SKU,
				}
				if mat.Price != data.Price || mat.ControlPrice != data.ControlPrice || mat.SalesPrice != data.SalesPrice || mat.PurchasePrice != data.PurchasePrice {
					da["price"] = data.Price
					da["control_price"] = data.ControlPrice
					da["sales_price"] = data.SalesPrice
					da["purchase_price"] = data.PurchasePrice
					//da["state"] = 0
				}
				if mat.ID == 0 {
					_, err := db.InsertModel(db.Type(final.FinalMat{}), da)
					if err != nil {
						return err
					}
				} else {
					err := db.UpdateModel(db.Type(mat), mat.ID, da)
					if err != nil {
						return err
					}
				}
			}
			return nil
		})
		if err != nil {
			app.Error(c, err.Error())
			return
		}
		//if len(datas) != 0 {
		//	db.InsertModels(db.Type(final.FinalMat{}), datas)
		//}
	}
	app.Success(c, nil)
}

func FinalMatOrderStatist(c *gin.Context) {
	var post map[string]interface{}
	if err := c.ShouldBindJSON(&post); err != nil {
		//app.ErrorMsg(c, err.Error(), nil)
		//return
	}

	var s db.Select
	s.TableName = "`zy_final_material_order`"
	s.Select = map[string]string{
		"date":        "UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%Y-%m'), '-01'))",
		"supplier_id": "`zy_final_material_order`.`supplier_id`",
		"count":       "COUNT(1)",
		"total":       "SUM(`zy_final_material_order`.`total`)",
	}
	s.GroupBy = "UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%Y-%m'), '-01')), `zy_final_material_order`.`supplier_id`"
	s.OrderBy = "UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%Y-%m'), '-01')) DESC"

	/*s.LeftJoin = []db.Join{{
		TableName: "zy_final_supplier",
		As:        "supplier",
		On:        []string{"`supplier`.`id` = `zy_final_material_order`.`supplier_id`"},
	}}*/

	if date, ok := post["date"]; ok {
		if n, ok := db.ToInt64(date); ok {
			s.Where = append(s.Where, fmt.Sprintf("UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%%Y-%%m'), '-01')) = %s", s.Param(n)))
		}
	}
	if startdate, ok := post["startdate"]; ok {
		if n, ok := db.ToInt64(startdate); ok {
			s.Where = append(s.Where, fmt.Sprintf("UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%%Y-%%m'), '-01')) >= %s", s.Param(n)))
		}
	}
	if enddate, ok := post["enddate"]; ok {
		if n, ok := db.ToInt64(enddate); ok {
			s.Where = append(s.Where, fmt.Sprintf("UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%%Y-%%m'), '-01')) <= %s", s.Param(n)))
		}
	}
	if supplier_id, ok := post["supplier_id"]; ok {
		if n, ok := db.ToInt64(supplier_id); ok {
			s.Where = append(s.Where, fmt.Sprintf("`zy_final_material_order`.`supplier_id` =  %s", s.Param(n)))
		}
	}
	s.Where = append(s.Where, fmt.Sprintf("`zy_final_material_order`.`deleted_at` = %s", s.Param(0)))

	_, size_ok := post["size"]
	_, page_ok := post["page"]

	if size_ok && page_ok {
		var size int64 = 20
		var page int64 = 1
		if num, ok := db.ToInt64(post["size"]); ok {
			size = num
		}
		if num, ok := db.ToInt64(post["page"]); ok {
			page = num
		}
		s.Limit = size
		s.Offset = size * (page - 1)
	}

	query, params := s.Query()
	list, err := db.QueryMap(query, params, nil)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	if list == nil {
		list = make([]map[string]interface{}, 0)
	}
	count, err := db.GetCount(s, nil)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}

	app.Success(c, gin.H{
		"list":  list,
		"count": count,
	})
}

func FinalMatOrderStatistExport(c *gin.Context) {
	var post map[string]interface{}
	if err := c.ShouldBindJSON(&post); err != nil {
		//app.ErrorMsg(c, err.Error(), nil)
		//return
	}

	var s db.Select
	s.TableName = "`zy_final_material_order`"
	s.Select = map[string]string{
		"date":          "UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%Y-%m'), '-01'))",
		"supplier_id":   "`zy_final_material_order`.`supplier_id`",
		"supplier_name": "`supplier`.`name`",
		"count":         "COUNT(1)",
		"total":         "SUM(`zy_final_material_order`.`total`)",
	}
	s.GroupBy = "UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%Y-%m'), '-01')), `zy_final_material_order`.`supplier_id`"
	s.OrderBy = "UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%Y-%m'), '-01')) DESC"

	s.LeftJoin = []db.Join{{
		TableName: "zy_final_supplier",
		As:        "supplier",
		On:        []string{"`supplier`.`id` = `zy_final_material_order`.`supplier_id`"},
	}}

	if date, ok := post["date"]; ok {
		if n, ok := db.ToInt64(date); ok {
			s.Where = append(s.Where, fmt.Sprintf("UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%%Y-%%m'), '-01')) = %s", s.Param(n)))
		}
	}
	if startdate, ok := post["startdate"]; ok {
		if n, ok := db.ToInt64(startdate); ok {
			s.Where = append(s.Where, fmt.Sprintf("UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%%Y-%%m'), '-01')) >= %s", s.Param(n)))
		}
	}
	if enddate, ok := post["enddate"]; ok {
		if n, ok := db.ToInt64(enddate); ok {
			s.Where = append(s.Where, fmt.Sprintf("UNIX_TIMESTAMP(CONCAT(from_unixtime(`zy_final_material_order`.`take_time`,'%%Y-%%m'), '-01')) <= %s", s.Param(n)))
		}
	}
	if supplier_id, ok := post["supplier_id"]; ok {
		if n, ok := db.ToInt64(supplier_id); ok {
			s.Where = append(s.Where, fmt.Sprintf("`zy_final_material_order`.`supplier_id` =  %s", s.Param(n)))
		}
	}
	s.Where = append(s.Where, fmt.Sprintf("`zy_final_material_order`.`deleted_at` = %s", s.Param(0)))

	query, params := s.Query()
	list, err := db.QueryMap(query, params, nil)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	if list == nil {
		list = make([]map[string]interface{}, 0)
	}

	export := excelize.NewFile()
	rows := make([][]string, 0)
	fields := []db.ExportField{
		{
			Label: "下单时间",
			Name:  "date",
			Width: 20,
		},
		{
			Label: "材料商",
			Name:  "supplier_name",
			Width: 20,
		},
		{
			Label: "订单数",
			Name:  "count",
			Width: 20,
		},
		{
			Label: "订单金额",
			Name:  "total",
			Width: 20,
		},
	}

	header := make([]string, 0)
	for i, field := range fields {
		header = append(header, field.Label)
		if field.Width != 0 {
			col, _ := excelize.ColumnNumberToName(i + 1)
			export.SetColWidth("Sheet1", col, col, field.Width)
		}
	}
	rows = append(rows, header)

	for _, v := range list {
		row := make([]string, 0)
		for _, field := range fields {
			if field.Name == "date" {
				dates := ""
				date, _ := db.ToFloat64(v["date"])
				if date != 0 {
					t := time.Unix(int64(date), 0).Local()
					dates = t.Format("2006-01")
				}
				row = append(row, dates)
			} else {
				row = append(row, db.ToString(v[field.Name]))
			}
		}
		rows = append(rows, row)
	}
	style, err := export.NewStyle(&excelize.Style{
		Alignment: &excelize.Alignment{
			Horizontal: "center",
			Vertical:   "center",
		},
	})
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	for i, row := range rows {
		//shrow := sh.AddRow()
		//shrow.SetHeight(30)
		export.SetSheetRow("Sheet1", "A"+strconv.Itoa(i+1), &row)
		//for _, cell := range row {
		//	c := shrow.AddCell()
		//	c.Value = cell
		//}
	}
	export.SetRowStyle("Sheet1", 1, len(rows), style)
	exportFileName := utils.ToStr(time.Now().UnixNano()) + ".xlsx"
	b, err := export.WriteToBuffer()
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	f, err := os.Create(config.Cfg.App.ExportPath + exportFileName)
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	defer f.Close()
	_, _ = b.WriteTo(f)
	app.Success(c, gin.H{"path": "export/" + exportFileName, "filename": exportFileName})
}

type FinalMatBatchStateFrom struct {
	MatIds []int `form:"mat_ids" json:"mat_ids" binding:"required"`
	State  int64 `form:"state" json:"state"`
}

func FinalMatBatchState(c *gin.Context) {
	var form FinalMatBatchStateFrom
	if app.Bind(c, &form) != nil {
		return
	}

	if len(form.MatIds) == 0 {
		app.ErrorMsg(c, "没有权限", nil)
		return
	}

	err := db.UpdateModels(db.Type(final.FinalMat{}), map[string]interface{}{
		"id in":      form.MatIds,
		"deleted_at": 0,
	}, map[string]interface{}{
		"state": form.State,
	})
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}

	app.Success(c, nil)
}

var num int64

func Generate(t time.Time) string {
	s := t.Format(timeformat.Continuity)
	m := t.UnixNano()/1e6 - t.UnixNano()/1e9*1e3
	ms := sup(m, 3)
	p := os.Getpid() % 1000
	ps := sup(int64(p), 3)
	i := atomic.AddInt64(&num, 1)
	r := i % 10000
	rs := sup(r, 4)
	n := fmt.Sprintf("%s%s%s%s", s, ms, ps, rs)
	return n
}

// 对长度不足n的数字前面补0
func sup(i int64, n int) string {
	m := fmt.Sprintf("%d", i)
	for len(m) < n {
		m = fmt.Sprintf("0%s", m)
	}
	return m
}

func FinalTestSite(c *gin.Context) {

	createTestsite(36)
	createTestsite(38)
	createTestsite(37)
	createTestsite(34)
	createTestsite(35)
	createTestsite(134)
	createTestsite(41)
	createTestsite(40)
	/*createTestsite(102)
	createTestsite(104)
	createTestsite(97)
	createTestsite(100)
	createTestsite(132)
	createTestsite(90)
	createTestsite(87)
	createTestsite(99)
	createTestsite(89)
	createTestsite(94)
	createTestsite(133)
	createTestsite(92)
	createTestsite(95)
	createTestsite(105)
	createTestsite(103)*/
	/*createTestsiteManager(57, 797)
	createTestsiteManager(67, 797)
	createTestsiteManager(877, 797)
	createTestsiteManager(1179, 797)
	createTestsiteManager(1218, 797)
	createTestsiteManager(1267, 797)
	createTestsiteManager(1331, 797)
	createTestsiteManager(812, 797)
	createTestsiteManager(235, 801)
	createTestsiteManager(1211, 801)
	createTestsiteManager(1148, 801)
	createTestsiteManager(1224, 801)
	createTestsiteManager(1308, 801)
	createTestsiteManager(1371, 801)

	createTestsite(48)
	createTestsite(49)
	createTestsite(50)
	createTestsite(51)
	createTestsite(52)
	createTestsite(53)
	createTestsite(54)
	createTestsite(55)
	createTestsite(56)
	createTestsite(57)
	createTestsite(58)
	createTestsite(59)
	createTestsite(60)
	createTestsite(61)
	createTestsite(62)
	createTestsite(63)
	createTestsite(64)
	createTestsite(65)
	createTestsite(66)
	createTestsite(67)
	createTestsite(68)
	createTestsite(69)
	createTestsite(70)
	createTestsite(71)
	createTestsite(72)
	createTestsite(73)
	createTestsite(74)
	createTestsite(75)
	createTestsite(76)
	createTestsite(77)
	createTestsite(78)
	createTestsite(79)
	createTestsite(80)
	createTestsite(81)
	createTestsite(82)
	createTestsite(83)
	createTestsite(84)
	createTestsite(85)
	createTestsite(86)
	createTestsite(123)
	createTestsite(128)
	createTestsite(129)
	createTestsite(130)
	createTestsite(131)*/

	app.Success(c, nil)
}

func createTestsite(id int) {

	siteid := 1546

	var mat final.FinalMat
	db.GetModel(map[string]interface{}{
		"supplier_id": id,
		"state":       1,
	}, &mat)

	if mat.ID == 0 {
		return
	}

	var mattype final.FinalMatType
	db.GetModel(map[string]interface{}{
		"id": mat.TypeId,
	}, &mattype)

	if mattype.ID == 0 {
		return
	}

	var supplier final.FinalSupplier
	db.GetModel(map[string]interface{}{
		"id": id,
	}, &supplier)

	if supplier.ID == 0 {
		return
	}

	orderNo := Generate(time.Now())
	datas := map[string]interface{}{
		"order_no":    orderNo,
		"site_id":     siteid,
		"type":        mattype.Type,
		"is_custom":   mattype.IsCustom,
		"type_id":     0,
		"supplier_id": id,
		"total":       mat.Price,
		"state":       0,
		"take_time":   time.Now().Unix(),
		"created_id":  1083,
	}
	if mattype.IsCustom == 1 {
		datas["state"] = 8
	}
	orderid, _ := db.InsertModel(db.Type(final.FinalMaterialOrder{}), datas)
	db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
		"item_id":  0,
		"order_id": orderid,
		"mat_id":   mat.ID,
		"price":    mat.Price,
		"num":      1,
		"total":    mat.Price,
		"remark":   "",
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderProcess{}), map[string]interface{}{
		"order_id":   orderid,
		"type":       0,
		"created_id": 1083,
	})
	if mattype.IsCustom == 1 {
		final.SendMaterialMessage(int(1083), orderNo, orderid, "XXXXXXXXX", "定制品已下单，请通知测量")
	} else {
		final.SendMaterialMessage(int(supplier.AdminId), orderNo, orderid, "XXXXXXXXX", "订单已下单，请安排备货")
	}

}

func createTestsiteManager(id int, project_leader_id int) {

	siteid, _ := db.InsertModel(db.Type(final.FinalSite{}), map[string]interface{}{
		"type_id":           1,
		"area_id":           1,
		"username":          "测试",
		"phone":             "13000000000",
		"address":           "XXXXXXXXX",
		"area":              100,
		"shop_id":           5,
		"manager_id":        id,
		"project_leader_id": project_leader_id,
		"designer_id":       1083,
		"created_id":        1083,
		"change_state":      1,
	})

	db.InsertModel(db.Type(final.FinalManagerPrice{}), map[string]interface{}{
		"site_id": siteid,
		"price":   100000,
	})

	ptypes := make([]final.FinalPaymentType, 0)
	db.GetModel(map[string]interface{}{
		"deleted_at": 0,
	}, &ptypes)
	for _, v := range ptypes {
		data := map[string]interface{}{
			"type_id": v.ID,
			"site_id": siteid,
			"state":   1,
		}
		db.InsertModel(db.Type(final.FinalSitePayment{}), data)
	}

	db.InsertModel(db.Type(final.FinalMaterial{}), map[string]interface{}{
		"type_id": 1,
		"site_id": siteid,
		"budget":  4500,
	})

	orderNo := Generate(time.Now())
	orderid, _ := db.InsertModel(db.Type(final.FinalMaterialOrder{}), map[string]interface{}{
		"order_no":    orderNo,
		"site_id":     siteid,
		"type":        1,
		"is_custom":   1,
		"type_id":     0,
		"supplier_id": 112,
		"total":       10988.35,
		"state":       8,
		"take_time":   time.Now().Unix(),
		"created_id":  1083,
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
		"item_id":  220,
		"order_id": orderid,
		"mat_id":   4381,
		"price":    410,
		"num":      4.88,
		"total":    2000.8,
		"remark":   "",
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
		"item_id":  221,
		"order_id": orderid,
		"mat_id":   4380,
		"price":    485,
		"num":      9,
		"total":    4365,
		"remark":   "",
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
		"item_id":  225,
		"order_id": orderid,
		"mat_id":   4378,
		"price":    0,
		"num":      1,
		"total":    0,
		"remark":   "",
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
		"item_id":  223,
		"order_id": orderid,
		"mat_id":   4382,
		"price":    388,
		"num":      2,
		"total":    776,
		"remark":   "",
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
		"item_id":  224,
		"order_id": orderid,
		"mat_id":   4383,
		"price":    400,
		"num":      1,
		"total":    400,
		"remark":   "",
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
		"item_id":  222,
		"order_id": orderid,
		"mat_id":   4379,
		"price":    555,
		"num":      6.21,
		"total":    3446.55,
		"remark":   "",
	})
	db.InsertModel(db.Type(final.FinalMaterialOrderProcess{}), map[string]interface{}{
		"order_id":   orderid,
		"type":       0,
		"created_id": 1083,
	})
	final.SendMaterialMessage(int(id), orderNo, orderid, "XXXXXXXXX", "定制品已下单，请通知测量")

}

func FinalMaterialSettlePaymentExport(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "id must be a number", nil)
		return
	}

	type FinalMaterialSettle struct {
		ID           int64   `json:"id" prop:"add:false"`
		ShopName     string  `json:"shop_name" prop:"select:shop.shop_name"`
		CreatedAt    int64   `json:"created_at" prop:"add:false"`
		AccountName  string  `json:"account_name" prop:"select:account.account_name"`
		AccountBank  string  `json:"account_bank" prop:"select:account.account_bank"`
		AccountNo    string  `json:"account_no" prop:"select:account.account_no"`
		SupplierName string  `json:"supplier_name" type:"string" prop:"select:supplier.name" search:"like"`
		Total        float64 `json:"total" label:"合计金额" type:"float" prop:"add:false" search:"="`
		final.FinalMaterialSettleMobile
	}
	var model FinalMaterialSettle
	db.GetModel(map[string]interface{}{"id": id}, &model)
	if model.ID == 0 {
		app.ErrorMsg(c, "结算不存在", nil)
		return
	}

	template, err := excelize.OpenFile("fkspdTemplate.xlsx")
	//template, err := xlsx.OpenFile("fkspdTemplate.xlsx")
	if err != nil {
		app.ErrorMsg(c, "系统错误", nil)
		return
	}
	for _, sheet := range template.GetSheetList() {
		template.SetCellValue(sheet, "B3", model.ShopName)
		template.SetCellValue(sheet, "F3", time.Unix(model.CreatedAt, 0).Format("2006.01.02"))
		template.SetCellValue(sheet, "B4", model.AccountName)
		template.SetCellValue(sheet, "B5", model.AccountBank)
		template.SetCellValue(sheet, "E5", model.AccountNo)
		template.SetCellValue(sheet, "B6", model.SupplierName+"(材料款)")
		template.SetCellValue(sheet, "B8", model.Total)
		/*cell, err := sheet.Cell(2, 1)
		if err != nil {
			app.ErrorMsg(c, "系统错误", nil)
			return
		}
		cell.SetString(model.ShopName)

		cell, err = sheet.Cell(2, 5)
		if err != nil {
			app.ErrorMsg(c, "系统错误", nil)
			return
		}
		cell.SetString(time.Unix(model.CreatedAt, 0).Format("2006.01.02"))

		cell, err = sheet.Cell(3, 1)
		if err != nil {
			app.ErrorMsg(c, "系统错误", nil)
			return
		}
		cell.SetString(model.AccountName)

		cell, err = sheet.Cell(4, 1)
		if err != nil {
			app.ErrorMsg(c, "系统错误", nil)
			return
		}
		cell.SetString(model.AccountBank)

		cell, err = sheet.Cell(4, 4)
		if err != nil {
			app.ErrorMsg(c, "系统错误", nil)
			return
		}
		cell.SetString(model.AccountNo)

		cell, err = sheet.Cell(5, 1)
		if err != nil {
			app.ErrorMsg(c, "系统错误", nil)
			return
		}
		cell.SetString(model.SupplierName + "(材料款)")

		cell, err = sheet.Cell(7, 1)
		if err != nil {
			app.ErrorMsg(c, "系统错误", nil)
			return
		}
		cell.SetFloat(model.Total)*/
	}

	exportFileName := utils.ToStr(time.Now().UnixNano()) + ".xlsx"
	b, err := template.WriteToBuffer()
	if err != nil {
		app.ErrorMsg(c, "系统错误", nil)
		return
	}
	f, err := os.Create(config.Cfg.App.ExportPath + exportFileName)
	if err != nil {
		app.ErrorMsg(c, "系统错误", nil)
		return
	}
	defer f.Close()
	_, _ = b.WriteTo(f)
	/*if err := template.Save(config.Cfg.App.ExportPath + exportFileName); err != nil {
		app.ErrorMsg(c, "系统错误", nil)
		return
	}*/

	app.Success(c, gin.H{"path": "export/" + exportFileName, "filename": exportFileName})
}

type FinalSiteContractDispatchFrom struct {
	Id              int64 `form:"id" json:"id" binding:"required"`
	TypeId          int64 `form:"type_id" json:"type_id" binding:"required"`
	ManagerId       int64 `form:"manager_id" json:"manager_id" binding:"required"`
	ProjectLeaderId int64 `form:"project_leader_id" json:"project_leader_id" binding:"required"`
}

func FinalSiteContractDispatch(c *gin.Context) {
	var forms FinalSiteContractDispatchFrom
	if app.Bind(c, &forms) != nil {
		return
	}

	var model final.FinalSite
	db.GetModel(map[string]interface{}{
		"id":         forms.Id,
		"deleted_at": 0,
	}, &model)

	err := db.UpdateModel(db.Type(model), forms.Id, map[string]interface{}{
		"type_id":           forms.TypeId,
		"manager_id":        forms.ManagerId,
		"project_leader_id": forms.ProjectLeaderId,
	})
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}

	users, err := user.GetOne(map[string]interface{}{"phone": model.Phone}, nil, nil)
	if err != nil {
		app.ErrorMsg(c, "获取用户信息失败", nil)
		return
	}
	if users == nil {
		app.ErrorMsg(c, "获取用户信息失败", nil)
		return
	}

	var pkg final.FinalPkg
	db.GetModel(map[string]interface{}{
		"id":         model.PkgId,
		"deleted_at": 0,
	}, &pkg)

	var typ final.FinalSiteType
	db.GetModel(map[string]interface{}{
		"id":         forms.TypeId,
		"deleted_at": 0,
	}, &typ)
	settlements := make([]int64, 0)
	if typ.ID != 0 {
		for _, s := range strings.Split(typ.Settlement, ",") {
			if n, ok := db.ToInt64(s); ok {
				settlements = append(settlements, n)
			}
		}
	}

	ptypes := make([]final.FinalPaymentType, 0)
	db.GetModel(map[string]interface{}{
		"deleted_at": 0,
	}, &ptypes)
	for _, v := range ptypes {
		data := map[string]interface{}{
			"type_id": v.ID,
			"site_id": forms.Id,
		}
		for _, s := range settlements {
			if s == v.ID {
				data["state"] = 1
			}
		}
		id, err := db.InsertModel(db.Type(final.FinalSitePayment{}), data)
		if err == nil {
			final.FinalSitePayment{}.AddAfter(c, id, data, data)
		}
	}

	var order budget2.Order
	if model.OrderId != 0 {
		db.GetModel(map[string]interface{}{
			"id":         model.OrderId,
			"deleted_at": 0,
		}, &order)
	}

	if order.ID == 0 {
		var pkg final.FinalPkg
		db.GetModel(map[string]interface{}{
			"id":         model.PkgId,
			"deleted_at": 0,
		}, &pkg)

		types := make([]final.FinalType, 0)
		db.GetModel(map[string]interface{}{
			"state":      1,
			"deleted_at": 0,
		}, &types)
		for _, v := range types {
			data := map[string]interface{}{
				"type_id": v.ID,
				"site_id": forms.Id,
			}
			if v.CalcValue != "" {
				expression, err := govaluate.NewEvaluableExpression(v.CalcValue)

				if err == nil {
					parameters := make(map[string]interface{}, 8)
					parameters["面积"] = model.Area
					parameters["套餐"] = pkg.Name
					result, err := expression.Evaluate(parameters)
					if err == nil {
						data["budget"], _ = db.ToFloat64(result)
					}
				}
			}
			id, err := db.InsertModel(db.Type(final.FinalSiteControl{}), data)
			if err == nil {
				final.FinalSiteControl{}.AddAfter(c, id, data, data)
			}
		}
		mauxiliarys := make([]final.FinalMatAuxiliary, 0)
		db.GetModel(map[string]interface{}{
			"preset":     1,
			"deleted_at": 0,
		}, &mauxiliarys)
		for _, v := range mauxiliarys {
			if v.Name == "开工形象" && (model.ShopId == 18 || forms.TypeId == 4) {
				continue
			}
			data := map[string]interface{}{
				"type_id": v.ID,
				"site_id": forms.Id,
			}
			if v.CalcValue != "" {
				expression, err := govaluate.NewEvaluableExpression(v.CalcValue)

				if err == nil {
					parameters := make(map[string]interface{}, 8)
					parameters["面积"] = model.Area
					parameters["套餐"] = pkg.Name
					result, err := expression.Evaluate(parameters)
					if err == nil {
						data["budget"], _ = db.ToFloat64(result)
					}
				}
			}
			id, err := db.InsertModel(db.Type(final.FinalMaterial{}), data)
			if err == nil {
				final.FinalMaterial{}.AddAfter(c, id, data, data)
			}
		}

		address := model.Address
		if model.Village != " " {
			address += " " + model.Village
		}
		if model.RoomNo != " " {
			address += " " + model.RoomNo
		}

		switch model.ShopId {
		case 9, 13, 14, 18:
			final.SendSiteMessage(1003, forms.Id, address, "工地已创建，请及时下单")
		case 10, 12, 15:
			final.SendSiteMessage(1004, forms.Id, address, "工地已创建，请及时下单")
		case 6, 16:
			final.SendSiteMessage(1257, forms.Id, address, "工地已创建，请及时下单")
		case 7, 17:
			final.SendSiteMessage(1173, forms.Id, address, "工地已创建，请及时下单")
		}
	} else {
		o, err := order.LoadOrder()
		if err != nil {
			app.ErrorMsg(c, err.Error(), nil)
			return
		}

		for name, price := range o.Form.ManagerPrice() {
			data := map[string]interface{}{
				"site_id": forms.Id,
				"price":   price,
				"explain": name,
			}
			id, err := db.InsertModel(db.Type(final.FinalManagerPrice{}), data)
			if err == nil {
				final.FinalManagerPrice{}.AddAfter(c, id, data, data)
			}
		}

		buildControl := o.Form.BuildControl()

		types := make([]final.FinalType, 0)
		db.GetModel(map[string]interface{}{
			"deleted_at": 0,
		}, &types)
		for _, v := range types {
			budget := buildControl[v.Name]
			if budget != 0 {
				data := map[string]interface{}{
					"type_id": v.ID,
					"site_id": forms.Id,
					"budget":  budget,
				}
				id, err := db.InsertModel(db.Type(final.FinalSiteControl{}), data)
				if err == nil {
					final.FinalSiteControl{}.AddAfter(c, id, data, data)
				}
			}
		}

		auxiliaryControl := o.Form.AuxiliaryControl()
		mauxiliarys := make([]final.FinalMatAuxiliary, 0)
		db.GetModel(map[string]interface{}{
			"deleted_at": 0,
		}, &mauxiliarys)
		for _, v := range mauxiliarys {
			budget := auxiliaryControl[v.Name]
			if budget != 0 {
				data := map[string]interface{}{
					"type_id": v.ID,
					"site_id": forms.Id,
					"budget":  budget,
				}
				id, err := db.InsertModel(db.Type(final.FinalMaterial{}), data)
				if err == nil {
					final.FinalMaterial{}.AddAfter(c, id, data, data)
				}
			}
		}

		address := model.Address
		if model.Village != " " {
			address += " " + model.Village
		}
		if model.RoomNo != " " {
			address += " " + model.RoomNo
		}

		materials := o.Form.Materials()
		type Mat struct {
			ID  int64
			Sum float64
		}
		matss := make([]Mat, 0)
		matids := make([]int64, 0)
		for id, sum := range materials {
			matss = append(matss, Mat{
				ID:  id,
				Sum: sum,
			})
			matids = append(matids, id)
		}

		matsss, err := db.GetModelMap(db.Type(final.FinalMatMobile{}), map[string]interface{}{
			"id in":      matids,
			"deleted_at": 0,
		}, nil)

		if err != nil {
			app.ErrorMsg(c, err.Error(), nil)
			return
		}

		type Mats struct {
			ID              int64
			Type            int64
			SupplierId      int64
			Price           float64
			IsCustom        int64
			SupplierAdminId int64
		}

		matMap := make(map[int64]Mats)
		for _, mat := range matsss {
			supplier_id, _ := db.ToInt64(mat["supplier_id"])
			supplier_admin_id, _ := db.ToInt64(mat["supplier_admin_id"])
			id, _ := db.ToInt64(mat["id"])
			typ, _ := db.ToInt64(mat["type"])
			price, _ := db.ToFloat64(mat["price"])
			is_custom, _ := db.ToInt64(mat["is_custom"])

			matMap[id] = Mats{
				ID:              id,
				Type:            typ,
				SupplierId:      supplier_id,
				Price:           price,
				SupplierAdminId: supplier_admin_id,
				IsCustom:        is_custom,
			}
		}

		cTotal := float64(0)

		itemMap := make(map[int64]map[int64]map[int64][]final.FinalMaterialOrderItem, 0)
		supplierAdminMap := make(map[int64]int64)
		supplierTotalMap := make(map[int64]float64)
		for _, v := range matss {
			if v.Sum <= 0 {
				continue
			}
			if mat, ok := matMap[v.ID]; ok {
				supplierAdminMap[mat.SupplierId] = mat.SupplierAdminId
				if _, ok := itemMap[mat.Type]; !ok {
					itemMap[mat.Type] = make(map[int64]map[int64][]final.FinalMaterialOrderItem)
				}
				if _, ok := itemMap[mat.Type][mat.IsCustom]; !ok {
					itemMap[mat.Type][mat.IsCustom] = make(map[int64][]final.FinalMaterialOrderItem)
				}

				is := make([]final.FinalMaterialOrderItem, 0)
				if s, ok := itemMap[mat.Type][mat.IsCustom][mat.SupplierId]; ok {
					is = s
				}
				total := utils.FloatMul(mat.Price, v.Sum, 2)
				is = append(is, final.FinalMaterialOrderItem{
					MatId: mat.ID,
					Price: mat.Price,
					Num:   v.Sum,
					Total: total,
				})
				itemMap[mat.Type][mat.IsCustom][mat.SupplierId] = is
				if _, ok := supplierTotalMap[mat.SupplierId]; !ok {
					supplierTotalMap[mat.SupplierId] = 0
				}
				supplierTotalMap[mat.SupplierId] = utils.FloatAdd(supplierTotalMap[mat.SupplierId], total, 2)
				cTotal = utils.FloatAdd(cTotal, total, 2)
			}
		}

		supplierids := make([]int64, 0)
		for id, _ := range supplierAdminMap {
			supplierids = append(supplierids, id)
		}

		suppliers, err := db.GetModelMap(db.Type(final.FinalSupplierPrepaymentStatist{}), map[string]interface{}{
			"id in":      supplierids,
			"prepayment": 1,
			"deleted_at": 0,
		}, nil)

		if err != nil {
			app.ErrorMsg(c, err.Error(), nil)
			return
		}

		for _, v := range suppliers {
			id, _ := db.ToInt64(v["id"])
			name := db.ToString(v["name"])
			warning_amount, _ := db.ToFloat64(v["warning_amount"])
			notice_ids := db.ToString(v["notice_ids"])
			total, _ := db.ToFloat64(v["total"])
			noticeIds := make([]int64, 0)
			for _, i := range strings.Split(notice_ids, ",") {
				if i != "" {
					if n, ok := db.ToInt64(i); ok {
						noticeIds = append(noticeIds, n)
					}
				}
			}
			if supplierTotalMap[id] > total {
				for _, i := range noticeIds {
					err := final.SendMaterialMessage(int(i), "", 0, address, "材料商"+name+"预付款金额不足，下单失败")
					logger.Sugar.Infof("SendMaterialMessage, err: %v", err)
				}
				app.ErrorMsg(c, "材料商"+name+"预付款金额不足，下单失败", nil)
				return
			}
			if total-supplierTotalMap[id] <= warning_amount {
				for _, i := range noticeIds {
					err := final.SendMaterialMessage(int(i), "", 0, address, "材料商"+name+"预付款金额仅剩"+db.ToString(total-supplierTotalMap[id]))
					logger.Sugar.Infof("SendMaterialMessage, err: %v", err)
				}
			}
		}

		orderNo := Generate(time.Now())
		n := 0

		supplierOrderMap := make(map[int64]final.FinalMaterialOrder)

		customOrders := make([]final.FinalMaterialOrder, 0)

		for ctyp, itemmap1 := range itemMap {
			for is_custom, itemmap2 := range itemmap1 {
				for supplier_id, items := range itemmap2 {
					n++
					order_no := orderNo
					order_no = order_no + "-" + db.ToString(n)

					total := float64(0)
					cartids := make([]int64, 0)
					for _, v := range items {
						cartids = append(cartids, v.ID)
						total = utils.FloatAdd(total, v.Total, 2)
					}

					datas := map[string]interface{}{
						"order_no":    order_no,
						"site_id":     model.ID,
						"type":        ctyp,
						"is_custom":   is_custom,
						"supplier_id": supplier_id,
						"total":       total,
						"state":       0,
						"take_time":   time.Now().Unix(),
						"created_id":  0,
					}
					if is_custom == 1 {
						datas["state"] = 8
					}

					orderid, err := db.InsertModel(db.Type(final.FinalMaterialOrder{}), datas)
					if err != nil {
						app.ErrorMsg(c, err.Error(), nil)
						return
					}

					if is_custom == 0 {
						supplierOrderMap[supplier_id] = final.FinalMaterialOrder{
							ID:      orderid,
							OrderNo: order_no,
						}
					} else {
						customOrders = append(customOrders, final.FinalMaterialOrder{
							ID:      orderid,
							OrderNo: order_no,
						})
					}

					for _, v := range items {
						_, err := db.InsertModel(db.Type(final.FinalMaterialOrderItem{}), map[string]interface{}{
							"item_id":  v.ItemId,
							"order_id": orderid,
							"mat_id":   v.MatId,
							"price":    v.Price,
							"num":      v.Num,
							"total":    v.Total,
							"remark":   v.Remark,
						})
						if err != nil {
							app.ErrorMsg(c, err.Error(), nil)
							return
						}

					}

					_, err = db.InsertModel(db.Type(final.FinalMaterialOrderProcess{}), map[string]interface{}{
						"order_id":   orderid,
						"type":       0,
						"created_id": 0,
					})
					if err != nil {
						app.ErrorMsg(c, err.Error(), nil)
						return
					}

				}
			}
		}

		for s, o := range supplierOrderMap {
			err := final.SendMaterialMessage(int(supplierAdminMap[s]), o.OrderNo, o.ID, address, "订单已下单，请安排备货")
			logger.Sugar.Infof("SendMaterialMessage, err: %v", err)
		}

		for _, o := range customOrders {
			err := final.SendMaterialMessage(int(model.ManagerId), o.OrderNo, o.ID, address, "定制品已下单，请通知测量")
			logger.Sugar.Infof("SendMaterialMessage, err: %v", err)
		}

	}

	err = db.UpdateModel(db.Type(order), model.OrderId, map[string]interface{}{
		"state": 2,
	})
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}

	address := model.Village + model.RoomNo
	if address == "" {
		address = model.Address
	}

	houseList := make([]*structs.HouseList, 0)
	_, err = user.GetHouseList(map[string]interface{}{"user_id": users.ID, "deleted_at": 0}, nil, app.Page{}, &houseList)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	haveHouse := false
	for _, house := range houseList {
		if house.Address == address {
			haveHouse = true
			break
		}
	}

	if !haveHouse {
		/*user.HouseAdd(form.HouseAdd{
			UserID:        users.ID,
			PkgID:         int(pkg.MatpkgId),
			ShopID:        int(model.ShopId),
			Salesman:      int(model.SalesmanId),
			ProjectLeader: int(model.ProjectLeaderId),
			Address:       address,
			Designer:      int(model.DesignerId),
			Supervisor:    int(model.ManagerId),
			ProjectStart:  time.Unix(model.StartTime, 0).Format("2006-01-02"),
			ProjectEnd:    time.Unix(model.EndTime, 0).Format("2006-01-02"),
		})*/
		houseMap := map[string]interface{}{
			"user_id": users.ID,
			"pkg_id":  pkg.MatpkgId,
			"shop_id": model.ShopId,
			//"district":        form.District,
			"salesman": model.SalesmanId,
			//"project_manager": form.ProjectManager,
			"project_leader": forms.ProjectLeaderId,
			"address":        address,
			"designer":       model.DesignerId,
			"supervisor":     forms.ManagerId,
			"project_start":  model.StartTime,
			"project_end":    model.EndTime,
			//"user_ids":        db.ToString(form.UserID),
			//"mark": form.Mark,
			"link_name":  users.Name,
			"link_phone": users.Phone,
		}
		db.InsertOne(user.UserHouse.TableName(), houseMap)
	}

	app.Success(c, nil)
}

func FinalMaterialSettleBalancePaymentExport(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "id must be a number", nil)
		return
	}

	var settle final.FinalSettle
	db.GetModel(map[string]interface{}{
		"id": id,
	}, &settle)

	if settle.ID == 0 {
		app.ErrorMsg(c, "结算不存在", nil)
		return
	}

	var site final.FinalSite
	db.GetModel(map[string]interface{}{
		"id": settle.SiteId,
	}, &site)

	if site.ID == 0 {
		app.ErrorMsg(c, "工地不存在", nil)
		return
	}

	var manager models.Admin
	db.GetModel(map[string]interface{}{
		"id": site.ManagerId,
	}, &manager)

	if manager.ID == 0 {
		app.ErrorMsg(c, "项目经理不存在", nil)
		return
	}

	type FinalSiteTableCollects struct {
		final.FinalSiteTableCollect
		Name   string  `json:"name" label:"类别名称" prop:"select:finaltype.name"`
		ShopId int64   `json:"shop_id" label:"门店" type:"int" prop:"select:finalsite.shop_id" search:"="`
		Total  float64 `json:"total" label:"合计" prop:"select:finalsiteitem.total"`
		State  int64   `json:"state" label:"状态" type:"int"`
		Deduct int64   `json:"deduct" type:"int" prop:"select:finaltype.deduct"`
	}

	tables := make([]FinalSiteTableCollects, 0)
	db.GetModel(map[string]interface{}{
		"site_id":    site.ID,
		"deleted_at": 0,
	}, &tables)

	tableMap := make(map[string]float64)
	for _, v := range tables {
		if v.State == -1 {
			continue
		}
		if v.State < 3 {
			app.ErrorMsg(c, "工人结算未完成", nil)
			return
		}
		if v.Deduct == 0 {
			tableMap[v.Name] = utils.FloatAdd(tableMap[v.Name], v.Total, -1)
		}
	}
	logger.Sugar.Infof("tableMap %v", tableMap)

	type FinalMaterialCollects struct {
		final.FinalMaterialMobile
		Budget         float64 `json:"budget" label:"预算" type:"float" prop:"edit" default:"0"`
		State          int64   `json:"state" label:"状态" type:"int" prop:"add:false" default:"0" search:"="`
		Name           string  `json:"name" label:"名称" prop:"select:finalmatauxiliary.name"`
		Total          float64 `json:"total" label:"金额" prop:"select:ROUND(ifnull(sum(order.total),0))"`
		CompletedTotal float64 `json:"completed_total" type:"float" prop:"select:sum(IF((order.state=7)or(order.state=11)or(order.state=12),ROUND(order.total),0))"`
	}

	materials := make([]FinalMaterialCollects, 0)
	db.GetModel(map[string]interface{}{
		"site_id":    site.ID,
		"deleted_at": 0,
	}, &materials)

	materialMap := make(map[string]float64)
	for _, v := range materials {
		if v.Budget != 0 && v.State != 1 {
			app.ErrorMsg(c, "辅材未下单", nil)
			return
		}
		logger.Sugar.Infof("v.Total %v v.CompletedTotal %v", v.Total, v.CompletedTotal)
		if v.Total != v.CompletedTotal {
			app.ErrorMsg(c, "订单未完成", nil)
			return
		}
		materialMap[v.Name] = utils.FloatAdd(materialMap[v.Name], v.Total, -1)
	}

	lines := len(tableMap)
	if len(materialMap) > lines {
		lines = len(materialMap)
	}
	lines++

	export := excelize.NewFile()

	style, err := export.NewStyle(&excelize.Style{
		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},
		},
		Alignment: &excelize.Alignment{
			Horizontal: "center",
			Vertical:   "center",
		},
	})
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}

	worksite := site.Village + "" + site.RoomNo
	if worksite == "" {
		worksite = site.Address
	}

	sheet := export.GetSheetList()[0]
	XlsxSetCellValue(export, sheet, 1, 1, worksite+" "+manager.Username)
	cell1, _ := excelize.CoordinatesToCellName(1, 1)
	cell2, _ := excelize.CoordinatesToCellName(lines, 1)
	if cell1 != cell2 {
		export.MergeCell(sheet, cell1, cell2)
	}

	n := 1
	total := float64(0)
	prices := float64(0)
	for name, price := range tableMap {
		XlsxSetCellValue(export, sheet, n, 2, name)
		XlsxSetCellValue(export, sheet, n, 3, price)
		prices = utils.FloatAdd(prices, price, -1)
		n++
	}
	XlsxSetCellValue(export, sheet, lines, 2, "合计")
	XlsxSetCellValue(export, sheet, lines, 3, prices)
	total = utils.FloatAdd(total, prices, -1)

	n = 1
	prices = float64(0)
	for name, price := range materialMap {
		XlsxSetCellValue(export, sheet, n, 4, name)
		XlsxSetCellValue(export, sheet, n, 5, price)
		prices = utils.FloatAdd(prices, price, -1)
		n++
	}
	//XlsxSetCellValue(export, sheet, n, 4, "合计")
	XlsxSetCellValue(export, sheet, lines, 5, prices)
	total = utils.FloatAdd(total, prices, -1)

	XlsxSetCellValue(export, sheet, 4, 7, "合计")
	XlsxSetCellValue(export, sheet, 5, 7, total)

	cell3, _ := excelize.CoordinatesToCellName(lines, 5)
	export.SetCellStyle(sheet, cell1, cell3, style)

	exportFileName := utils.ToStr(time.Now().UnixNano()) + ".xlsx"
	b, err := export.WriteToBuffer()
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	f, err := os.Create(config.Cfg.App.ExportPath + exportFileName)
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	defer f.Close()
	_, _ = b.WriteTo(f)
	app.Success(c, gin.H{"path": "export/" + exportFileName, "filename": exportFileName})
}

func FinalSettleMaterialCollectExport(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "id must be a number", nil)
		return
	}

	var settle final.FinalSettle
	db.GetModel(map[string]interface{}{
		"id": id,
	}, &settle)

	if settle.ID == 0 {
		app.ErrorMsg(c, "结算不存在", nil)
		return
	}

	var site final.FinalSite
	db.GetModel(map[string]interface{}{
		"id": settle.SiteId,
	}, &site)

	if site.ID == 0 {
		app.ErrorMsg(c, "工地不存在", nil)
		return
	}

	var pkg final.FinalPkg
	db.GetModel(map[string]interface{}{
		"id": site.PkgId,
	}, &pkg)

	if pkg.ID == 0 {
		app.ErrorMsg(c, "套餐不存在", nil)
		return
	}

	var designer models.Admin
	db.GetModel(map[string]interface{}{
		"id": site.DesignerId,
	}, &designer)

	if designer.ID == 0 {
		app.ErrorMsg(c, "设计师不存在", nil)
		return
	}

	var manager models.Admin
	db.GetModel(map[string]interface{}{
		"id": site.ManagerId,
	}, &manager)

	if manager.ID == 0 {
		app.ErrorMsg(c, "项目经理不存在", nil)
		return
	}

	var amount final.FinalSiteAmount
	db.GetModel(map[string]interface{}{
		"site_id": site.ID,
	}, &amount)

	discount := ""
	if amount.ID != 0 {
		from := utils.JsonDecode(db.ToString(amount.Content)).ToMap()
		discounts, _ := db.ToFloat64(from["报价折扣"])
		if discounts != 0 {
			discount = db.ToString(discounts*10) + "折"
		}
	}

	type FinalMaterialOrder struct {
		final.FinalMaterialOrderMobile
		State        int64   `json:"state" label:"状态" type:"int" prop:"add:false" default:"0" search:"="`
		Total        float64 `json:"total" label:"金额" type:"float" prop:"add:false" default:"0"`
		SupplierName string  `json:"supplier_name" type:"string" prop:"select:supplier.name" search:"like"`
	}

	orders := make([]FinalMaterialOrder, 0)
	db.GetModel(map[string]interface{}{
		"site_id":    site.ID,
		"type":       1,
		"deleted_at": 0,
	}, &orders)
	logger.Sugar.Infof("len(orders) %v", len(orders))

	orderMap := make(map[string]float64)
	for _, v := range orders {
		if v.State == -1 {
			continue
		}
		if v.State != 7 && v.State != 11 && v.State != 12 {
			app.ErrorMsg(c, "材料订单未完成", nil)
			return
		}
		orderMap[v.SupplierName] = utils.FloatAdd(orderMap[v.SupplierName], v.Total, -1)
	}

	num := len(orderMap) + 1
	line := int(math.Ceil(float64(num) / 3))

	worksite := site.Village + "" + site.RoomNo
	if worksite == "" {
		worksite = site.Address
	}

	export := excelize.NewFile()

	style, err := export.NewStyle(&excelize.Style{
		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},
		},
		Alignment: &excelize.Alignment{
			Horizontal: "center",
			Vertical:   "center",
		},
	})
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}

	sheet := export.GetSheetList()[0]
	XlsxSetCellValue(export, sheet, 1, 1, "项目名称")
	XlsxSetCellValue(export, sheet, 2, 1, worksite)
	XlsxSetCellValue(export, sheet, 5, 1, "设计师")
	XlsxSetCellValue(export, sheet, 6, 1, designer.Username)
	XlsxSetCellValue(export, sheet, 7, 1, "项目监理")
	XlsxSetCellValue(export, sheet, 8, 1, manager.Username)
	XlsxSetCellValue(export, sheet, 9, 1, "套餐")
	XlsxSetCellValue(export, sheet, 10, 1, pkg.Name)
	XlsxSetCellValue(export, sheet, 11, 1, "折扣")
	XlsxSetCellValue(export, sheet, 12, 1, discount)

	mcell1, _ := excelize.CoordinatesToCellName(2, 1)
	mcell2, _ := excelize.CoordinatesToCellName(4, 1)
	if mcell1 != mcell2 {
		export.MergeCell(sheet, mcell1, mcell2)
	}

	for _, n := range []int{0, 4, 8} {
		XlsxSetCellValue(export, sheet, 1+n, 2, "品名")
		XlsxSetCellValue(export, sheet, 2+n, 2, "品牌")
		XlsxSetCellValue(export, sheet, 3+n, 2, "实际金额")
		XlsxSetCellValue(export, sheet, 4+n, 2, "备注")
	}

	n := 0
	total := float64(0)
	for name, price := range orderMap {
		col := int(math.Floor(float64(n) / float64(line)))
		row := n - col*line
		col = col * 4
		XlsxSetCellValue(export, sheet, 2+col, 3+row, name)
		XlsxSetCellValue(export, sheet, 3+col, 3+row, price)
		total = utils.FloatAdd(total, price, -1)
		n++
	}

	XlsxSetCellValue(export, sheet, 10, line+2, "合计")
	XlsxSetCellValue(export, sheet, 11, line+2, total)

	cell1, _ := excelize.CoordinatesToCellName(1, 1)
	cell2, _ := excelize.CoordinatesToCellName(12, line+2)
	export.SetCellStyle(sheet, cell1, cell2, style)

	exportFileName := utils.ToStr(time.Now().UnixNano()) + ".xlsx"
	b, err := export.WriteToBuffer()
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	f, err := os.Create(config.Cfg.App.ExportPath + exportFileName)
	if err != nil {
		app.ErrorMsg(c, "导出失败", nil)
		return
	}
	defer f.Close()
	_, _ = b.WriteTo(f)
	app.Success(c, gin.H{"path": "export/" + exportFileName, "filename": exportFileName})
}

func XlsxSetCellValue(file *excelize.File, sheet string, col int, row int, value interface{}) error {
	cell, err := excelize.CoordinatesToCellName(col, row)
	if err != nil {
		return err
	}
	err = file.SetCellValue(sheet, cell, value)
	if err != nil {
		return err
	}

	return nil
}