package final

import (
	"errors"
	"fmt"
	"time"
	"zhiyuan/models"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/admin"

	"github.com/gin-gonic/gin"
)

type FinalMaterialOrderProcess struct {
	ID           int64  `json:"id" prop:"add:false"`
	OrderId      int64  `json:"order_id" label:"订单ID" type:"int" prop:"add" search:"="`
	Type         int64  `json:"type" label:"类型" type:"int" prop:"add" default:"0"`
	ChangeTypeId int64  `json:"change_type_id" label:"类型" type:"int" default:"0"`
	Explain      string `json:"explain" label:"说明" type:"string" search:"like"`
	Pictures     string `json:"pictures" label:"图片" type:"string" search:"like"`
	Signature    string `json:"signature" label:"签名" type:"string"`
	CreatedId    int64  `json:"created_id" label:"创建人员" type:"int" prop:"add:false" search:"="`
	Check        int64  `json:"check" label:"审核状态" type:"int" prop:"add:false"`
	CheckMark    string `json:"checkmark" label:"审核留言" type:"string" prop:"add:false"`
	CheckId      int64  `json:"check_id" label:"审核人员" type:"int" prop:"add:false"`
	CheckAt      int64  `json:"check_at" label:"审核时间" type:"int" prop:"add:false"`
	Check2       int64  `json:"check2" label:"审核状态" type:"int" prop:"add:false"`
	CheckMark2   string `json:"checkmark2" label:"审核留言" type:"string" prop:"add:false"`
	CheckId2     int64  `json:"check_id2" label:"审核人员" type:"int" prop:"add:false"`
	CheckAt2     int64  `json:"check_at2" label:"审核时间" type:"int" prop:"add:false"`
	Check3       int64  `json:"check3" label:"审核状态" type:"int" prop:"add:false"`
	CheckMark3   string `json:"checkmark3" label:"审核留言" type:"string" prop:"add:false"`
	CheckId3     int64  `json:"check_id3" label:"审核人员" type:"int" prop:"add:false"`
	CheckAt3     int64  `json:"check_at3" label:"审核时间" type:"int" prop:"add:false"`
	DeletedAt    int64  `json:"deleted_at" prop:"add:false select:false"`
	CreatedAt    int64  `json:"created_at" prop:"add:false"`
	UpdatedAt    int64  `json:"updated_at" prop:"add:false"`
	db.BaseModel
}

func (FinalMaterialOrderProcess) TableName() string {
	return "zy_final_material_order_process"
}

func (model FinalMaterialOrderProcess) ListPrivilege(c *gin.Context, data map[string]interface{}, s *db.Select) bool {
	order_id, _ := db.ToInt64(data["order_id"])
	s.Where = append(s.Where, fmt.Sprintf("`%s`.`order_id` = %s", model.TableName(), s.Param(order_id)))
	return true
}

func (FinalMaterialOrderProcess) OnePrivilege(c *gin.Context, id int64) bool {
	return true
}

