enterprise/src/gongyinglian/order.go

package gongyinglian

import (
	"math"

	"shylinux.com/x/ice"
	"shylinux.com/x/icebergs/base/aaa"
	"shylinux.com/x/icebergs/base/ctx"
	kit "shylinux.com/x/toolkits"

	"shylinux.com/x/enterprise/src/gongyinglian/model"
)

type Order struct {
	Table
	userStore       userStore
	store           store
	product         Product
	orderDetail     orderDetail
	models          string `data:"order"`
	sell            string `name:"sell name info" help:"出货" role:"boss,worker"`
	produce         string `name:"produce name info" help:"加工" role:"boss,worker"`
	purchase        string `name:"purchase name info" help:"进货" role:"boss,worker"`
	insert          string `name:"insert product_uid*:select count*" role:"boss,worker"`
	update          string `name:"update count* price*" role:"boss,worker"`
	delete          string `name:"delete" role:"boss,worker"`
	cancel          string `name:"cancel" role:"boss,worker"`
	submit          string `name:"submit" role:"boss,worker"`
	confirmSell     string `name:"confirmSell from_store_uid" role:"void"`
	confirmProduce  string `name:"confirmProduce" role:"void"`
	confirmPurchase string `name:"confirmPurchase to_store_uid" role:"void"`
	again           string `name:"again" role:"void"`
	process         string `name:"process" role:"void"`
	payment         string `name:"payment company_uid* open_id*" role:"void"`
	express         string `name:"express company_uid* open_id*" role:"void"`
	refund          string `name:"refund company_uid* open_id*" role:"void"`
	// return          string `name:"return company_uid* open_id*" role:"void"`
	confirmPayment string `name:"confirmPayment" role:"void"`
	confirmExpress string `name:"confirmExpress" role:"void"`
	confirmReturn  string `name:"confirmReturn" role:"void"`
	confirmRefund  string `name:"confirmRefund" role:"void"`
}

