- mtwm sku act ready

business/jxstore/act/act_test.go

@@ -29,7 +29,7 @@ func TestCreateAct(t *testing.T) {
 	actID, err := CreateAct(jxcontext.AdminCtx, &model.Act{
 		Name:            "测试活动",
 		PricePercentage: 80,
-	}, []int{model.VendorIDEBAI}, nil, []*ActStoreSkuParam{
+	}, []int{model.VendorIDJD, model.VendorIDMTWM, model.VendorIDEBAI}, nil, []*ActStoreSkuParam{
 		&ActStoreSkuParam{
 			ActStoreSku: model.ActStoreSku{
 				StoreID: 100884,

business/partner/purchase/ebai/act.go

@@ -80,8 +80,9 @@ func act2EbaiActivity(act *model.Act2, actOrderRules []*model.ActOrderRule) (act
 	return activity
 }
 
-func createOneShopAct(shopID string, activity *ebaiapi.ActivityInfo, oneStoreActSku []*model.ActStoreSku2) (ebaiActIDStr string, err error) {
+func createOneShopAct(act *model.Act2, shopID string, oneStoreActSku []*model.ActStoreSku2) (ebaiActIDStr string, err error) {
 	globals.SugarLogger.Debugf("ebai createOneShopAct")
+	activity := act2EbaiActivity(act, nil)
 	if globals.EnableEbaiStoreWrite {
 		ebaiActID, err := api.EbaiAPI.ActivityCreate(shopID, 0, 0, activity)
 		if err == nil {
@@ -98,6 +99,10 @@ func ActivitySkuAddBatch(activityID int64, shopID string, baiduShopID int64, act
 	globals.SugarLogger.Debugf("ebai ActivitySkuAddBatch")
 	if globals.EnableEbaiStoreWrite {
 		successIDs, err = api.EbaiAPI.ActivitySkuAddBatch(activityID, shopID, baiduShopID, activityType, skuList, isSkuIDCustom)
+	} else {
+		for _, v := range skuList {
+			successIDs = append(successIDs, v.SkuID)
+		}
 	}
 	return successIDs, err
 }
@@ -106,6 +111,8 @@ func ActivitySkuDeleteBatch(activityID int64, shopID string, baiduShopID int64,
 	globals.SugarLogger.Debugf("ebai ActivitySkuDeleteBatch")
 	if globals.EnableEbaiStoreWrite {
 		successIDs, err = api.EbaiAPI.ActivitySkuDeleteBatch(activityID, shopID, baiduShopID, skuIDs, isSkuIDCustom)
+	} else {
+		successIDs = append([]string{}, skuIDs...)
 	}
 	return successIDs, err
 }
@@ -136,13 +143,12 @@ func getActStoreSkuFromTaskResult(taskReslt []interface{}) (list []*model.ActSto
 
 func createSkuAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreSku []*model.ActStoreSku2) (createdList []*model.ActStoreSku2, err error) {
 	globals.SugarLogger.Debugf("ebai createSkuAct")
-	activity := act2EbaiActivity(act, nil)
 	actStoreSkuListList := partner.SplitActStoreSku2List(actStoreSku)
 	task := tasksch.NewParallelTask("ebai createSkuAct", nil, ctx,
 		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			list := batchItemList[0].([]*model.ActStoreSku2)
 			var vendorActID string
-			if vendorActID, err = createOneShopAct(utils.Int2Str(list[0].StoreID), activity, list); err == nil {
+			if vendorActID, err = createOneShopAct(act, utils.Int2Str(list[0].StoreID), list); err == nil {
 				for _, v := range list {
 					v.VendorActID = vendorActID
 				}
@@ -222,8 +228,7 @@ func addSkuActSkus(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.
 						_, err = ActivitySkuAddBatch(utils.Str2Int64(vendorActID), utils.Int2Str(actStoreSkuList[0].StoreID), 0, actType2Ebai(act.Type), list, false)
 					}
 				} else {
-					activity := act2EbaiActivity(act, nil)
+					vendorActID, err = createOneShopAct(act, utils.Int2Str(actStoreSkuList[0].StoreID), actStoreSkuList)
-					vendorActID, err = createOneShopAct(utils.Int2Str(actStoreSkuList[0].StoreID), activity, actStoreSkuList)
 				}
 				if err == nil {
 					for _, v := range actStoreSkuList {

business/partner/purchase/jd/act.go

@@ -24,6 +24,19 @@ type LogicUpdateInfo struct {
 	Condition map[string]interface{}
 }
 
+func splitPromotionSku(skus []*jdapi.PromotionSku, maxCount int) (skusList [][]*jdapi.PromotionSku) {
+	for {
+		skusLen := len(skus)
+		if skusLen <= maxCount {
+			skusList = append(skusList, skus)
+			break
+		}
+		skusList = append(skusList, skus[:maxCount])
+		skus = skus[maxCount:]
+	}
+	return skusList
+}
+
 func CreatePromotionInfos(promotionType int, name string, beginDate, endDate time.Time, outInfoId, advertising, traceId string) (infoId int64, err error) {
 	if globals.EnableJdStoreWrite {
 		if promotionType == model.ActSkuDirectDown {
@@ -50,10 +63,18 @@ func CreatePromotionRules(promotionType int, infoId int64, outInfoId string, lim
 
 func CreatePromotionSku(promotionType int, infoId int64, outInfoId string, skus []*jdapi.PromotionSku, traceId string) (skusResult []*jdapi.PromotionSku, err error) {
 	if globals.EnableJdStoreWrite {
+		for _, batchSkus := range splitPromotionSku(skus, jdapi.MaxPromotionSkuCount) {
+			var tmpSkusResult []*jdapi.PromotionSku
+			var tmpErr error
 			if promotionType == model.ActSkuDirectDown {
-			return api.JdAPI.CreatePromotionSkuSingle(infoId, outInfoId, skus, traceId)
+				tmpSkusResult, tmpErr = api.JdAPI.CreatePromotionSkuSingle(infoId, outInfoId, batchSkus, traceId)
 			} else {
-			return api.JdAPI.CreatePromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
+				tmpSkusResult, tmpErr = api.JdAPI.CreatePromotionSkuLimitTime(infoId, outInfoId, batchSkus, traceId)
+			}
+			if err = tmpErr; err != nil {
+				break
+			}
+			skusResult = append(skusResult, tmpSkusResult...)
 		}
 	}
 	return skusResult, err
@@ -61,10 +82,16 @@ func CreatePromotionSku(promotionType int, infoId int64, outInfoId string, skus
 
 func CancelPromotionSku(promotionType int, infoId int64, outInfoId string, skus []*jdapi.PromotionSku, traceId string) (err error) {
 	if globals.EnableJdStoreWrite {
+		for _, batchSkus := range splitPromotionSku(skus, jdapi.MaxPromotionSkuCount) {
+			var tmpErr error
 			if promotionType == model.ActSkuDirectDown {
-			return api.JdAPI.CancelPromotionSkuSingle(infoId, outInfoId, skus, traceId)
+				tmpErr = api.JdAPI.CancelPromotionSkuSingle(infoId, outInfoId, batchSkus, traceId)
 			} else {
-			return api.JdAPI.CancelPromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
+				tmpErr = api.JdAPI.CancelPromotionSkuLimitTime(infoId, outInfoId, batchSkus, traceId)
+			}
+			if err = tmpErr; err != nil {
+				break
+			}
 		}
 	}
 	return err

business/partner/purchase/mtwm/act.go

@@ -7,6 +7,8 @@ import (
 	"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/model/dao"
+	"git.rosy.net.cn/jx-callback/business/partner"
 	"git.rosy.net.cn/jx-callback/globals"
 	"git.rosy.net.cn/jx-callback/globals/api"
 )
@@ -85,13 +87,107 @@ func createOneShopAct(act *model.Act2, vendorStoreID string, actStoreSku []*mode
 	return err
 }
 
-func cancelOneShopAct(ctx *jxcontext.Context, vendorStoreID string, actStoreSku []*model.ActStoreSku2) (err error) {
+func cancelOneShopAct(ctx *jxcontext.Context, actStoreSku []*model.ActStoreSku2) (err error) {
 	if list := storeSku2ActData4Delete(actStoreSku, model.IsSyncStatusNeedDelete); len(list) > 0 {
-		err = api.MtwmAPI.RetailDiscountDelete(vendorStoreID, list)
+		if globals.EnableMtwmStoreWrite {
+			err = api.MtwmAPI.RetailDiscountDelete(actStoreSku[0].VendorStoreID, list)
+		}
 	}
 	return err
 }
 
-func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
+func getActStoreSkuFromTaskResult(taskReslt []interface{}) (list []*model.ActStoreSku2) {
-	return nil
+	for _, v := range taskReslt {
+		actStoreSkuList := v.([]*model.ActStoreSku2)
+		list = append(list, actStoreSkuList...)
+	}
+	return list
+}
+
+func createSkuAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreSku []*model.ActStoreSku2) (createdList []*model.ActStoreSku2, err error) {
+	globals.SugarLogger.Debugf("mtwm createSkuAct")
+	actStoreSkuListList := partner.SplitActStoreSku2List(actStoreSku)
+	task := tasksch.NewParallelTask("mtwm createSkuAct", nil, ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+			list := batchItemList[0].([]*model.ActStoreSku2)
+			if err = createOneShopAct(act, utils.Int2Str(list[0].StoreID), list); err == nil {
+				retVal = []interface{}{list}
+			}
+			return retVal, err
+		}, actStoreSkuListList)
+	tasksch.HandleTask(task, parentTask, true).Run()
+	result, err := task.GetResult(0)
+	return getActStoreSkuFromTaskResult(result), err
+}
+
+func cancelSkuAct(ctx *jxcontext.Context, parentTask tasksch.ITask, actStoreSku []*model.ActStoreSku2) (canceledList []*model.ActStoreSku2, err error) {
+	globals.SugarLogger.Debugf("mtwm cancelSkuAct")
+	actStoreSkuListList := partner.SplitActStoreSku2List(actStoreSku)
+	task := tasksch.NewParallelTask("mtwm cancelSkuAct", nil, ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+			actStoreSkuList := batchItemList[0].([]*model.ActStoreSku2)
+			if err = cancelOneShopAct(ctx, actStoreSkuList); err == nil {
+				retVal = []interface{}{actStoreSkuList}
+			}
+			return retVal, err
+		}, actStoreSkuListList)
+	tasksch.HandleTask(task, parentTask, true).Run()
+	result, err := task.GetResult(0)
+	return getActStoreSkuFromTaskResult(result), err
+}
+
+func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
+	globals.SugarLogger.Debugf("mtwm SyncAct, actID:%d", act.ID)
+	var actStoreSkuList4Create, actStoreSkuList4Delete []*model.ActStoreSku2
+	var updateItems []*dao.KVUpdateItem
+
+	actStoreSkuMap := partner.SplitActStoreSku(actStoreSkuList)
+	for storeID := range actStoreSkuMap {
+		for _, actStoreSku := range actStoreSkuMap[storeID] {
+			if model.IsSyncStatusNeedCreate(actStoreSku.SyncStatus) {
+				actStoreSkuList4Create = append(actStoreSkuList4Create, actStoreSku)
+			} else if model.IsSyncStatusNeedDelete(actStoreSku.SyncStatus) {
+				actStoreSkuList4Delete = append(actStoreSkuList4Delete, actStoreSku)
+			}
+		}
+	}
+	err = func() (err error) {
+		if model.IsSyncStatusNeedCreate(act.SyncStatus) {
+			createdList, err2 := createSkuAct(ctx, nil, act, actStoreSkuList4Create)
+			updateItems = append(updateItems, partner.ActStoreSku2Update(createdList, model.SyncFlagNewMask)...)
+			if err = err2; err == nil {
+				updateItems = append(updateItems, partner.Act2Update(act, model.SyncFlagNewMask))
+			}
+		} else if model.IsSyncStatusNeedDelete(act.SyncStatus) {
+			canceledList, err2 := cancelSkuAct(ctx, nil, actStoreSkuList)
+			updateItems = append(updateItems, partner.ActStoreSku2Update(canceledList, model.SyncFlagDeletedMask)...)
+			if err = err2; err == nil {
+				updateItems = append(updateItems, partner.Act2Update(act, model.SyncFlagDeletedMask))
+			}
+		} else if model.IsSyncStatusNeedUpdate(act.SyncStatus) {
+			// globals.SugarLogger.Debug(utils.Format4Output(updateItems, false))
+			if len(actStoreSkuList4Create) > 0 {
+				addedList, err2 := createSkuAct(ctx, nil, act, actStoreSkuList4Create)
+				updateItems = append(updateItems, partner.ActStoreSku2Update(addedList, model.SyncFlagNewMask)...)
+				if err = err2; err != nil {
+					return err
+				}
+			}
+			if len(actStoreSkuList4Delete) > 0 {
+				deletedList, err2 := cancelSkuAct(ctx, nil, actStoreSkuList4Delete)
+				updateItems = append(updateItems, partner.ActStoreSku2Update(deletedList, model.SyncFlagDeletedMask)...)
+				if err = err2; err != nil {
+					return err
+				}
+			}
+			updateItems = append(updateItems, partner.Act2Update(act, model.SyncFlagModifiedMask))
+		}
+		return nil
+	}()
+	db := dao.GetDB()
+	_, err2 := dao.BatchUpdateEntityByKV(db, updateItems)
+	if err == nil {
+		err = err2
+	}
+	return err
 }