func (FinalMaterialOrderProcess) AddPrivilege(c *gin.Context, data map[string]interface{}, post map[string]interface{}) error {
	data["created_id"] = c.GetInt("adminID")
	typ, _ := db.ToInt64(data["type"])
	orderId, _ := db.ToInt64(data["order_id"])
	receipt_date, _ := db.ToInt64(post["receipt_date"])
	install_date, _ := db.ToInt64(post["install_date"])
	pictures := db.ToString(post["pictures"])
	signature := db.ToString(post["signature"])

	var model FinalMaterialOrder
	db.GetModel(map[string]interface{}{
		"id":         orderId,
		"deleted_at": 0,
	}, &model)
	if model.ID == 0 {
		return errors.New("没有权限")
	}

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

	var site FinalSite
	db.GetModel(map[string]interface{}{
		"id":         model.SiteId,
		"deleted_at": 0,
	}, &site)
	if site.ID == 0 {
		return errors.New("没有权限")
	}

	datas := map[string]interface{}{}

	if typ > 0 && typ < 5 {
		if model.ProcessId != 0 || model.State != typ-1 {
			return errors.New("没有权限")
		}

		datas["state"] = typ

		if typ == 1 || typ == 3 {
			if int64(c.GetInt("adminID")) != supplier.AdminId {
				return errors.New("没有权限")
			}
			if typ == 1 {
				datas["stock_time"] = time.Now().Unix()
			} else {
				if pictures == "" {
					return errors.New("请上传出库单和现场照片")
				}
				datas["deliver_time"] = time.Now().Unix()
			}
		} else {

			if int64(c.GetInt("adminID")) != site.ManagerId {
				return errors.New("没有权限")
			}

			if typ == 2 {
				if receipt_date == 0 {
					return errors.New("请选择配送时间")
				}
				datas["notice_time"] = time.Now().Unix()
				datas["receipt_date"] = receipt_date
			} else {
				if signature == "" {
					return errors.New("请签名")
				}
				/*if pictures == "" {
					return errors.New("请上传质量监督本或确认截图")
				}*/
				if model.Type == 0 || supplier.Reduce == 1 {
					datas["state"] = 7
				} else if supplier.Install == 0 {
					datas["state"] = typ + 2
				}
				datas["accept_time"] = time.Now().Unix()
			}
		}

	} else if typ == 5 {
	} else if typ == 6 {
		if int64(c.GetInt("adminID")) != model.CreatedId {
			return errors.New("没有权限")
		}
		if model.ProcessId != 0 || model.State == 7 || model.State < 0 {
			return errors.New("没有权限")
		}
	} else if typ == 7 {
		if int64(c.GetInt("adminID")) != supplier.AdminId && int64(c.GetInt("adminID")) != site.ManagerId && !admin.CheckAuth([]string{"final:verify:audit"}, c.GetInt("adminID")) {
			return errors.New("没有权限")
		}
		if (model.ProcessId != 0 || model.State > 5 || model.State < 0) && !admin.CheckAuth([]string{"final:verify:audit"}, c.GetInt("adminID")) {
			return errors.New("没有权限")
		}
		if model.SettleId != 0 {
			return errors.New("没有权限")
		}

		carts := make([]FinalMaterialCart, 0)
		db.GetModel(map[string]interface{}{
			"admin_id":   c.GetInt("adminID"),
			"process_id": 0,
			"deleted_at": 0,
		}, &carts)

		if len(carts) == 0 {
			return errors.New("没有权限")
		}

	} else if typ == 8 {
		if int64(c.GetInt("adminID")) != site.ManagerId {
			return errors.New("没有权限")
		}
		if model.ProcessId != 0 || model.State != 4 {
			return errors.New("没有权限")
		}
		if install_date == 0 {
			return errors.New("请选择配送时间")
		}
		datas["install_date"] = install_date
		datas["state"] = 5
	} else if typ == 9 {
		if int64(c.GetInt("adminID")) != supplier.AdminId {
			return errors.New("没有权限")
		}
		if model.ProcessId != 0 || model.State != 5 {
			return errors.New("没有权限")
		}
		if pictures == "" {
			return errors.New("请上传现场照片")
		}
		datas["install_time"] = time.Now().Unix()
		datas["state"] = 6
	} else if typ == 10 {
		if int64(c.GetInt("adminID")) != site.ManagerId {
			return errors.New("没有权限")
		}
		if model.ProcessId != 0 || model.State != 6 {
			return errors.New("没有权限")
		}
		if signature == "" {
			return errors.New("请签名")
		}
		if pictures == "" {
			return errors.New("请上传质量监督本或确认截图")
		}
		datas["state"] = 7
		datas["over_time"] = time.Now().Unix()
	} else if typ == 11 {
		if int64(c.GetInt("adminID")) != site.ManagerId {
			return errors.New("没有权限")
		}
		if model.ProcessId != 0 || model.State != 8 {
			return errors.New("没有权限")
		}
		datas["notice_measure_time"] = time.Now().Unix()
		datas["state"] = 9
	} else if typ == 12 {
		if int64(c.GetInt("adminID")) != supplier.AdminId {
			return errors.New("没有权限")
		}
		if model.ProcessId != 0 || model.State != 9 {
			return errors.New("没有权限")
		}

		carts := make([]FinalMaterialCart, 0)
		db.GetModel(map[string]interface{}{
			"admin_id":   c.GetInt("adminID"),
			"process_id": 0,
			"deleted_at": 0,
		}, &carts)

		if len(carts) == 0 {
			return errors.New("没有权限")
		}
		if model.MeasureTime == 0 {
			datas["measure_time"] = time.Now().Unix()
		}
		datas["state"] = 10
	} else if typ == 14 {
		if int64(c.GetInt("adminID")) != supplier.AdminId {
			return errors.New("没有权限")
		}
		if model.ProcessId != 0 || model.State != 9 {
			return errors.New("没有权限")
		}

	} else {
		return errors.New("没有权限")
	}

	if len(datas) != 0 {
		err := db.UpdateModel(db.Type(model), orderId, datas)

		if err != nil {
			return errors.New("没有权限")
		}
	}

	return nil
}

