增加 1.订单列表/订单统计/订单详情

 appname = partner
 runmode  = "${RUN_MODE||dev}"
-httpport = "${HTTP_PORT||8082}"
+httpport = "${HTTP_PORT||8080}"
 
 #开启监控
 EnableAdmin = false

@@ -52,6 +52,8 @@ spec:
             - mountPath: /opt/logs
               name: accesslogs
           env:
+            - name: RUN_MODE
+              value: 8082
             - name: POSTGRESQL_DB_NAME
               value: "mmmpartner_dev"
             - name: POSTGRESQL_USER

@@ -52,6 +52,8 @@ spec:
             - mountPath: /opt/logs
               name: accesslogs
           env:
+            - name: RUN_MODE
+              value: 8082
             - name: POSTGRESQL_DB_NAME
               value: "partner"
             - name: POSTGRESQL_USER

@@ -62,6 +62,8 @@ spec:
                 configMapKeyRef:
                   name: suplus-config
                   key: redis.port
+            - name: RUN_MODE
+                value: 8082
             - name: POSTGRESQL_DB_NAME
               value: "partner_test"
             - name: POSTGRESQL_USER

@@ -8,5 +8,6 @@ require (
 	github.com/go-pg/pg/v10 v10.0.0-beta.2
 	github.com/linmadan/egglib-go v0.0.0-20191217144343-ca4539f95bf9
 	github.com/shiena/ansicolor v0.0.0-20151119151921-a422bbe96644 // indirect
+	github.com/shopspring/decimal v1.2.0
 	github.com/tiptok/gocomm v0.0.0-20190919092013-c230743f8095
 )

 package factory
 
+import (
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/dao"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/transaction"
+)
+
 //func CreateTaskDao(options map[string]interface{}) (*dao.TaskDao, error) {
 //	var transactionContext *pg.TransactionContext
 //	if value, ok := options["transactionContext"]; ok {
@@ -7,3 +12,7 @@ package factory
 //	}
 //	return dao.NewTaskDao(transactionContext)
 //}
+
+func CreateOrderDao(ctx *transaction.TransactionContext) (*dao.OrderDao, error) {
+	return dao.NewOrderDao(ctx)
+}

