+ partner.ListOrders

+ AmendMissingOrders

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
+}

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.*,

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)

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
+}

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 {

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
+}

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 = curPurchaseHandler.Swtich2SelfDeliver(order, ""); err == nil {
-		if err = c.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))
+}

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
+}

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)
 	}

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
+	})
 }