func (FinalMaterialOrderProcess) AddAfter(c *gin.Context, id int64, post map[string]interface{}, data map[string]interface{}) {
	typ, _ := db.ToInt64(data["type"])
	orderId, _ := db.ToInt64(data["order_id"])

	datas := map[string]interface{}{}

	var order FinalMaterialOrder
	db.GetModel(map[string]interface{}{
		"id":         orderId,
		"deleted_at": 0,
	}, &order)

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

	var process FinalMaterialOrderProcess
	db.GetModel(map[string]interface{}{
		"id":         id,
		"deleted_at": 0,
	}, &process)

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

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

	name := ""
	adminInfo, _ := admin.GetInfoByID(int(process.CreatedId), nil, nil)
	if adminInfo != nil {
		name = adminInfo.Username
	}

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

	if typ == 1 {
		SendMaterialMessage(int(order.CreatedId), order.OrderNo, order.ID, address, name+"已备货")
		if site.ID != 0 && site.ManagerId != order.CreatedId {
			SendMaterialMessage(int(site.ManagerId), order.OrderNo, order.ID, address, name+"已备货")
		}
	} else if typ == 2 {
		if site.ID != 0 {
			SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"已通知配送，请按时安排配送")
		}
	} else if typ == 3 {
		if site.ID != 0 {
			SendMaterialMessage(int(site.ManagerId), order.OrderNo, order.ID, address, name+"已确认货物送达，请及时验收")
		}
	} else if typ == 4 {
		if site.ID != 0 {
			SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"已确认收货")
		}
	} else if typ == 5 {
		if process.CreatedId != site.ManagerId {
			SendMaterialMessage(int(site.ManagerId), order.OrderNo, order.ID, address, name+"在订单留言了")
		}
		if process.CreatedId != supplier.AdminId {
			SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"在订单留言了")
		}
		if process.CreatedId != order.CreatedId && order.CreatedId != site.ManagerId {
			SendMaterialMessage(int(order.CreatedId), order.OrderNo, order.ID, address, name+"在订单留言了")
		}
	} else if typ == 6 {
		if order.State < 2 && order.IsCustom == 0 || (order.State == 8 || order.State == 9) && order.IsCustom == 1 {
			datas["state"] = -1
			db.UpdateModel(db.Type(FinalMaterialOrder{}), orderId, datas)
			if process.CreatedId != site.ManagerId {
				SendMaterialMessage(int(site.ManagerId), order.OrderNo, order.ID, address, name+"已取消订单")
			}
			if process.CreatedId != supplier.AdminId {
				SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"已取消订单")
			}
			if process.CreatedId != order.CreatedId && order.CreatedId != site.ManagerId {
				SendMaterialMessage(int(order.CreatedId), order.OrderNo, order.ID, address, name+"已取消订单")
			}
		} else {
			datas["process_id"] = id
			db.UpdateModel(db.Type(FinalMaterialOrder{}), orderId, datas)
			/*if process.CreatedId == supplier.AdminId {
				SendMaterialMessage(int(order.CreatedId), order.OrderNo, order.ID, address, name+"取消订单，请确认")
			} else {
				SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"取消订单，请确认")
			}*/
			SendMaterialMessage(int(site.ManagerId), order.OrderNo, order.ID, address, name+"取消订单，请确认")
			SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"取消订单，请确认")

			/*if manager.AuditId != 0 {
				SendMaterialMessage(int(manager.AuditId), order.OrderNo, order.ID, address, name+"取消订单，请确认")
			} else {
				roleId := 24
				where := map[string]string{
					"where":     "id>1 AND deleted_at=0 AND state=1",
					"_order_by": "id desc",
				}
				param := make(map[string]interface{})
				where["where"] = where["where"] + " AND FIND_IN_SET({{role_id}}, role_ids)"
				param["role_id"] = roleId
				where["where"] = where["where"] + " AND FIND_IN_SET({{shop_id}}, shop_ids)"
				param["shop_id"] = site.ShopId
				type AdminList struct {
					ID int `json:"id"`
				}
				adminList := make([]AdminList, 0)
				_, err := admin.GetAdminsRaw(where, param, &adminList)
				if err == nil {
					for _, v := range adminList {
						SendMaterialMessage(int(v.ID), order.OrderNo, order.ID, address, name+"取消订单，请确认")
					}
				}
			}*/
		}
	} else if typ == 7 {
		db.BuildUpdate(FinalMaterialCart{}.TableName(), map[string]interface{}{
			"admin_id":   c.GetInt("adminID"),
			"process_id": 0,
			"deleted_at": 0,
		}, map[string]interface{}{
			"process_id": id,
		}, FinalMaterialCart{}.DB())

		if modifyOrderCheck(orderId, id) {
			carts := make([]FinalMaterialCart, 0)
			db.GetModel(map[string]interface{}{
				"process_id": process.ID,
				"deleted_at": 0,
			}, &carts)

			_, err := db.BuildUpdate(FinalMaterialOrderItem{}.TableName(), map[string]interface{}{
				"order_id":   order.ID,
				"deleted_at": 0,
			}, map[string]interface{}{
				"deleted_at": time.Now().Unix(),
			}, FinalMaterialOrderItem{}.DB())
			if err != nil {
				return
			}

			total := float64(0)
			for _, v := range carts {
				_, err := db.InsertModel(db.Type(FinalMaterialOrderItem{}), map[string]interface{}{
					"order_id": order.ID,
					"mat_id":   v.MatId,
					"price":    v.Price,
					"num":      v.Num,
					"total":    v.Total,
					"remark":   v.Remark,
				})
				if err != nil {
					return
				}
				total = utils.FloatAdd(total, v.Total, 2)

			}
			datas["total"] = total
			datas["process_id"] = 0
			db.UpdateModel(db.Type(FinalMaterialOrder{}), orderId, datas)
			SendMaterialMessage(int(process.CreatedId), order.OrderNo, order.ID, address, "订单已修改")
		} else {
			if admin.CheckAuth([]string{"final:verify:audit"}, c.GetInt("adminID")) || modifyOrderCheck1(orderId, id) {
				db.UpdateModel(db.Type(FinalMaterialOrderProcess{}), id, map[string]interface{}{
					"check_at": time.Now().Unix(),
				})
			} else {
				if manager.AuditId != 0 {
					SendMaterialMessage(int(manager.AuditId), order.OrderNo, order.ID, address, name+"修改订单，请确认")
				} else {
					roleId := 24
					where := map[string]string{
						"where":     "id>1 AND deleted_at=0 AND state=1",
						"_order_by": "id desc",
					}
					param := make(map[string]interface{})
					where["where"] = where["where"] + " AND FIND_IN_SET({{role_id}}, role_ids)"
					param["role_id"] = roleId
					where["where"] = where["where"] + " AND FIND_IN_SET({{shop_id}}, shop_ids)"
					param["shop_id"] = site.ShopId
					type AdminList struct {
						ID int `json:"id"`
					}
					adminList := make([]AdminList, 0)
					_, err := admin.GetAdminsRaw(where, param, &adminList)
					if err == nil {
						for _, v := range adminList {
							SendMaterialMessage(int(v.ID), order.OrderNo, order.ID, address, name+"修改订单，请确认")
						}
					}
				}
			}

			datas["process_id"] = id
			db.UpdateModel(db.Type(FinalMaterialOrder{}), orderId, datas)

			SendMaterialMessage(int(order.CreatedId), order.OrderNo, order.ID, address, name+"修改订单，请确认")
		}
	} else if typ == 8 {
		if site.ID != 0 {
			SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"已通知安装，请及时安排")
		}
	} else if typ == 9 {
		if site.ID != 0 {
			SendMaterialMessage(int(site.ManagerId), order.OrderNo, order.ID, address, name+"已确认安装，请及时验收")
		}
	} else if typ == 10 {
		if site.ID != 0 {
			SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"已确认验收")
			SendMaterialMessage(int(site.ProjectLeaderId), order.OrderNo, order.ID, address, "订单已完成，请及时审核")
		}
	} else if typ == 11 {
		if site.ID != 0 {
			SendMaterialMessage(int(supplier.AdminId), order.OrderNo, order.ID, address, name+"已通知测量，请及时安排")
		}
	} else if typ == 12 {
		db.BuildUpdate(FinalMaterialCart{}.TableName(), map[string]interface{}{
			"admin_id":   c.GetInt("adminID"),
			"process_id": 0,
			"deleted_at": 0,
		}, map[string]interface{}{
			"process_id": id,
		}, FinalMaterialCart{}.DB())

		if modifyOrderCheck(orderId, id) {
			carts := make([]FinalMaterialCart, 0)
			db.GetModel(map[string]interface{}{
				"process_id": process.ID,
				"deleted_at": 0,
			}, &carts)

			_, err := db.BuildUpdate(FinalMaterialOrderItem{}.TableName(), map[string]interface{}{
				"order_id":   order.ID,
				"deleted_at": 0,
			}, map[string]interface{}{
				"deleted_at": time.Now().Unix(),
			}, FinalMaterialOrderItem{}.DB())
			if err != nil {
				return
			}

			total := float64(0)
			for _, v := range carts {
				_, err := db.InsertModel(db.Type(FinalMaterialOrderItem{}), map[string]interface{}{
					"order_id": order.ID,
					"mat_id":   v.MatId,
					"price":    v.Price,
					"num":      v.Num,
					"total":    v.Total,
					"remark":   v.Remark,
				})
				if err != nil {
					return
				}
				total = utils.FloatAdd(total, v.Total, 2)

			}
			datas["total"] = total
			datas["state"] = 0
			datas["take_time"] = time.Now().Unix()
			datas["process_id"] = 0
			db.UpdateModel(db.Type(FinalMaterialOrder{}), orderId, datas)
			SendMaterialMessage(int(process.CreatedId), order.OrderNo, order.ID, address, "测量订单修改已通过审核，请及时安排备货")
		} else {
			if admin.CheckAuth([]string{"final:verify:audit"}, c.GetInt("adminID")) || modifyOrderCheck1(orderId, id) {
				db.UpdateModel(db.Type(FinalMaterialOrderProcess{}), id, map[string]interface{}{
					"check_at": time.Now().Unix(),
				})
			} else {
				if manager.AuditId != 0 {
					SendMaterialMessage(int(manager.AuditId), order.OrderNo, order.ID, address, name+"修改测量订单，请确认")
				} else {
					roleId := 24
					where := map[string]string{
						"where":     "id>1 AND deleted_at=0 AND state=1",
						"_order_by": "id desc",
					}
					param := make(map[string]interface{})
					where["where"] = where["where"] + " AND FIND_IN_SET({{role_id}}, role_ids)"
					param["role_id"] = roleId
					where["where"] = where["where"] + " AND FIND_IN_SET({{shop_id}}, shop_ids)"
					param["shop_id"] = site.ShopId
					type AdminList struct {
						ID int `json:"id"`
					}
					adminList := make([]AdminList, 0)
					_, err := admin.GetAdminsRaw(where, param, &adminList)
					if err == nil {
						for _, v := range adminList {
							SendMaterialMessage(int(v.ID), order.OrderNo, order.ID, address, name+"修改测量订单，请确认")
						}
					}
				}
			}

			datas["process_id"] = id
			db.UpdateModel(db.Type(FinalMaterialOrder{}), orderId, datas)

			SendMaterialMessage(int(order.CreatedId), order.OrderNo, order.ID, address, name+"修改测量订单，请确认")
		}
	} else if typ == 14 {
		datas["process_id"] = id
		db.UpdateModel(db.Type(FinalMaterialOrder{}), orderId, datas)
		if site.ID != 0 {
			SendMaterialMessage(int(site.ManagerId), order.OrderNo, order.ID, address, name+"报备不具备测量条件，请审核")
		}

	}

}