@@ -5,6 +5,7 @@ import (
 	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
 	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/utils"
 	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/protocol"
+	"time"
 )
 
 func Template(header *protocol.RequestHeader, request *protocol.OrderDetailRequest) (rsp *protocol.OrderDetailResponse, err error) {
@@ -25,13 +26,13 @@ func Template(header *protocol.RequestHeader, request *protocol.OrderDetailReque
 	return
 }
 
+//订单详情
 func OrderDetail(header *protocol.RequestHeader, request *protocol.OrderDetailRequest) (rsp *protocol.OrderDetailResponse, err error) {
 	var (
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		OrderResponsitory, _  = factory.CreateOrderRepository(transactionContext)
-		PartnerInfoRepository, _ = factory.CreatePartnerInfoRepositoryIn(transactionContext)
+		//PartnerInfoRepository, _ = factory.CreatePartnerInfoRepositoryIn(transactionContext)
 		order *domain.Order
-		partner                  *domain.PartnerInfo
 	)
 	if err = transactionContext.StartTransaction(); err != nil {
 		return nil, err
@@ -46,25 +47,163 @@ func OrderDetail(header *protocol.RequestHeader, request *protocol.OrderDetailRe
 	if order, err = OrderResponsitory.FindOne(utils.ObjectJsonToMap(request)); err != nil {
 		return
 	}
-	if partner, err = PartnerInfoRepository.FindOne(map[string]interface{}{"partnerId": order.PartnerId}); err != nil {
-		return
+	//if partner, err = PartnerInfoRepository.FindOne(map[string]interface{}{"partnerId": order.PartnerId}); err != nil {
+	//	return
+	//}
+	rsp.Order = protocol.OrderDetail{
+		Id:                order.Id,
+		OrderNo:           order.OrderCode,
+		OrderName:         order.OrderName,
+		OrderStatus:       order.OrderStatus,
+		CreateTime:        order.CreateAt.Unix() * 1000,
+		UpdateTime:        order.UpdateAt.Unix() * 1000,
+		OrderQuantity:     order.OrderCount,
+		OrderAmount:       order.OrderAmount,
+		OrderAmountCancel: order.OrderAmountCancel(),
+		OrderDistrict:     map[string]interface{}{"id": order.OrderRegionInfo.RegionId, "name": order.OrderRegionInfo.RegionName},
+		Customer:          protocol.Customer{Uname: order.Buyer.BuyerName, Phone: order.Buyer.ContactInfo},
+		MyDividend:        order.OrderTotalBonus(),
+		MyDividendPercent: order.PartnerBonusPercent,
 	}
-	rsp.Order = order
-	rsp.Partner = partner
 	err = transactionContext.CommitTransaction()
 	return
 }
 
+//订单统计
 func OrderStatistics(header *protocol.RequestHeader, request *protocol.OrderStatisticsRequest) (rsp *protocol.OrderStatisticsResponse, err error) {
 	var (
-	//beginTime =time.Unix(request)
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		OrderDao, _           = factory.CreateOrderDao(transactionContext)
 	)
-	rsp = &protocol.OrderStatisticsResponse{}
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err != nil {
+			transactionContext.RollbackTransaction()
+		}
+	}()
+	rsp = &protocol.OrderStatisticsResponse{Statistics: protocol.OrderStatics{}}
+	if rsp.Statistics.TodayIntentionQuantity, rsp.Statistics.TodayIntentionMoney, err = OrderDao.OrderStatics(&domain.OrderStaticQuery{
+		BeginTime: utils.GetDayBegin().Unix() * 1000,
+		EndTime:   utils.GetDayEnd().Unix() * 1000,
+		OrderType: domain.OrderIntention,
+		PartnerId: header.UserId,
+	}); err != nil {
+		return
+	}
+	if rsp.Statistics.TodayRealQuantity, rsp.Statistics.TodayRealMoney, err = OrderDao.OrderStatics(&domain.OrderStaticQuery{
+		BeginTime: utils.GetDayBegin().Unix() * 1000,
+		EndTime:   utils.GetDayEnd().Unix() * 1000,
+		OrderType: domain.OrderReal,
+		PartnerId: header.UserId,
+	}); err != nil {
+		return
+	}
+	if rsp.Statistics.CumulativeQuantity, rsp.Statistics.CumulativeMoney, err = OrderDao.OrderStatics(&domain.OrderStaticQuery{
+		EndTime:   time.Now().Unix() * 1000,
+		OrderType: domain.OrderReal,
+		PartnerId: header.UserId,
+	}); err != nil {
+		return
+	}
+	err = transactionContext.CommitTransaction()
 	return
 }
 
+//订单列表
 func OrderList(header *protocol.RequestHeader, request *protocol.OrderListRequest) (rsp *protocol.OrderListResponse, err error) {
-	var ()
-	rsp = &protocol.OrderListResponse{}
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		OrderResponsitory, _  = factory.CreateOrderRepository(transactionContext)
+		OrderDao, _           = factory.CreateOrderDao(transactionContext)
+		orders                []*domain.Order
+	)
+
+	rsp = &protocol.OrderListResponse{
+		List:       make([]*protocol.OrderListItem, 0),
+		Statistics: make(map[string]interface{}),
+	}
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = transactionContext.CommitTransaction()
+		if err != nil {
+			transactionContext.RollbackTransaction()
+		}
+	}()
+	queryOption := &domain.OrderQueryOption{
+		PartnerId:        header.UserId,
+		OrderType:        request.OrderAction,
+		Limit:            request.PageSize,
+		Offset:           request.PageSize * request.PageIndex,
+		SortByUpdateTime: domain.DESC,
+	}
+	if request.StartTime > 0 {
+		queryOption.BeginTime = time.Unix(request.StartTime/1000, 0)
+	}
+	if request.EndTime > 0 {
+		queryOption.EndTime = time.Unix(request.EndTime/1000, 0)
+	}
+	_, orders, _ = OrderResponsitory.Find(utils.ObjectJsonToMap(queryOption))
+	//统计数据
+	if request.PageIndex == 0 {
+		//部分发货的订单数量
+		rsp.Statistics["partShipmentQuantity"], _, err = OrderDao.OrderStatics(&domain.OrderStaticQuery{
+			EndTime:     time.Now().Unix() * 1000,
+			OrderType:   domain.OrderReal,
+			PartnerId:   header.UserId,
+			OrderStatus: domain.OrderStatusDeliverSome,
+		})
+		//全部发货的订单数量
+		rsp.Statistics["allShipmentQuantity"], _, err = OrderDao.OrderStatics(&domain.OrderStaticQuery{
+			EndTime:     time.Now().Unix() * 1000,
+			OrderType:   domain.OrderReal,
+			PartnerId:   header.UserId,
+			OrderStatus: domain.OrderStatusDeliverAll,
+		})
+		var (
+			cumulativeQuantity, intentionQuantity int
+		)
+		//累计实发订单
+		cumulativeQuantity, _, err = OrderDao.OrderStatics(&domain.OrderStaticQuery{
+			EndTime:   time.Now().Unix() * 1000,
+			OrderType: domain.OrderReal,
+			PartnerId: header.UserId,
+		})
+		//累计意向订单
+		intentionQuantity, _, err = OrderDao.OrderStatics(&domain.OrderStaticQuery{
+			EndTime:   time.Now().Unix() * 1000,
+			OrderType: domain.OrderIntention,
+			PartnerId: header.UserId,
+		})
+		//订单数量
+		rsp.Statistics["orderQuantity"] = cumulativeQuantity + intentionQuantity
+		rsp.Statistics["cumulativeQuantity"] = cumulativeQuantity
+		rsp.Statistics["intentionQuantity"] = intentionQuantity
+
+	}
+
+	if len(orders) == 0 {
 		return
+	}
+	for i := range orders {
+		rsp.List = append(rsp.List, DomainOrderToOrderListItem(orders[i]))
+	}
+	return
+}
+func DomainOrderToOrderListItem(order *domain.Order) *protocol.OrderListItem {
+	return &protocol.OrderListItem{
+		Id:               order.Id,
+		OrderType:        order.OrderType,
+		OrderNo:          order.OrderCode,
+		OrderName:        order.OrderName,
+		OrderAmount:      order.OrderAmount,
+		OrderActualCount: order.OrderActualCount,
+		OrderStatus:      order.OrderStatus,
+		UpdateTime:       order.UpdateAt.Unix() * 1000,
+		MyDividend:       order.OrderTotalBonus(),
+		IsRead:           order.IsRead(),
+	}
 }

@@ -116,10 +116,28 @@ func (m *Order) OrderBonusOutstanding() float64 {
 	return utils.Decimal((m.OrderAmount - m.OrderActualAmount) * (m.PartnerBonusPercent / 100.0))
 }
 
+//订单被取消金额
+func (m *Order) OrderAmountCancel() float64 {
+	if m.OrderAmount <= m.OrderActualAmount {
+		return 0
+	}
+	return utils.Decimal((m.OrderAmount - m.OrderActualAmount))
+}
+
+func (m *Order) IsRead() int {
+	if m.UpdateAt.After(m.LastViewTime) {
+		return 0
+	}
+	return 1
+}
+
 type OrderQueryOption struct {
 	PartnerId        int64     `json:"partnerId,omitempty"`
+	OrderType        int       `json:"orderType,omitempty"`
 	BeginTime        time.Time `json:"beginTime,omitempty"`
 	EndTime          time.Time `json:"endTime,omitempty"`
 	SortByCreateTime string    `json:"sortByCreateTime,omitempty"`
 	SortByUpdateTime string    `json:"sortByUpdateTime,omitempty"`
+	Offset           int       `json:"offset,omitempty"`
+	Limit            int       `json:"limit,omitempty"`
 }

 package domain
 
+//type OrderTodayStatic struct {
+//	TodayIntentionQuantity int `json:"todayIntentionQuantity"` //今日新增意向订单
+//	TodayIntentionMoney    int `json:"todayIntentionMoney"`    //今日新增意向订单金额
+//	TodayRealQuantity      int `json:"todayRealQuantity"`      //今日新增实发订单
+//	TodayRealMoney         int `json:"todayRealMoney"`         //今日新增实发订单金额
+//	//CumulativeQuantity     int `json:"cumulativeQuantity"`     //累计实发订单
+//	//CumulativeMoney        int `json:"cumulativeMoney"`        //累计实发订单金额
+//}
+////实发订单统计
+//type OrderRealStatic struct {
+//	CumulativeQuantity     int `json:"cumulativeQuantity"`     //累计实发订单
+//	CumulativeMoney        int `json:"cumulativeMoney"`        //累计实发订单金额
+//}
+////意向订单统计
+//type OrderIntentionStatic struct {
+//	CumulativeQuantity     int `json:"cumulativeQuantity"`     //累计意向订单
+//	CumulativeMoney        int `json:"cumulativeMoney"`                 //累计意向订单金额
+//}
+
 type OrderStatic struct {
-	TodayIntentionQuantity int `json:"todayIntentionQuantity"` //今日新增意向订单
-	TodayIntentionMoney    int `json:"todayIntentionMoney"`    //今日新增意向订单金额
-	TodayRealQuantity      int `json:"todayRealQuantity"`      //今日新增实发订单
-	TodayRealMoney         int `json:"todayRealMoney"`         //今日新增实发订单金额
-	CumulativeQuantity     int `json:"cumulativeQuantity"`     //累计实发订单
-	CumulativeMoney        int `json:"cumulativeMoney"`        //累计实发订单金额
+	CumulativeQuantity int `json:"cumulativeQuantity"` //累计数量
+	CumulativeMoney    int `json:"cumulativeMoney"`    //累计金额
+}
+
+type OrderStaticQuery struct {
+	PartnerId   int64 `json:"partnerId,omitempty"`
+	BeginTime   int64 `json:"beginTime,omitempty"`
+	EndTime     int64 `json:"endTime,omitempty"`
+	OrderStatus int   `json:"orderStatus,omitempty"`
+	OrderType   int   `json:"orderType,omitempty"`
 }

@@ -2,22 +2,42 @@ package dao
 
 import (
 	"fmt"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/models"
 	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/transaction"
+	"time"
 )
 
 type OrderDao struct {
 	transactionContext *transaction.TransactionContext
 }
 
-func (dao *OrderDao) OrderStatics() (count int, amount float64, err error) {
-	//tx :=dao.transactionContext.PgTx
-	//order :=new(models.Order)
-	//sql :=fmt.Sprintf(``,)
-	//q:=tx.Model(order).QueryOne()
+func (dao *OrderDao) OrderStatics(option *domain.OrderStaticQuery) (count int, amount float64, err error) {
+	tx := dao.transactionContext.PgTx
+	order := new(models.Order)
+	q := tx.Model(order)
+	q.ColumnExpr("count(*) count")
+	q.ColumnExpr("sum(order_amount) total_order_amount")
+	if option.PartnerId > 0 {
+		q.Where(`"order".partner_id =?`, option.PartnerId)
+	}
+	if option.OrderType > 0 {
+		q.Where(`"order".order_type =?`, option.OrderType)
+	}
+	if option.OrderStatus > 0 {
+		q.Where(`"order".order_status =?`, option.OrderStatus)
+	}
+	if option.BeginTime > 0 {
+		q.Where(`"order".create_at >=?`, time.Unix(option.BeginTime/1000, 0))
+	}
+	if option.EndTime > 0 {
+		q.Where(`"order".create_at <?`, time.Unix(option.EndTime/1000, 0))
+	}
+	err = q.Select(&count, &amount)
 	return
 }
 
-func NewEmployeeDao(transactionContext *transaction.TransactionContext) (*OrderDao, error) {
+func NewOrderDao(transactionContext *transaction.TransactionContext) (*OrderDao, error) {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {

@@ -68,6 +68,8 @@ func (repository *OrderRepository) Find(queryOptions map[string]interface{}) (in
 	query := NewQuery(tx.Model(&OrderModels), queryOptions)
 	query.
 		SetWhere(`"order".partner_id= ?`, "partnerId").
+		SetWhere(`"order".order_type= ?`, "orderType").
+		SetWhere(`"order".order_type= ?`, "orderType").
 		SetWhere(`"order".create_at >= ?`, "beginTime").
 		SetWhere(`"order".create_at < ?`, "endTime").
 		SetLimit().

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"github.com/go-pg/pg/v10/orm"
 	"github.com/linmadan/egglib-go/utils/snowflake"
+	"strconv"
 	"time"
 )
 
@@ -41,17 +42,17 @@ func (query *Query) SetWhere(condition, key string) *Query {
 
 func (query *Query) SetLimit() *Query {
 	if offset, ok := query.queryOptions["offset"]; ok {
-		offset := offset.(int)
+		offset, _ := strconv.ParseInt(fmt.Sprintf("%v", offset), 10, 64)
 		if offset > -1 {
-			query.Offset(offset)
+			query.Offset(int(offset))
 		}
 	} else {
 		query.Offset(0)
 	}
 	if limit, ok := query.queryOptions["limit"]; ok {
-		limit := limit.(int)
+		limit, _ := strconv.ParseInt(fmt.Sprintf("%v", limit), 10, 64)
 		if limit > -1 {
-			query.Limit(limit)
+			query.Limit(int(limit))
 		} else {
 			query.Limit(20)
 		}

 package utils
 
 import (
-	"fmt"
+	"github.com/shopspring/decimal"
 	"math"
-	"strconv"
 )
 
-func decimal(value float64) float64 {
-	return math.Trunc(value*1e1+0.5) * 1e-2
+func decimal1(value float64) float64 {
+	return math.Trunc(value*1e1+0.5) * 1e-1
+}
+
+func Round(value float64, places int32) float64 {
+	quantity := decimal.NewFromFloat(value)
+	d := quantity.Round(places)
+	rsp, _ := d.Float64()
+	return rsp
 }
 
 func Decimal(value float64) float64 {
-	value = decimal(value)
-	value, _ = strconv.ParseFloat(fmt.Sprintf("%.1f", value), 64)
-	return value
+	return Round(value, 2)
 }
 
 func DecimalToNumber(value float64) float64 {
-	value = decimal(value)
-	value, _ = strconv.ParseFloat(fmt.Sprintf("%.f", value), 64)
-	return value
+	return Round(value, 2)
 }

+package utils
+
+import "time"
+
+func GetDayBegin() time.Time {
+	t := time.Now()
+	today, _ := time.Parse("2006-01-02", t.Format("2006-01-02"))
+	return today
+}
+
+func GetDayEnd() time.Time {
+	t := GetDayBegin()
+	nextDay := t.AddDate(0, 0, 1)
+	return nextDay
+}

@@ -10,8 +10,8 @@ type OrderController struct {
 }
 
 //OrderStatistics 订单统计
-// @router /orderStatistics [post]
-func (this *OrderController) OrderStatistics() {
+// @router /statistics [post]
+func (this *OrderController) Statistics() {
 	var msg *protocol.ResponseMessage
 	defer func() {
 		this.Resp(msg)

@@ -22,7 +22,9 @@ func init() {
 	nsV1.Router("user/resetPassword", &controllers.UserController{}, "Post:ResetPassword")
 	nsV1.Router("user/changePassword", &controllers.UserController{}, "Post:ChangePassword")
 
+	nsV1.Router("order/statistics", &controllers.OrderController{}, "Post:Statistics")
 	nsV1.Router("order/details", &controllers.OrderController{}, "Post:OrderDetail")
+	nsV1.Router("order/list", &controllers.OrderController{}, "Post:OrderList")
 
 	nsV1.Router("dividend/statistics", &controllers.DividendController{}, "Post:DividendStatistics")
 	beego.AddNamespace(nsV1)

@@ -100,7 +100,7 @@ func NewReturnResponse(data interface{}, eRR error) *ResponseMessage {
 		msg.Data = data
 		return msg
 	}
-	// fmt.Println("日志:" + eRR.Error())
+	fmt.Println("日志:" + eRR.Error())
 	if x, ok := eRR.(CustomErrParse); ok {
 		msg = x.ParseToMessage()
 		msg.Data = data

@@ -6,19 +6,73 @@ type OrderDetailRequest struct {
 }
 type OrderDetailResponse struct {
 	Order interface{} `json:"order"`
-	Partner interface{} `json:"partner"`
+}
+type OrderDetail struct {
+	Id                int64       `json:"id"`
+	OrderNo           string      `json:"orderNo"`
+	OrderName         string      `json:"orderName"`
+	OrderStatus       int         `json:"orderStatus"`
+	CreateTime        int64       `json:"createTime"`
+	UpdateTime        int64       `json:"updateTime"`
+	OrderQuantity     int         `json:"orderQuantity"`
+	OrderAmount       float64     `json:"orderAmount"`
+	OrderAmountCancel float64     `json:"orderAmountCancel"`
+	OrderDistrict     interface{} `json:"orderDistrict"`
+	Customer          Customer    `json:"customer"`
+	MyDividend        float64     `json:"myDividend"`
+	MyDividendPercent float64     `json:"myDividendPercent"`
+}
+type Customer struct {
+	Uname string `json:"uname"`
+	Phone string `json:"phone"`
 }
 
 /*OrderStatistics */
 type OrderStatisticsRequest struct {
-	Xxx string `json:"xxx" valid:"Required"`
 }
 type OrderStatisticsResponse struct {
+	Statistics OrderStatics `json:"statistics"`
+}
+type OrderStatics struct {
+	TodayIntentionQuantity int     `json:"todayIntentionQuantity"` //今日新增意向订单
+	TodayIntentionMoney    float64 `json:"todayIntentionMoney"`    //今日新增意向订单金额
+	TodayRealQuantity      int     `json:"todayRealQuantity"`      //今日新增实发订单
+	TodayRealMoney         float64 `json:"todayRealMoney"`         //今日新增实发订单金额
+	CumulativeQuantity     int     `json:"cumulativeQuantity"`     //累计实发订单
+	CumulativeMoney        float64 `json:"cumulativeMoney"`        //累计实发订单金额
 }
 
 /*OrderList */
 type OrderListRequest struct {
-	Xxx string `json:"xxx" valid:"Required"`
+	StartTime   int64 `json:"startTime" valid:"Required"`
+	EndTime     int64 `json:"endTime" valid:"Required"`
+	OrderAction int   `json:"orderAction" valid:"Required"`
+	PageIndex   int   `json:"pageIndex"`
+	PageSize    int   `json:"pageSize" valid:"Required"`
 }
 type OrderListResponse struct {
+	List       []*OrderListItem       `json:"list"`
+	Statistics map[string]interface{} `json:"statistics"`
+}
+
+type OrderListItem struct {
+	//id
+	Id int64 `json:"id,omitempty"`
+	//订单类型
+	OrderType int `json:"orderType"`
+	//订单编号
+	OrderNo string `json:"orderNo"`
+	//订单名称
+	OrderName string `json:"orderName"`
+	//订单状态
+	OrderStatus int `json:"orderStatus"`
+	//实际订单数量
+	OrderActualCount int `json:"orderActualCount"`
+	//订单金额
+	OrderAmount float64 `json:"orderAmount"`
+	UpdateTime  int64   `json:"updateTime"`
+	//我的分红
+	MyDividend float64 `json:"myDividend"`
+	//是否已读（0未读，1已读）
+	IsRead int `json:"isRead"`
 }