func (s Order) Init(m *ice.Message, arg ...string) {
	aaa.White(m.Message, kit.Keys(m.PrefixKey(), ctx.ACTION, s.Return))
	m.Design(s.Return, "", "company_uid* open_id*")
	s.Table.Init(m, arg...)
}
func (s Order) Sell(m *ice.Message, arg ...string) {
	s.Table.Insert(m, kit.Simple(arg, model.FROM_STORE_UID, m.Option(model.STORE_UID), model.FROM_USER_UID, m.Option(model.USER_UID))...)
	m.ProcessRewrite(model.UID, m.Result())
}
func (s Order) Produce(m *ice.Message, arg ...string) {
	s.Table.Insert(m, kit.Simple(arg,
		model.FROM_STORE_UID, m.Option(model.STORE_UID), model.FROM_USER_UID, m.Option(model.USER_UID),
		model.TO_STORE_UID, m.Option(model.STORE_UID), model.TO_USER_UID, m.Option(model.USER_UID),
	)...)
	m.ProcessRewrite(model.UID, m.Result())
}
func (s Order) Purchase(m *ice.Message, arg ...string) {
	s.Table.Insert(m, kit.Simple(arg, model.TO_STORE_UID, m.Option(model.STORE_UID), model.TO_USER_UID, m.Option(model.USER_UID))...)
	m.ProcessRewrite(model.UID, m.Result())
}
func (s Order) List(m *ice.Message, arg ...string) {
	m.Display("")
	if len(arg) == 1 {
		if !s.IsBoss(m) && !s.IsWorker(m) {
			return
		}
		switch OrderType(kit.Int(m.Option(model.ORDER_TYPE))) {
		case OrderSell:
			s.Select(m, "from_store_uid = ? AND (to_store_uid IS NULL OR to_store_uid != ?)", arg[0], arg[0])
			defer func() { kit.If(m.Length() == 0, func() { m.EchoInfoButton("", s.Sell) }) }()
		case OrderProduce:
			s.Select(m, "from_store_uid = ? AND to_store_uid = ?", arg[0], arg[0])
			defer func() { kit.If(m.Length() == 0, func() { m.EchoInfoButton("", s.Produce) }) }()
		case OrderPurchase:
			s.Select(m, "(from_store_uid IS NULL OR from_store_uid != ?) AND to_store_uid = ?", arg[0], arg[0])
			defer func() { kit.If(m.Length() == 0, func() { m.EchoInfoButton("", s.Purchase) }) }()
		default:
			s.Select(m, "from_store_uid = ? OR to_store_uid = ?", arg[0], arg[0])
		}
		m.Table(func(value ice.Maps) {
			if value[model.FROM_STORE_UID] == arg[0] && value[model.TO_STORE_UID] == arg[0] {
				m.Push(model.USER_UID, value[model.TO_USER_UID])
				m.Push(model.ORDER_TYPE, OrderProduce)
			} else if value[model.FROM_STORE_UID] == arg[0] {
				m.Push(model.USER_UID, value[model.TO_USER_UID])
				m.Push(model.ORDER_TYPE, OrderSell)
			} else {
				m.Push(model.USER_UID, value[model.FROM_USER_UID])
				m.Push(model.ORDER_TYPE, OrderPurchase)
			}
		})
		m.RewriteAppend(func(value, key string, index int) string {
			if key == model.STATUS {
				switch OrderStatus(kit.Int(value)) {
				case OrderConfirm:
					if PaymentStatus(kit.Int(m.Appendv(model.PAYMENT_STATUS)[index])) == PaymentUnknown {
						if OrderType(kit.Int(m.Appendv(model.ORDER_TYPE)[index])) == OrderPurchase {
							value = kit.Format(OrderPayment)
						}
					} else if ExpressStatus(kit.Int(m.Appendv(model.EXPRESS_STATUS)[index])) == ExpressUnknown {
						if OrderType(kit.Int(m.Appendv(model.ORDER_TYPE)[index])) == OrderSell {
							value = kit.Format(OrderExpress)
						}
					}
				case OrderDeal:
					if ReturnStatus(kit.Int(m.Appendv(model.RETURN_STATUS)[index])) != ReturnUnknown {
						if RefundStatus(kit.Int(m.Appendv(model.REFUND_STATUS)[index])) == RefundUnknown {
							if OrderType(kit.Int(m.Appendv(model.ORDER_TYPE)[index])) == OrderSell {
								value = kit.Format(OrderRefund)
							} else {
								value = kit.Format(OrderConfirm)
							}
						} else {
							value = kit.Format(OrderDone)
						}
					}
				}
			}
			return value
		}).RenameAppend(model.STATUS, model.ORDER_STATUS).Action().Display("")
		s.SelectJoinUser(m)
	} else if len(arg) == 2 {
		user_uid := m.Option(model.USER_UID)
		if m.Cmdy(s.orderDetail, arg); m.Length() == 0 {
			kit.If(!m.IsErr(), func() { m.EchoInfoButton(m.Trans("please insert product", "请添加产品"), s.Insert) })
			return
		}
		m.RenameAppend(model.UID, model.ORDER_DETAIL_UID).Action()
		msg := s.Select(m.Spawn(), "(from_store_uid = ? OR to_store_uid = ?) AND uid = ?", arg[0], arg[0], arg[1])
		status := OrderStatus(kit.Int(msg.Append(model.STATUS)))
		kit.If(status != OrderCreate, func() { m.PushAction().Action() })
		switch status {
		case OrderCreate:
			if user_uid == msg.Append(model.FROM_USER_UID) || user_uid == msg.Append(model.TO_USER_UID) {
				m.PushAction(s.Update, s.Delete).Action(s.Insert).EchoButton(s.Cancel, s.Submit)
			}
		case OrderSubmit:
			if user_uid == msg.Append(model.FROM_USER_UID) && msg.Append(model.TO_USER_UID) == "" {
				m.Echo("请让买家扫码确认订单")
				m.EchoQRCode(s.Link(m, arg[0], m.PrefixKey(), arg[1]))
			} else if user_uid == msg.Append(model.TO_USER_UID) && msg.Append(model.FROM_USER_UID) == "" {
				m.Echo("请让卖家扫码确认订单")
				m.EchoQRCode(s.Link(m, arg[0], m.PrefixKey(), arg[1]))
			} else if msg.Append(model.FROM_USER_UID) == "" {
				m.EchoButton(s.ConfirmSell)
			} else if msg.Append(model.TO_USER_UID) == "" {
				m.EchoButton(s.ConfirmPurchase)
			} else if msg.Append(model.FROM_USER_UID) == msg.Append(model.TO_USER_UID) {
				m.EchoButton(s.ConfirmProduce)
			}
		case OrderConfirm:
			if msg.Append(model.FROM_USER_UID) == msg.Append(model.TO_USER_UID) {
				m.EchoButton(s.Process)
			} else if user_uid == msg.Append(model.TO_USER_UID) {
				if PaymentStatus(kit.Int(msg.Append(model.PAYMENT_STATUS))) == PaymentUnknown {
					m.EchoButton(s.Payment)
				}
				if ExpressStatus(kit.Int(msg.Append(model.EXPRESS_STATUS))) == ExpressRecv {
					m.EchoButton(s.ConfirmExpress)
				}
			} else if user_uid == msg.Append(model.FROM_USER_UID) {
				if PaymentStatus(kit.Int(msg.Append(model.PAYMENT_STATUS))) == PaymentSuccess {
					m.EchoButton(s.ConfirmPayment)
				}
				if PaymentStatus(kit.Int(msg.Append(model.PAYMENT_STATUS))) == PaymentConfirm {
					if ExpressStatus(kit.Int(msg.Append(model.EXPRESS_STATUS))) == ExpressUnknown {
						m.EchoButton(s.Express)
					}
				}
			}
		case OrderDeal:
			s.DoneMessage(m)
			if user_uid == msg.Append(model.TO_USER_UID) {
				if ReturnStatus(kit.Int(msg.Append(model.RETURN_STATUS))) == ReturnUnknown {
					m.EchoButton(s.Again, s.Return)
				}
				if RefundStatus(kit.Int(msg.Append(model.REFUND_STATUS))) == RefundSuccess {
					m.EchoButton(s.ConfirmRefund)
				}
			} else if user_uid == msg.Append(model.FROM_USER_UID) {
				if ReturnStatus(kit.Int(msg.Append(model.RETURN_STATUS))) == ReturnUnknown {
					m.EchoButton(s.Again)
				} else if ReturnStatus(kit.Int(msg.Append(model.RETURN_STATUS))) == ReturnRecv {
					m.EchoButton(s.ConfirmReturn)
				} else if ReturnStatus(kit.Int(msg.Append(model.RETURN_STATUS))) == ReturnConfirm {
					if RefundStatus(kit.Int(msg.Append(model.REFUND_STATUS))) == RefundUnknown {
						m.EchoButton(s.Refund)
					}
				}
			}
		}
	}
}
func (s Order) Amount(m *ice.Message, arg ...string) {
	msg := m.Cmd(s.orderDetail, s.orderDetail.Amount, m.Option(model.UID))
	s.Table.Update(m, kit.Dict(msg.AppendSimple(model.AMOUNT, model.TOTAL)), m.OptionSimple(model.UID)...)
}
func (s Order) Insert(m *ice.Message, arg ...string) {
	msg := m.Cmd(s.product, m.Option(model.STORE_UID), m.Option(model.PRODUCT_UID))
	m.Cmd(s.orderDetail, s.Insert, arg, msg.AppendSimple(model.PRICE), model.ORDER_UID, m.Option(model.UID))
	s.Amount(m)
}
func (s Order) Update(m *ice.Message, arg ...string) {
	m.Cmdy(s.orderDetail, s.Update, model.UID, m.Option(model.ORDER_DETAIL_UID), model.ORDER_UID, m.Option(model.UID))
	s.Amount(m)
}
func (s Order) Delete(m *ice.Message, arg ...string) {
	m.Cmd(s.orderDetail, s.Delete, model.UID, m.Option(model.ORDER_DETAIL_UID), model.ORDER_UID, m.Option(model.UID))
	s.Amount(m)
}
func (s Order) Cancel(m *ice.Message, arg ...string) {
	s.Table.Update(m, kit.Dict(model.STATUS, OrderCancel), m.OptionSimple(model.UID)...)
}
func (s Order) Submit(m *ice.Message, arg ...string) {
	s.Table.Update(m, kit.Dict(model.STATUS, OrderSubmit), m.OptionSimple(model.UID)...)
}
func (s Order) ConfirmSell(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderSubmit, model.FROM_USER_UID, func(msg *ice.Message) {
		s.Table.Update(m, kit.Dict(model.STATUS, OrderConfirm, m.OptionSimple(model.FROM_STORE_UID), model.FROM_USER_UID, m.Option(model.USER_UID)), m.OptionSimple(model.UID)...)
		s.SendMessage(m, m.Option(model.USER_UID), msg.Option(model.TO_USER_UID), m.Option(model.STORE_UID), m.Option(model.UID))
		s.SendMessage(m, msg.Option(model.TO_USER_UID), m.Option(model.USER_UID), m.Option(model.STORE_UID), m.Option(model.UID))
	})
}
func (s Order) ConfirmProduce(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderSubmit, model.FROM_USER_UID, func(msg *ice.Message) {
		s.Table.Update(m, kit.Dict(model.STATUS, OrderConfirm), m.OptionSimple(model.UID)...)
		s.SendMessage(m, msg.Option(model.USER_UID), m.Option(model.USER_UID), m.Option(model.STORE_UID), m.Option(model.UID))
	})
}
func (s Order) ConfirmPurchase(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderSubmit, model.TO_USER_UID, func(msg *ice.Message) {
		s.Table.Update(m, kit.Dict(model.STATUS, OrderConfirm, m.OptionSimple(model.TO_STORE_UID), model.TO_USER_UID, m.Option(model.USER_UID)), m.OptionSimple(model.UID)...)
		s.SendMessage(m, msg.Option(model.FROM_USER_UID), m.Option(model.USER_UID), m.Option(model.STORE_UID), m.Option(model.UID))
		s.SendMessage(m, m.Option(model.USER_UID), msg.Option(model.FROM_USER_UID), m.Option(model.STORE_UID), m.Option(model.UID))
	})
}
func (s Order) Again(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderDeal, "", func(msg *ice.Message) {
		s.Table.Insert(m, kit.Simple(model.STATUS, OrderConfirm, msg.AppendSimple(model.FROM_STORE_UID, model.FROM_USER_UID, model.TO_STORE_UID, model.TO_USER_UID))...)
		m.Cmd(s.orderDetail, m.Option(model.STORE_UID), m.Option(model.UID)).Table(func(detail ice.Maps) {
			m.Cmd(s.orderDetail, s.Insert, model.STORE_UID, detail[model.STORE_UID], model.ORDER_UID, m.Result(),
				model.PRODUCT_UID, detail[model.PRODUCT_UID], model.PRICE, detail[model.PRICE], model.COUNT, detail[model.COUNT],
			)
		})
	})
	m.ProcessRewrite(model.UID, m.Result())
}
func (s Order) Process(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderConfirm, model.FROM_USER_UID, func(msg *ice.Message) {
		s.store.Lock(m)
		m.Cmd(s.orderDetail, m.Option(model.STORE_UID), m.Option(model.UID)).Table(func(detail ice.Maps) {
			if m.IsErr() {
				return
			}
			m.Cmd(s.product, m.Option(model.STORE_UID), detail[model.PRODUCT_UID]).Table(func(product ice.Maps) {
				count, stock := kit.Int(detail[model.COUNT]), kit.Int(product[model.STOCK])
				switch ProductType(kit.Int(product[model.PRODUCT_TYPE])) {
				case ProductGoods:
					count = kit.Int(math.Abs(float64(count)))
				case ProductMaterial:
					count = -kit.Int(math.Abs(float64(count)))
				}
				if m.Warn(count < 0 && -count > stock, product[model.NAME], "库存不足") {
					return
				}
				m.Cmd(s.product, s.AddCount, model.STOCK, count, detail[model.PRODUCT_UID])
			})
		})
	})
}
func (s Order) Payment(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderConfirm, model.TO_USER_UID, func(msg *ice.Message) {
		if msg.Append(model.FROM_STORE_UID) == m.Option(model.STORE_UID) {
			s.store.Lock(m)
			if m.WarnNotValid(PaymentStatus(kit.Int(msg.Append(model.PAYMENT_STATUS))) != PaymentUnknown) {
				return
			}
			m.Cmd(s.orderDetail, m.Option(model.STORE_UID), m.Option(model.UID)).Table(func(detail ice.Maps) {
				if m.IsErr() {
					return
				}
				m.Cmd(s.product, m.Option(model.STORE_UID), detail[model.PRODUCT_UID]).Table(func(product ice.Maps) {
					count, stock := kit.Int(detail[model.COUNT]), kit.Int(product[model.STOCK])
					if m.Warn(count > stock, product[model.NAME], "库存不足") {
						return
					}
					m.Cmd(s.product, s.AddCount, model.STOCK, -count, detail[model.PRODUCT_UID])
				})
			})
			if m.IsErr() {
				return
			}
		}
		m.Cmdy(payment{}, s.Insert, model.ORDER_UID, m.Option(model.UID), m.OptionSimple(model.COMPANY_UID, model.OPEN_ID), model.STATUS, PaymentSuccess)
		s.Table.Update(m, kit.Dict(model.PAYMENT_STATUS, PaymentSuccess, model.PAYMENT_SUCCESS_TIME, m.Time()), m.OptionSimple(model.UID)...)
		m.Option(model.FROM_USER_UID, msg.Option(model.FROM_USER_UID))
	})
	s.sendTemplate(m, model.FROM_USER_UID, m.Trans("order payment", "订单已付款"))
}
func (s Order) ConfirmPayment(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderConfirm, model.FROM_USER_UID, func(msg *ice.Message) {
		if m.WarnNotValid(PaymentStatus(kit.Int(msg.Append(model.PAYMENT_STATUS))) != PaymentSuccess) {
			return
		}
		s.Table.Update(m, kit.Dict(model.PAYMENT_STATUS, PaymentConfirm), m.OptionSimple(model.UID)...)
	})
}
func (s Order) Express(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderConfirm, model.FROM_USER_UID, func(msg *ice.Message) {
		if m.WarnNotValid(PaymentStatus(kit.Int(msg.Append(model.PAYMENT_STATUS))) != PaymentConfirm) {
			return
		}
		if m.WarnNotValid(ExpressStatus(kit.Int(msg.Append(model.EXPRESS_STATUS))) != ExpressUnknown) {
			return
		}
		m.Cmdy(express{}, s.Insert, model.ORDER_UID, m.Option(model.UID), m.OptionSimple(model.COMPANY_UID, model.OPEN_ID), model.STATUS, ExpressRecv)
		s.Table.Update(m, kit.Dict(model.EXPRESS_STATUS, ExpressRecv), m.OptionSimple(model.UID)...)
		m.Option(model.TO_USER_UID, msg.Option(model.TO_USER_UID))
	})
	s.sendTemplate(m, model.TO_USER_UID, m.Trans("order express", "订单已发货"))
}
func (s Order) ConfirmExpress(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderConfirm, model.TO_USER_UID, func(msg *ice.Message) {
		if m.WarnNotValid(ExpressStatus(kit.Int(msg.Append(model.EXPRESS_STATUS))) != ExpressRecv) {
			return
		}
		if msg.Append(model.TO_STORE_UID) == m.Option(model.STORE_UID) {
			s.ReturnProduct(m)
		}
		s.Table.Update(m, kit.Dict(model.STATUS, OrderDeal, model.EXPRESS_STATUS, ExpressConfirm, model.EXPRESS_RECV_TIME, m.Time()), m.OptionSimple(model.UID)...)
		m.Option(model.FROM_USER_UID, msg.Option(model.FROM_USER_UID))
	})
	s.DashboardUpdate(m)
	s.sendTemplate(m, model.FROM_USER_UID, m.Trans("order confirm express", "订单已确认收货"))
}
func (s Order) Return(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderDeal, model.TO_USER_UID, func(msg *ice.Message) {
		if m.WarnNotValid(ExpressStatus(kit.Int(msg.Append(model.EXPRESS_STATUS))) != ExpressConfirm) {
			return
		}
		if m.WarnNotValid(ReturnStatus(kit.Int(msg.Append(model.RETURN_STATUS))) != ReturnUnknown) {
			return
		}
		m.Cmdy(Return{}, s.Insert, model.ORDER_UID, m.Option(model.UID), m.OptionSimple(model.COMPANY_UID, model.OPEN_ID), model.STATUS, ReturnRecv)
		s.Table.Update(m, kit.Dict(model.RETURN_STATUS, ReturnRecv, model.RETURN_RECV_TIME, m.Time()), m.OptionSimple(model.UID)...)
		m.Option(model.FROM_USER_UID, msg.Option(model.FROM_USER_UID))
	})
	s.sendTemplate(m, model.FROM_USER_UID, m.Trans("order return", "订单已发起退货"))
}
func (s Order) ReturnProduct(m *ice.Message, arg ...string) {
	s.store.Lock(m)
	m.Cmd(s.orderDetail, m.Option(model.STORE_UID), m.Option(model.UID)).Table(func(detail ice.Maps) {
		m.Cmd(s.product, s.AddCount, model.STOCK, detail[model.COUNT], detail[model.PRODUCT_UID])
	})
}
func (s Order) ConfirmReturn(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderDeal, model.FROM_USER_UID, func(msg *ice.Message) {
		if m.WarnNotValid(ReturnStatus(kit.Int(msg.Append(model.RETURN_STATUS))) != ReturnRecv) {
			return
		}
		s.ReturnProduct(m)
		s.Table.Update(m, kit.Dict(model.RETURN_STATUS, ReturnConfirm), m.OptionSimple(model.UID)...)
	})
	s.DashboardUpdate(m)
}
func (s Order) Refund(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, -1, model.FROM_USER_UID, func(msg *ice.Message) {
		if m.WarnNotValid(PaymentStatus(kit.Int(msg.Append(model.PAYMENT_STATUS))) != PaymentConfirm) {
			return
		}
		if m.WarnNotValid(RefundStatus(kit.Int(msg.Append(model.REFUND_STATUS))) != RefundUnknown) {
			return
		}
		m.Cmdy(refund{}, s.Insert, model.ORDER_UID, m.Option(model.UID), m.OptionSimple(model.COMPANY_UID, model.OPEN_ID), model.STATUS, RefundSuccess)
		s.Table.Update(m, kit.Dict(model.REFUND_STATUS, RefundSuccess, model.REFUND_SUCCESS_TIME, m.Time()), m.OptionSimple(model.UID)...)
		m.Option(model.TO_USER_UID, msg.Option(model.TO_USER_UID))
	})
	s.sendTemplate(m, model.TO_USER_UID, m.Trans("order refund", "订单已发起退款"))
}
func (s Order) ConfirmRefund(m *ice.Message, arg ...string) {
	s.changeStatusFrom(m, OrderDeal, model.TO_USER_UID, func(msg *ice.Message) {
		if m.WarnNotValid(RefundStatus(kit.Int(msg.Append(model.REFUND_STATUS))) != RefundSuccess) {
			return
		}
		s.Table.Update(m, kit.Dict(model.REFUND_STATUS, RefundConfirm, model.STATUS, OrderDone), m.OptionSimple(model.UID)...)
		m.Option(model.FROM_USER_UID, msg.Option(model.FROM_USER_UID))
	})
	s.sendTemplate(m, model.FROM_USER_UID, m.Trans("order confirm refund", "订单已确认退款"))
}