func (FinalMaterialOrderProcess) EditPrivilege(c *gin.Context, id int64, data map[string]interface{}, post map[string]interface{}) error {
	return errors.New("没有权限")
}

func (FinalMaterialOrderProcess) DelPrivilege(c *gin.Context, id int64) error {
	return errors.New("没有权限")
}

func (FinalMaterialOrderProcess) Page() bool {
	return false
}

type FinalMaterialOrderProcessMobile struct {
	CreatedName       string `json:"created_name" prop:"add:false select:created.username"`
	CreatedPhone      string `json:"created_phone" prop:"add:false select:created.phone"`
	CreatedHeadimgurl string `json:"created_headimgurl" prop:"add:false select:created.headimgurl"`
	CheckName         string `json:"check_name" prop:"add:false select:check.username"`
	CheckPhone        string `json:"check_phone" prop:"add:false select:check.phone"`
	CheckHeadimgurl   string `json:"check_headimgurl" prop:"add:false select:check.headimgurl"`
	CheckName2        string `json:"check_name2" prop:"add:false select:check2.username"`
	CheckPhone2       string `json:"check_phone2" prop:"add:false select:check2.phone"`
	CheckHeadimgurl2  string `json:"check_headimgurl2" prop:"add:false select:check2.headimgurl"`
	CheckName3        string `json:"check_name3" prop:"add:false select:check3.username"`
	CheckPhone3       string `json:"check_phone3" prop:"add:false select:check3.phone"`
	CheckHeadimgurl3  string `json:"check_headimgurl3" prop:"add:false select:check3.headimgurl"`
	FinalMaterialOrderProcess
}

