Merge branch 'feat/order-domain' into 6-order-domain-service

增加状态

+version: v1
+kind: Attribute
+metadata:
+  name: deliveryTime
+  description: 发货时间
+  type: 
+    primitive: datetime

@@ -14,6 +14,8 @@ metadata:
     required: true
   - ref: deliveryCode
     required: true
+  - ref: delieveryTime
+    required: true
   - ref: isDisable
     required: true
   - ref: orderNo

@@ -19,6 +19,7 @@ const (
 	ORDER_STATUS_RETURN               // 退换货
 	ORDER_STATUS_CANCELED             // 已取消（关闭）
 	ORDER_STATUS_COMPLETED            // 已完成
+	ORDER_STATUS_CLOSED               // 已关闭
 )
 
 // 订单实体
@@ -33,6 +34,8 @@ type Order struct {
 	PartnerId int64 `json:"partnerId"`
 	// 发货单号
 	DeliveryCode string `json:"deliveryCode"`
+	// 发货时间
+	DeliveryTime time.Time `json:"deliveryTime"`
 	// 是否关闭订单标志
 	IsDisable int `json:"isDisable"`
 	// 订单编号
@@ -70,13 +73,14 @@ type Order struct {
 // 订单状态机
 type OrderStatus interface {
 	Update(order *Order, data map[string]interface{}) error // 更新订单
-	Checkout(order *Order) error                            // 下单
-	Return(order *Order) error                              // 退换货
+	Shipping(order *Order) error                            // 发货
+	Return(order *Order) error                              // 退换/货
 	Cancel(order *Order) error                              // 取消订单
 	Receive(order *Order) error                             // 收货
+	Close(order *Order) error                               // 关闭订单
 }
 
-// 代发货状态
+// 待发货状态
 type UnShippedStatus struct{}
 
 // 编辑待发货订单
@@ -195,18 +199,29 @@ func (status *UnShippedStatus) Update(order *Order, data map[string]interface{})
 	return nil
 }
 
-func (status *UnShippedStatus) Checkout(order *Order) error {
+// 发货
+func (status *UnShippedStatus) Shipping(order *Order) error {
+	currentTime := time.Now()
+	order.DeliveryTime = currentTime
+	if order.OrderType == ORDER_TYPE_INTENTION {
+		order.OrderStatus = ORDER_STATUS_TRANSIT
+		order.CurrentStatus = &TransitStatus{}
+	}
 	return nil
 }
 
+// 退货
 func (status *UnShippedStatus) Return(order *Order) error {
 	return fmt.Errorf("待发货订单不能退货")
 }
 
+// 取消订单
 func (status *UnShippedStatus) Cancel(order *Order) error {
+	order.CurrentStatus = &CanceledStatus{}
 	return nil
 }
 
+// 收货
 func (status *UnShippedStatus) Receive(order *Order) error {
 	return fmt.Errorf("待发货订单不能收货")
 }
@@ -214,122 +229,176 @@ func (status *UnShippedStatus) Receive(order *Order) error {
 // 待收货状态
 type TransitStatus struct{}
 
+// 待收货订单不能再次发货
+func (status *TransitStatus) Shipping(order *Order) error {
+	return fmt.Errorf("待收货订单不能重复发货")
+}
+
+// 待收货订单不能关闭
+func (status *TransitStatus) Close(order *Order) error {
+	return fmt.Errorf("待收货订单不能关闭")
+}
+
 // 待收货订单不允许编辑
 func (status *TransitStatus) Update(order *Order, data map[string]interface{}) error {
 	return fmt.Errorf("已发货订单不允许编辑")
 }
 
-func (status *TransitStatus) Checkout(order *Order) error {
-	return fmt.Errorf("待收货订单不能重复发货")
-}
-
+// 退货
 func (status *TransitStatus) Return(order *Order) error {
+	order.CurrentStatus = &ReturnedStatus{}
 	return nil
 }
 
+// 待收货订单不能取消
 func (status *TransitStatus) Cancel(order *Order) error {
 	return fmt.Errorf("待收货订单不能取消")
 }
 
+// 收货
 func (status *TransitStatus) Receive(order *Order) error {
+	order.CurrentStatus = &ReceivedStatus{}
 	return nil
 }
 
 // 收货状态
 type ReceivedStatus struct{}
 
+// 编辑订单
 func (status *ReceivedStatus) Update(order *Order, data map[string]interface{}) error {
 	return fmt.Errorf("已收货订单不能编辑")
 }
 
-func (status *ReceivedStatus) Checkout(order *Order) error {
-	return fmt.Errorf("已收货订单不能重复发货")
+// 已收货订单不能再次收货
+func (status *ReceivedStatus) Shipping(order *Order) error {
+	return fmt.Errorf("已收货订单不能再次发货")
 }
 
+// 退货
 func (status *ReceivedStatus) Return(order *Order) error {
+	order.CurrentStatus = &ReturnedStatus{}
 	return nil
 }
 
+// 已取消订单不能再次取消
 func (status *ReceivedStatus) Cancel(order *Order) error {
 	return fmt.Errorf("已收货订单不能取消")
 }
 
+// 已收货订单不能重复收货
 func (status *ReceivedStatus) Receive(order *Order) error {
 	return fmt.Errorf("已收货订单不能重复收货")
 }
 
+// 关闭订单
+func (status *ReceivedStatus) Close(order *Order) error {
+	return nil
+}
+
 // 退货状态
 type ReturnedStatus struct{}
 
+// 已退货订单不能编辑
 func (status *ReturnedStatus) Update(order *Order, data map[string]interface{}) error {
 	return fmt.Errorf("已退货订单不允许编辑")
 }
 
-func (status *ReturnedStatus) Checkout(order *Order) error {
-	return fmt.Errorf("已退货订单不允许发货")
+// 已收货订单不能再次收货
+func (status *ReturnedStatus) Shipping(order *Order) error {
+	return fmt.Errorf("已收货订单不能再次发货")
 }
 
+// 已退货订单不能再次发货
 func (status *ReturnedStatus) Return(order *Order) error {
 	return fmt.Errorf("已退货订单不允许再次退货")
 }
 
+// 已退货订单不能取消
 func (status *ReturnedStatus) Cancel(order *Order) error {
 	return fmt.Errorf("已退货订单不能取消")
 }
 
+// 已退货订单不能重复守护
 func (status *ReturnedStatus) Receive(order *Order) error {
 	return fmt.Errorf("已退货订单不能收货")
 }
 
+// 关闭订单
+func (status *ReturnedStatus) Close(order *Order) error {
+
+	return nil
+}
+
 // 取消状态
 type CanceledStatus struct{}
 
+// 已取消订单不能编辑
 func (status *CanceledStatus) Update(order *Order, dat map[string]interface{}) error {
 	return fmt.Errorf("已取消订单不能编辑")
 }
 
-func (status *CanceledStatus) Checkout(order *Order) error {
-	return fmt.Errorf("已取消订单不能发货")
+// 已取消订单不能发货
+func (status *CanceledStatus) Shipping(order *Order) error {
+	return fmt.Errorf("已取消订单不能再次发货")
 }
 
+// 已取消的订单不能退货
 func (status *CanceledStatus) Return(order *Order) error {
 	return fmt.Errorf("已取消订单不能退货")
 }
 
+// 已取消定案不能再次取消
 func (status *CanceledStatus) Cancel(order *Order) error {
 	return fmt.Errorf("已取消订单不能再次取消")
 }
 
+// 已取消订单不能收货
 func (status *CanceledStatus) Receive(order *Order) error {
 	return fmt.Errorf("已取消订单不能进行收货")
 }
 
+// 关闭订单
+func (status *CanceledStatus) Close(order *Order) error {
+	return nil
+}
+
 // 已完成状态
 type CompletedStatus struct{}
 
+// 编辑已完成订单分红
 func (status *CompletedStatus) Update(order *Order, data map[string]interface{}) error {
+
 	return nil
 }
 
-func (status *CompletedStatus) Checkout(order *Order) error {
+// 已完成的订单不能再次发货
+func (status *CompletedStatus) Shipping(order *Order) error {
 	return fmt.Errorf("已完成订单不能发货")
 }
 
+// 已完成订单不能退货
 func (status *CompletedStatus) Return(order *Order) error {
 	return fmt.Errorf("已完成订单不能退货")
 }
 
+// 已完成订单不能取消
 func (status *CompletedStatus) Cancel(order *Order) error {
 	return fmt.Errorf("已完成订单不能取消")
 }
 
+// 已完成订单不能收货
 func (status *CompletedStatus) Receive(order *Order) error {
 	return fmt.Errorf("已完成订单不能收货")
 }
 
+// 关闭已完成订单
+func (status *CompletedStatus) Close(order *Order) error {
+	return nil
+}
+
 // 订单仓储
 type OrderRepository interface {
-	Save(order *Order) (*Order, error)
+	Save(order *Order) (*Order, error) // 下单/编辑订单
 	Remove(order *Order) (*Order, error)
 	FindOne(queryOptions map[string]interface{}) (*Order, error)
 	Find(queryOptions map[string]interface{}) (int64, []*Order, error)
@@ -348,8 +417,8 @@ func (order *Order) Update(data map[string]interface{}) error {
 }
 
 // 发货
-func (order *Order) Checkout() error {
-	return order.CurrentStatus.Checkout(order)
+func (order *Order) Shipping() error {
+	return order.CurrentStatus.Shipping(order)
 }
 
 // 退货
@@ -366,3 +435,8 @@ func (order *Order) Receive() error {
 func (order *Order) Cancel() error {
 	return order.CurrentStatus.Cancel(order)
 }
+
+// 关闭订单
+func (order *Order) Close() error {
+	return order.CurrentStatus.Close(order)
+}