func init() { ice.TeamCtxCmd(Order{}) }

func (s Order) changeStatusFrom(m *ice.Message, from OrderStatus, which string, cb func(*ice.Message)) {
	s.Transaction(m, func() {
		msg := s.SelectForUpdate(m.Spawn(), m.OptionSimple(model.UID)...)
		if from != -1 && m.WarnNotValid(OrderStatus(kit.Int(msg.Append(model.STATUS))) != from) {
			return
		}
		if which != "" && msg.Append(which) != "" && m.WarnNotRight(m.Option(model.USER_UID) != msg.Append(which)) {
			return
		}
		cb(msg)
	})
}
func (s Order) sendTemplate(m *ice.Message, to string, title string) {
	s.RecordEvent(m, kit.JoinWord(kit.Cut(m.Option(model.UID), 6), title))
	kit.If(to == model.TO_USER_UID, func() { title = "进货" + title })
	kit.If(to == model.FROM_USER_UID, func() { title = "出货" + title })
	kit.If(to != "" && m.Option(to) != "", func() { s.SendTemplate(m, "", m.Option(to), title) })
}

func newOrder() Order { return Order{} }

type OrderType int

const (
	OrderUnknown OrderType = iota
	OrderSell
	OrderProduce
	OrderPurchase
)

var OrderTypeList = map[OrderType]string{
	OrderUnknown:  "unknown",
	OrderSell:     "sell",
	OrderProduce:  "produce",
	OrderPurchase: "purchase",
}

func (s OrderType) String() string { return OrderTypeList[s] }

type OrderStatus int

const (
	OrderCreate OrderStatus = iota
	OrderCancel
	OrderSubmit
	OrderConfirm
	OrderDeal
	OrderDone
	// dynamic
	OrderPayment
	OrderExpress
	OrderReturn
	OrderRefund
)

var OrderStatusList = map[OrderStatus]string{
	OrderCreate:  "create",
	OrderCancel:  "cancel",
	OrderSubmit:  "submit",
	OrderConfirm: "confirm",
	OrderDeal:    "deal",
	OrderDone:    "done",
	// dynamic
	OrderPayment: "payment",
	OrderExpress: "express",
	OrderReturn:  "return",
	OrderRefund:  "refund",
}

func (s OrderStatus) String() string { return OrderStatusList[s] }