func (model FinalMaterialOrderProcessMobile) GroupBy() string {
	return fmt.Sprintf("`%s`.`id`", model.TableName())
}

func (model FinalMaterialOrderProcessMobile) OrderBy() string {
	return fmt.Sprintf("`%s`.`created_at` desc", model.TableName())
}

func (model FinalMaterialOrderProcessMobile) LeftJoin(data map[string]interface{}, s *db.Select) []db.JoinModel {
	return []db.JoinModel{
		{
			Model: JoinAdmin{},
			As:    "created",
			On:    []string{"`created`.`id` = " + model.TableName() + ".`created_id`"},
		},
		{
			Model: JoinAdmin{},
			As:    "check",
			On:    []string{"`check`.`id` = " + model.TableName() + ".`check_id`"},
		},
		{
			Model: JoinAdmin{},
			As:    "check2",
			On:    []string{"`check2`.`id` = " + model.TableName() + ".`check_id2`"},
		},
		{
			Model: JoinAdmin{},
			As:    "check3",
			On:    []string{"`check3`.`id` = " + model.TableName() + ".`check_id3`"},
		},
	}
}

func (model FinalMaterialOrderProcessMobile) ListAfter(c *gin.Context, data map[string]interface{}, list []map[string]interface{}) []map[string]interface{} {
	ids := make([]int64, 0)
	idmap := make(map[int64]int)
	for i, v := range list {
		id, _ := db.ToInt64(v["id"])
		ids = append(ids, id)
		idmap[id] = i
	}
	datas, _ := db.GetModelMap(db.Type(FinalMaterialCartMobile{}), map[string]interface{}{
		fmt.Sprintf("`%s`.`process_id` in", FinalMaterialCartMobile{}.TableName()): ids,
		fmt.Sprintf("`%s`.`deleted_at`", FinalMaterialCartMobile{}.TableName()):    0,
	}, nil)
	for _, v := range datas {
		id, _ := db.ToInt64(v["process_id"])
		if n, ok := idmap[id]; ok {
			carts := make([]map[string]interface{}, 0)
			if is, ok := list[n]["carts"].([]map[string]interface{}); ok {
				carts = is
			}
			carts = append(carts, v)
			list[n]["carts"] = carts
		}
	}
	return list
}

