From d5752381c7c9534f24c820e00ac41c2351cc0807 Mon Sep 17 00:00:00 2001 From: gazebo Date: Thu, 18 Jul 2019 18:46:14 +0800 Subject: [PATCH] + partner.ListOrders + AmendMissingOrders --- business/jxcallback/orderman/orderman_ext.go | 119 +++++++++++++++++++ business/model/dao/dao_order.go | 24 ++++ business/partner/partner_store_sku.go | 3 + business/partner/purchase/ebai/order.go | 41 +++++++ business/partner/purchase/ebai/order_test.go | 13 +- business/partner/purchase/jd/order.go | 25 ++++ business/partner/purchase/jd/order_test.go | 17 ++- business/partner/purchase/mtwm/order.go | 49 ++++++++ business/partner/purchase/mtwm/order_test.go | 13 +- controllers/jx_order.go | 10 ++ 10 files changed, 309 insertions(+), 5 deletions(-) diff --git a/business/jxcallback/orderman/orderman_ext.go b/business/jxcallback/orderman/orderman_ext.go index 1570a08a1..6e165be14 100644 --- a/business/jxcallback/orderman/orderman_ext.go +++ b/business/jxcallback/orderman/orderman_ext.go @@ -969,3 +969,122 @@ func (c *OrderManager) GetStoreAfsOrderCountInfo(ctx *jxcontext.Context, storeID globals.SugarLogger.Infof("GetStoreAfsOrderCountInfo storeID:%d failed with error:%v", storeID, err) return nil, err } + +func (c *OrderManager) AmendMissingOrders(ctx *jxcontext.Context, vendorIDs []int, storeID int, fromDate, toDate time.Time, isAsync, isContinueWhenError bool) (hint string, err error) { + if utils.IsTimeZero(fromDate) { + return "", fmt.Errorf("fromDate必须指定") + } + if len(vendorIDs) == 0 { + for vendorID := range partner.PurchasePlatformHandlers { + vendorIDs = append(vendorIDs, vendorID) + } + } + type tDateVendorPair struct { + QueryDate time.Time + VendorID int + } + fromDate = utils.Time2Date(fromDate) + if utils.IsTimeZero(toDate) { + toDate = fromDate + } + toDate = utils.Time2Date(toDate) + var dateVendorList []*tDateVendorPair + for _, vendorID := range vendorIDs { + for tmpDate := fromDate; tmpDate.Sub(toDate) <= 0; tmpDate = tmpDate.Add(24 * time.Hour) { + dateVendorList = append(dateVendorList, &tDateVendorPair{ + QueryDate: tmpDate, + VendorID: vendorID, + }) + } + } + type tOrderVendorPair struct { + VendorOrderID string + VendorID int + } + if len(dateVendorList) > 0 { + var missingOrderList []*tOrderVendorPair + task := tasksch.NewSeqTask("AmendMissingOrders", ctx, + func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) { + switch step { + case 0: + db := dao.GetDB() + vendorStoreIDMap := make(map[int]string) + if storeID > 0 { + for _, vendorID := range vendorIDs { + storeDetail, err2 := dao.GetStoreDetail(db, storeID, vendorID) + if err = err2; err != nil { + return "", err + } + vendorStoreIDMap[vendorID] = storeDetail.VendorStoreID + } + } + task1 := tasksch.NewParallelTask("AmendMissingOrders ListOrders", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx, + func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) { + vendorDate := batchItemList[0].(*tDateVendorPair) + if handler, _ := partner.GetPurchasePlatformFromVendorID(vendorDate.VendorID).(partner.IPurchasePlatformStoreSkuHandler); handler != nil { + orderIDs, err2 := handler.ListOrders(ctx, task, vendorDate.QueryDate, vendorStoreIDMap[vendorDate.VendorID]) + if err = err2; err == nil && len(orderIDs) > 0 { + var orderList []*tOrderVendorPair + for _, v := range orderIDs { + orderList = append(orderList, &tOrderVendorPair{ + VendorOrderID: v, + VendorID: vendorDate.VendorID, + }) + } + retVal = orderList + } + } + return retVal, err + }, dateVendorList) + tasksch.HandleTask(task1, task, true).Run() + orderList, err2 := task1.GetResult(0) + if err = err2; err != nil && !isContinueWhenError { + return "", err + } + localOrders, err2 := dao.QueryOrders(db, vendorIDs, storeID, fromDate, toDate.Add(24*time.Hour-time.Second)) + if err = err2; err != nil { + return "", err + } + localOrderMap := make(map[string]*model.GoodsOrder) + for _, v := range localOrders { + localOrderMap[jxutils.ComposeUniversalOrderID(v.VendorOrderID, v.VendorID)] = v + } + + for _, v := range orderList { + pair := v.(*tOrderVendorPair) + if localOrderMap[jxutils.ComposeUniversalOrderID(pair.VendorOrderID, pair.VendorID)] == nil { + missingOrderList = append(missingOrderList, pair) + } + } + case 1: + task2 := tasksch.NewParallelTask("AmendMissingOrders GetOrders", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx, + func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) { + pair := batchItemList[0].(*tOrderVendorPair) + if handler := partner.GetPurchasePlatformFromVendorID(pair.VendorID); handler != nil { + order, err2 := handler.GetOrder(pair.VendorOrderID) + if err = err2; err == nil { + isDuplicated, err2 := c.SaveOrder(order, false, dao.GetDB()) + if err2 == nil && !isDuplicated { + retVal = []int{1} + } + } + } + return retVal, err + }, missingOrderList) + tasksch.HandleTask(task2, task, true).Run() + result, err = task2.GetResult(0) + } + return result, err + }, 2) + tasksch.HandleTask(task, nil, true).Run() + if !isAsync { + result, err2 := task.GetResult(0) + if err = err2; err == nil { + hint = utils.Int2Str(len(result)) + } + } else { + hint = task.GetID() + } + } + return hint, err +} diff --git a/business/model/dao/dao_order.go b/business/model/dao/dao_order.go index f9ba426ca..9f29dd539 100644 --- a/business/model/dao/dao_order.go +++ b/business/model/dao/dao_order.go @@ -21,6 +21,30 @@ type StoresOrderSaleInfo struct { EarningPrice int64 `json:"earningPrice"` // 预估结算给门店老板的钱 } +func QueryOrders(db *DaoDB, vendorIDs []int, storeID int, orderCreatedAtBegin, orderCreatedAtEnd time.Time) (orderList []*model.GoodsOrder, err error) { + sql := ` + SELECT t1.* + FROM goods_order t1 + WHERE t1.order_created_at >= ?` + sqlParams := []interface{}{ + orderCreatedAtBegin, + } + if len(vendorIDs) > 0 { + sql += " AND t1.vendor_id IN (" + GenQuestionMarks(len(vendorIDs)) + ")" + sqlParams = append(sqlParams, vendorIDs) + } + if storeID > 0 { + sql += " AND IF(t1.jx_store_id <> 0, t1.jx_store_id, t1.store_id) = ?" + sqlParams = append(sqlParams, storeID) + } + if !utils.IsTimeZero(orderCreatedAtEnd) { + sql += " AND t1.order_created_at <= ?" + sqlParams = append(sqlParams, orderCreatedAtEnd) + } + // sql += " ORDER BY t1.order_created_at DESC, t1.id DESC;" + return orderList, GetRows(db, &orderList, sql, sqlParams...) +} + func GetStoreOrderAfterTime(db *DaoDB, storeID int, orderTime time.Time, lastOrderSeqID int64) (orderList []*model.GoodsOrderExt, err error) { sql := ` SELECT t1.*, diff --git a/business/partner/partner_store_sku.go b/business/partner/partner_store_sku.go index 4d5c7c409..afafe23b3 100644 --- a/business/partner/partner_store_sku.go +++ b/business/partner/partner_store_sku.go @@ -2,6 +2,7 @@ package partner import ( "math" + "time" "git.rosy.net.cn/baseapi/utils" "git.rosy.net.cn/jx-callback/business/jxutils/jxcontext" @@ -104,6 +105,8 @@ type BareCategoryInfo struct { type IPurchasePlatformStoreSkuHandler interface { GetStoreSkusBatchSize(funcID int) int + ListOrders(ctx *jxcontext.Context, parentTask tasksch.ITask, queryDate time.Time, vendorStoreID string) (vendorOrderIDs []string, err error) + GetStoreSkusBareInfo(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, vendorStoreID string, inStoreSkuList []*StoreSkuInfo) (outStoreSkuList []*StoreSkuInfo, err error) UpdateStoreSkusStock(ctx *jxcontext.Context, storeID int, vendorStoreID string, storeSkuList []*StoreSkuInfo) (err error) UpdateStoreSkusStatus(ctx *jxcontext.Context, storeID int, vendorStoreID string, storeSkuList []*StoreSkuInfo) (err error) diff --git a/business/partner/purchase/ebai/order.go b/business/partner/purchase/ebai/order.go index 9e0efad2d..7cc70ef7a 100644 --- a/business/partner/purchase/ebai/order.go +++ b/business/partner/purchase/ebai/order.go @@ -1,6 +1,7 @@ package ebai import ( + "fmt" "math" "time" @@ -563,3 +564,43 @@ func (c *PurchaseHandler) AdjustOrder(ctx *jxcontext.Context, order *model.Goods } return err } + +func (c *PurchaseHandler) ListOrders(ctx *jxcontext.Context, parentTask tasksch.ITask, queryDate time.Time, vendorStoreID string) (vendorOrderIDs []string, err error) { + if utils.IsTimeZero(queryDate) { + return nil, fmt.Errorf("queryDate必须指定") + } + fromDate := utils.Time2Date(queryDate) + toDate := fromDate.Add(24*time.Hour - 1) + var shopList []*ebaiapi.ShopInfo + if vendorStoreID == "" { + shopList, err = api.EbaiAPI.ShopList(ebaiapi.SysStatusAll) + if err != nil { + return nil, err + } + } else { + shopList = []*ebaiapi.ShopInfo{ + &ebaiapi.ShopInfo{ + BaiduShopID: utils.Str2Int64(vendorStoreID), + }, + } + } + task := tasksch.NewParallelTask("ebai ListOrders", nil, ctx, + func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) { + shop := batchItemList[0].(*ebaiapi.ShopInfo) + orderList, err := api.EbaiAPI.OrderListAll("", shop.BaiduShopID, fromDate.Unix(), toDate.Unix(), 0) + if err == nil { + retVal = orderList + } + return retVal, err + }, shopList) + tasksch.HandleTask(task, parentTask, true).Run() + orderList, err := task.GetResult(0) + if err == nil && len(orderList) > 0 { + vendorOrderIDs = make([]string, len(orderList)) + for k, v := range orderList { + orderInfo := v.(*ebaiapi.ListOrderItemInfo) + vendorOrderIDs[k] = orderInfo.OrderID + } + } + return vendorOrderIDs, err +} diff --git a/business/partner/purchase/ebai/order_test.go b/business/partner/purchase/ebai/order_test.go index d39be9df4..d5081c08d 100644 --- a/business/partner/purchase/ebai/order_test.go +++ b/business/partner/purchase/ebai/order_test.go @@ -3,11 +3,22 @@ package ebai import ( "testing" + "git.rosy.net.cn/jx-callback/business/jxutils/jxcontext" + "git.rosy.net.cn/baseapi/utils" ) func TestGetOrder4PartRefund(t *testing.T) { - order, err := new(PurchaseHandler).GetOrder4PartRefund("1556529608021993938") + order, err := CurPurchaseHandler.GetOrder4PartRefund("1556529608021993938") + if err != nil { + t.Fatal(err.Error()) + } else { + t.Log(utils.Format4Output(order, false)) + } +} + +func TestListOrders(t *testing.T) { + order, err := CurPurchaseHandler.ListOrders(jxcontext.AdminCtx, nil, utils.GetCurDate(), utils.DefaultTimeValue, "") if err != nil { t.Fatal(err.Error()) } else { diff --git a/business/partner/purchase/jd/order.go b/business/partner/purchase/jd/order.go index 402d51634..f2cda5a2d 100644 --- a/business/partner/purchase/jd/order.go +++ b/business/partner/purchase/jd/order.go @@ -1,6 +1,7 @@ package jd import ( + "fmt" "strings" "time" @@ -411,3 +412,27 @@ func (c *PurchaseHandler) AdjustOrder(ctx *jxcontext.Context, order *model.Goods } return err } + +func (c *PurchaseHandler) ListOrders(ctx *jxcontext.Context, parentTask tasksch.ITask, queryDate time.Time, vendorStoreID string) (vendorOrderIDs []string, err error) { + if utils.IsTimeZero(queryDate) { + return nil, fmt.Errorf("queryDate必须指定") + } + fromDate := utils.Time2Date(queryDate) + toDate := fromDate.Add(24*time.Hour - 1) + params := map[string]interface{}{ + "orderPurchaseTime_begin": utils.Time2Str(fromDate), + "orderPurchaseTime_end": utils.Time2Str(toDate), + jdapi.KeyPageNo: jdapi.AllPage, + } + if vendorStoreID != "" { + params["deliveryStationNo"] = vendorStoreID + } + orderList, _, err := api.JdAPI.OrderQuery2(params) + if err == nil { + vendorOrderIDs = make([]string, len(orderList)) + for k, v := range orderList { + vendorOrderIDs[k] = utils.Int64ToStr(v.OrderID) + } + } + return vendorOrderIDs, err +} diff --git a/business/partner/purchase/jd/order_test.go b/business/partner/purchase/jd/order_test.go index 64a8ed192..1268fb487 100644 --- a/business/partner/purchase/jd/order_test.go +++ b/business/partner/purchase/jd/order_test.go @@ -2,6 +2,10 @@ package jd import ( "testing" + "time" + + "git.rosy.net.cn/baseapi/utils" + "git.rosy.net.cn/jx-callback/business/jxutils/jxcontext" _ "git.rosy.net.cn/jx-callback/business/jxcallback/orderman" "git.rosy.net.cn/jx-callback/business/model" @@ -17,8 +21,7 @@ func TestSwitch2SelfDeliver(t *testing.T) { orderID := "817540316000041" if order, err := partner.CurOrderManager.LoadOrder(orderID, model.VendorIDJD); err == nil { // globals.SugarLogger.Debug(order) - c := new(PurchaseHandler) - if err = c.Swtich2SelfDeliver(order, ""); err == nil { + if err = curPurchaseHandler.Swtich2SelfDeliver(order, ""); err == nil { } else { t.Fatal(err.Error()) } @@ -28,8 +31,16 @@ func TestSwitch2SelfDeliver(t *testing.T) { } func TestGetOrder(t *testing.T) { - _, err := new(PurchaseHandler).GetOrder("815536199000222") + _, err := curPurchaseHandler.GetOrder("815536199000222") if err != nil { t.Fatal(err.Error()) } } + +func TestListOrders(t *testing.T) { + result, err := curPurchaseHandler.ListOrders(jxcontext.AdminCtx, nil, time.Now(), "") + if err != nil { + t.Fatal(err.Error()) + } + t.Log(utils.Format4Output(result, false)) +} diff --git a/business/partner/purchase/mtwm/order.go b/business/partner/purchase/mtwm/order.go index ef93ca337..d7ec97c45 100644 --- a/business/partner/purchase/mtwm/order.go +++ b/business/partner/purchase/mtwm/order.go @@ -13,6 +13,7 @@ import ( "git.rosy.net.cn/jx-callback/business/jxcallback/scheduler" "git.rosy.net.cn/jx-callback/business/jxutils" "git.rosy.net.cn/jx-callback/business/jxutils/jxcontext" + "git.rosy.net.cn/jx-callback/business/jxutils/tasksch" "git.rosy.net.cn/jx-callback/business/model" "git.rosy.net.cn/jx-callback/business/partner" "git.rosy.net.cn/jx-callback/globals" @@ -525,3 +526,51 @@ func (c *PurchaseHandler) AdjustOrder(ctx *jxcontext.Context, order *model.Goods } return err } + +func (c *PurchaseHandler) ListOrders(ctx *jxcontext.Context, parentTask tasksch.ITask, queryDate time.Time, vendorStoreID string) (vendorOrderIDs []string, err error) { + if utils.IsTimeZero(queryDate) { + return nil, fmt.Errorf("queryDate必须指定") + } + queryDate = utils.Time2Date(queryDate) + + var vendorStoreIDs []string + if vendorStoreID == "" { + vendorStoreIDs, err = api.MtwmAPI.PoiGetIDs() + if err != nil { + return nil, err + } + } else { + vendorStoreIDs = []string{vendorStoreID} + } + task := tasksch.NewParallelTask("mtwm ListOrders", nil, ctx, + func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) { + vendorStoreID := batchItemList[0].(string) + var orderIDs []string + seqStart := 1 + for { + seqEnd := seqStart + mtwmapi.MaxGap4GetOrderIdByDaySeq - 1 + tmpOrderIDs, err2 := api.MtwmAPI.GetOrderIdByDaySeq(vendorStoreID, queryDate, seqStart, seqEnd) + if len(tmpOrderIDs) > 0 { + for _, v := range tmpOrderIDs { + orderIDs = append(orderIDs, utils.Int64ToStr(v)) + } + } + if err = err2; err != nil || len(tmpOrderIDs) == 0 { + err = nil + break + } + seqStart = seqEnd + 1 + } + retVal = orderIDs + return retVal, nil + }, vendorStoreIDs) + tasksch.HandleTask(task, parentTask, true).Run() + orderList, err := task.GetResult(0) + if err == nil && len(orderList) > 0 { + vendorOrderIDs = make([]string, len(orderList)) + for k, v := range orderList { + vendorOrderIDs[k] = v.(string) + } + } + return vendorOrderIDs, err +} diff --git a/business/partner/purchase/mtwm/order_test.go b/business/partner/purchase/mtwm/order_test.go index ced0f03e9..61c5f74a2 100644 --- a/business/partner/purchase/mtwm/order_test.go +++ b/business/partner/purchase/mtwm/order_test.go @@ -2,13 +2,24 @@ package mtwm import ( "testing" + "time" + + "git.rosy.net.cn/jx-callback/business/jxutils/jxcontext" "git.rosy.net.cn/baseapi/utils" _ "git.rosy.net.cn/jx-callback/business/jxcallback/orderman" ) func TestGetOrder(t *testing.T) { - result, err := new(PurchaseHandler).GetOrder("33437032333978492") + result, err := curPurchaseHandler.GetOrder("33437032333978492") + if err != nil { + t.Fatal(err) + } + t.Log(utils.Format4Output(result, false)) +} + +func TestListOrders(t *testing.T) { + result, err := curPurchaseHandler.ListOrders(jxcontext.AdminCtx, nil, time.Now(), "4626746") if err != nil { t.Fatal(err) } diff --git a/controllers/jx_order.go b/controllers/jx_order.go index a574ba8e4..c13bbbe3d 100644 --- a/controllers/jx_order.go +++ b/controllers/jx_order.go @@ -719,4 +719,14 @@ func (c *OrderController) GetStoreAfsOrderCountInfo() { // @Failure 200 {object} controllers.CallResult // @router /AmendMissingOrders [post] func (c *OrderController) AmendMissingOrders() { + c.callAmendMissingOrders(func(params *tOrderAmendMissingOrdersParams) (retVal interface{}, errCode string, err error) { + timeList, err := jxutils.BatchStr2Time(params.FromDate, params.ToDate) + if err == nil { + var vendorIDs []int + if err = jxutils.Strings2Objs(params.VendorIDs, &vendorIDs); err == nil { + retVal, err = orderman.FixedOrderManager.AmendMissingOrders(params.Ctx, vendorIDs, params.StoreID, timeList[0], timeList[1], params.IsAsync, params.IsContinueWhenError) + } + } + return retVal, "", err + }) }