func modifyOrderCheck(orderId int64, processId int64) bool {
	carts := make([]FinalMaterialCart, 0)
	db.GetModel(map[string]interface{}{
		"process_id": processId,
		"deleted_at": 0,
	}, &carts)

	items := make([]FinalMaterialOrderItem, 0)
	db.GetModel(map[string]interface{}{
		"order_id":   orderId,
		"deleted_at": 0,
	}, &items)

	for _, cart := range carts {
		find := false
		for _, item := range items {
			if item.MatId == cart.MatId && item.ItemId == cart.ItemId && item.Price == cart.Price {
				//if cart.Num > item.Num {
				if cart.Num != item.Num {
					return false
				}
				find = true
			}
		}
		if !find {
			return false
		}
	}

	return true
}

func modifyOrderCheck1(orderId int64, processId int64) bool {
	carts := make([]FinalMaterialCart, 0)
	db.GetModel(map[string]interface{}{
		"process_id": processId,
		"deleted_at": 0,
	}, &carts)

	items := make([]FinalMaterialOrderItem, 0)
	db.GetModel(map[string]interface{}{
		"order_id":   orderId,
		"deleted_at": 0,
	}, &items)

	for _, cart := range carts {
		find := false
		for _, item := range items {
			if item.MatId == cart.MatId && item.ItemId == cart.ItemId && item.Price == cart.Price {
				if cart.Num > item.Num {
					return false
				}
				find = true
			}
		}
		if !find {
			return false
		}
	}

	return true
}