liulei/jx-callback
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'mark' into get-store

Browse Source
This commit is contained in:
gazebo
2019-06-24 21:43:41 +08:00
parent dd92bb99f5 594aa3e6b7
commit fc5c7ae609
33 changed files with 1229 additions and 766 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
business/partner/partner.go
View File

@@ -172,7 +172,7 @@ type IStoreManager interface {
// 所有非以Sync，Refresh开头的函数不用自己清理sync_status标记（VendorSync统一处理）
type IPurchasePlatformHandler interface {
IPurchasePlatformPromotionHandler
IPurchasePlatformActHandler
GetVendorID() int
GetStatusFromVendorStatus(vendorStatus string) int

79
business/partner/partner_act.go
View File

@@ -1,24 +1,83 @@
package partner
import (
"time"
"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"
)
type IPurchasePlatformPromotionHandler interface {
// 如果是单品级活动，actOrderRules为空
// 如果是订单级活动，actStoreSku可以为空（表示不限制SKU）
CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error)
UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error)
// 取消整个京西活动
CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error)
type IPurchasePlatformActHandler interface {
// // 如果是单品级活动，actOrderRules为空
// // 如果是订单级活动，actStoreSku可以为空（表示不限制SKU）
// CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error)
// UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error)
// // 取消整个京西活动
// CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreSku []*model.ActStoreSku2) (err error)
SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error)
}
func ActStoreSku2Map(actStoreSku []*model.ActStoreSku2) (actStoreSkuMap map[int][]*model.ActStoreSku2) {
func SplitActStoreSku(actStoreSkuList []*model.ActStoreSku2) (actStoreSkuMap map[int][]*model.ActStoreSku2) {
actStoreSkuMap = make(map[int][]*model.ActStoreSku2)
for _, storeSku := range actStoreSku {
actStoreSkuMap[storeSku.StoreID] = append(actStoreSkuMap[storeSku.StoreID], storeSku)
for _, v := range actStoreSkuList {
actStoreSkuMap[v.StoreID] = append(actStoreSkuMap[v.StoreID], v)
}
return actStoreSkuMap
}
func SplitActStoreSku2List(actStoreSkuList []*model.ActStoreSku2) (actStoreSkuListList [][]*model.ActStoreSku2) {
actStoreSkuMap := SplitActStoreSku(actStoreSkuList)
for _, v := range actStoreSkuMap {
actStoreSkuListList = append(actStoreSkuListList, v)
}
return actStoreSkuListList
}
func Act2ActMap(act *model.Act2) (actMap *model.ActMap) {
actMap = &model.ActMap{}
actMap.ID = act.MapID
return actMap
}
func ActStoreSku2ActStoreSkuMap(actStoreSku *model.ActStoreSku2) (actStoreSkuMap *model.ActStoreSkuMap) {
actStoreSkuMap = &model.ActStoreSkuMap{}
actStoreSkuMap.ID = actStoreSku.MapID
return actStoreSkuMap
}
func Act2Update(act *model.Act2, syncStatus int) (item *dao.KVUpdateItem) {
kvs := map[string]interface{}{
model.FieldSyncStatus: 0,
}
if syncStatus == model.SyncFlagDeletedMask {
kvs[model.FieldDeletedAt] = time.Now()
} else if syncStatus == model.SyncFlagNewMask {
kvs[model.FieldVendorActID] = act.VendorActID
}
item = &dao.KVUpdateItem{
Item: Act2ActMap(act),
KVs: kvs,
}
return item
}
func ActStoreSku2Update(actStoreSkuList []*model.ActStoreSku2, syncStatus int) (items []*dao.KVUpdateItem) {
for _, v := range actStoreSkuList {
kvs := map[string]interface{}{
model.FieldSyncStatus: 0,
}
if syncStatus == model.SyncFlagDeletedMask {
kvs[model.FieldDeletedAt] = time.Now()
} else if syncStatus == model.SyncFlagNewMask {
kvs[model.FieldVendorActID] = v.VendorActID
}
items = append(items, &dao.KVUpdateItem{
Item: ActStoreSku2ActStoreSkuMap(v),
KVs: kvs,
})
}
return items
}

118
business/partner/purchase/ebai/act.go
View File

@@ -102,16 +102,20 @@ func ActivitySkuUpdateBatch(activityID int64, actSkuInfoList []*ebaiapi.Activity
return api.EbaiAPI.ActivitySkuUpdateBatch(activityID, actSkuInfoList)
}
func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error) {
activity := act2EbaiActivity(act, actOrderRules)
if act.Type < model.ActOrderBegin {
actStoreSkuMap := partner.ActStoreSku2Map(actStoreSku)
actStoreSkuListList := partner.SplitActStoreSku2List(actStoreSku)
task := tasksch.NewParallelTask("ebai CreateAct", nil, ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
store := batchItemList[0].(*model.ActStore2)
store.VendorActID, err = createOneShopAct(utils.Int2Str(store.StoreID), activity, actStoreSkuMap[store.StoreID])
list := batchItemList[0].([]*model.ActStoreSku2)
var vendorActID string
vendorActID, err = createOneShopAct(utils.Int2Str(list[0].StoreID), activity, list)
for _, v := range list {
v.VendorActID = vendorActID
}
return nil, err
}, actStoreMap)
}, actStoreSkuListList)
tasksch.HandleTask(task, parentTask, true).Run()
_, err = task.GetResult(0)
} else {
@@ -120,67 +124,55 @@ func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.I
return err
}
func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
if act.Type < model.ActOrderBegin {
actStoreSkuMap := partner.ActStoreSku2Map(actStoreSku)
if len(actStoreMap2Remove) > 0 {
if err = c.CancelAct(ctx, parentTask, act, actStoreMap2Remove, nil); err != nil {
return err
}
for _, v := range actStoreMap2Remove {
delete(actStoreSkuMap, v.StoreID)
}
}
if len(actStoreMap2Add) > 0 {
if err = c.CreateAct(ctx, parentTask, act, actOrderRules, actStoreMap2Add, actStoreSku); err != nil {
return err
}
for _, v := range actStoreMap2Add {
delete(actStoreSkuMap, v.StoreID)
}
}
task := tasksch.NewParallelTask("ebai UpdateAct", nil, ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
v := batchItemList[0].(*model.ActStore2)
if storeSkus := actStoreSkuMap[v.StoreID]; storeSkus != nil {
if list := actStoreSu2Ebai4Delete(storeSkus); len(list) > 0 {
if _, err = ActivitySkuDeleteBatch(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, list, false); err != nil {
return nil, err
}
}
if list := actStoreSu2Ebai4Add(storeSkus); len(list) > 0 {
if _, err = ActivitySkuAddBatch(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, actType2Ebai(act.Type), list, false); err != nil {
return nil, err
}
}
if list := actStoreSu2Ebai4Update(storeSkus); len(list) > 0 {
if _, err = ActivitySkuUpdateBatch(utils.Str2Int64(v.VendorActID), list); err != nil {
return nil, err
}
}
}
return nil, err
}, actStoreMap2Update)
tasksch.HandleTask(task, parentTask, true).Run()
_, err = task.GetResult(0)
} else {
func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error) {
// if act.Type < model.ActOrderBegin {
// actStoreSkuMap := partner.SplitActStoreSku(actStoreSku)
// task := tasksch.NewParallelTask("ebai UpdateAct", nil, ctx,
// func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
// v := batchItemList[0].(*model.ActStore2)
// if storeSkus := actStoreSkuMap[v.StoreID]; storeSkus != nil {
// if list := actStoreSu2Ebai4Delete(storeSkus); len(list) > 0 {
// if _, err = ActivitySkuDeleteBatch(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, list, false); err != nil {
// return nil, err
// }
// }
// if list := actStoreSu2Ebai4Add(storeSkus); len(list) > 0 {
// if _, err = ActivitySkuAddBatch(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, actType2Ebai(act.Type), list, false); err != nil {
// return nil, err
// }
// }
// if list := actStoreSu2Ebai4Update(storeSkus); len(list) > 0 {
// if _, err = ActivitySkuUpdateBatch(utils.Str2Int64(v.VendorActID), list); err != nil {
// return nil, err
// }
// }
// }
// return nil, err
// }, actStoreMap2Update)
// tasksch.HandleTask(task, parentTask, true).Run()
// _, err = task.GetResult(0)
// } else {
}
// }
return err
}
func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
if act.Type < model.ActOrderBegin {
task := tasksch.NewParallelTask("ebai DeleteAct", nil, ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
v := batchItemList[0].(*model.ActStore2)
if globals.EnableEbaiStoreWrite {
err = api.EbaiAPI.ActivityDisable(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, 0)
}
return nil, err
}, actStoreMap)
tasksch.HandleTask(task, parentTask, true).Run()
_, err = task.GetResult(0)
}
func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreSku []*model.ActStoreSku2) (err error) {
// if act.Type < model.ActOrderBegin {
// task := tasksch.NewParallelTask("ebai DeleteAct", nil, ctx,
// func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
// v := batchItemList[0].(*model.ActStore2)
// if globals.EnableEbaiStoreWrite {
// err = api.EbaiAPI.ActivityDisable(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, 0)
// }
// return nil, err
// }, actStoreMap)
// tasksch.HandleTask(task, parentTask, true).Run()
// _, err = task.GetResult(0)
// }
return err
}
func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
return nil
}

6
business/partner/purchase/ebai/store_sku.go
View File

@@ -496,9 +496,9 @@ func genSkuParamsFromStoreSkuInfo(storeSku *tStoreSkuFullInfo) (params map[strin
params["status"] = jxSkuStatus2Ebai(jxutils.MergeSkuStatus(storeSku.SkuStatus, storeSku.Status))
}
// todo 饿百如果给的UPC是空要报错，但如果我要删除UPC怎么弄？
if storeSku.Upc != "" {
params["upc"] = storeSku.Upc
}
// if storeSku.Upc != "" {
// params["upc"] = storeSku.Upc
// }
return params
}

12
business/partner/purchase/elm/act.go
View File

@@ -6,14 +6,6 @@ import (
"git.rosy.net.cn/jx-callback/business/model"
)
func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
return err
}
func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
return err
}
func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
return err
func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
return nil
}

158
business/partner/purchase/jd/act.go
View File

@@ -3,6 +3,9 @@ package jd
import (
"time"
"git.rosy.net.cn/jx-callback/business/model/dao"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/business/jxutils"
"git.rosy.net.cn/jx-callback/globals"
@@ -15,6 +18,12 @@ import (
"git.rosy.net.cn/jx-callback/business/model"
)
type LogicUpdateInfo struct {
Item interface{}
KVs map[string]interface{}
Condition map[string]interface{}
}
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 {
@@ -124,60 +133,131 @@ func storeSku2Jd(actStoreSku []*model.ActStoreSku2, handler func(syncStatus int)
return jdActStoreSku
}
func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
traceID := getTraceID(ctx)
func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error) {
if act.Type < model.ActOrderBegin {
outInfoID := utils.Int2Str(act.ID)
infoID, err2 := CreatePromotionInfos(act.Type, act.Name, act.BeginAt, act.EndAt, outInfoID, act.Advertising, traceID)
if err = err2; err == nil {
act.VendorActID = utils.Int64ToStr(infoID)
if err = CreatePromotionRules(act.Type, infoID, "", act.LimitDevice, act.LimitPin, act.LimitCount, act.LimitDaily, traceID); err == nil {
if _, err = CreatePromotionSku(act.Type, infoID, "", storeSku2Jd(actStoreSku, model.IsSyncStatusNeedCreate), traceID); err == nil {
err = ConfirmPromotion(act.Type, infoID, "", traceID)
act.VendorActID, err = createSkuAct(ctx, act, actStoreSku)
} else {
}
return err
}
func createSkuAct(ctx *jxcontext.Context, act *model.Act2, actStoreSku []*model.ActStoreSku2) (vendorActID string, err error) {
traceID := getTraceID(ctx)
outInfoID := ""
if act.VendorActID == "" {
outInfoID = utils.Int2Str(act.ID)
}
infoID, err2 := CreatePromotionInfos(act.Type, act.Name, act.BeginAt, act.EndAt, outInfoID, act.Advertising, traceID)
if err = err2; err == nil {
vendorActID = utils.Int64ToStr(infoID)
if err = CreatePromotionRules(act.Type, infoID, "", act.LimitDevice, act.LimitPin, act.LimitCount, act.LimitDaily, traceID); err == nil {
if _, err = CreatePromotionSku(act.Type, infoID, "", storeSku2Jd(actStoreSku, model.IsSyncStatusNeedCreate), traceID); err == nil {
if err = ConfirmPromotion(act.Type, infoID, "", traceID); err == nil {
for _, v := range actStoreSku {
v.VendorActID = vendorActID
}
}
}
}
} else {
}
return vendorActID, err
}
func cancelSkuActSkus(ctx *jxcontext.Context, actType int, vendorActID string, actStoreSku []*model.ActStoreSku2) (err error) {
if skuList := storeSku2Jd(actStoreSku, model.IsSyncStatusNeedDelete); len(skuList) > 0 {
err = CancelPromotionSku(actType, utils.Str2Int64(vendorActID), "", skuList, getTraceID(ctx))
}
return err
}
func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
traceID := getTraceID(ctx)
func cancelSkuAct(ctx *jxcontext.Context, actType int, vendorActID string) (err error) {
err = CancelPromotion(actType, utils.Str2Int64(vendorActID), "", getTraceID(ctx))
return err
}
func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error) {
return err
}
func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreSku []*model.ActStoreSku2) (err error) {
if act.Type < model.ActOrderBegin {
outInfoID := utils.Int2Str(act.ID)
if !utils.IsTimeZero(act.EndAt) {
if err = AdjustPromotionTime(act.Type, 0, outInfoID, act.EndAt, traceID); err != nil {
return err
}
}
if toBeDeleted := storeSku2Jd(actStoreSku, model.IsSyncStatusNeedDelete); len(toBeDeleted) > 0 {
if err = CancelPromotionSku(act.Type, 0, outInfoID, toBeDeleted, traceID); err != nil {
return err
}
}
// if toBeAdded := storeSku2Jd(actStoreSku, model.IsSyncStatusNeedDelete); len(toBeAdded) > 0 {
// if _, err = CreatePromotionSku(act.Type, 0, outInfoID, toBeAdded, traceID); err != nil {
// return err
// }
// }
// if toBeUpdated := storeSku2Jd(actStoreSku, model.IsSyncStatusNeedDelete); len(toBeUpdated) > 0 {
// if _, err = AdjustPromotionSku(act.Type, 0, outInfoID, toBeUpdated, traceID); err != nil {
// return err
// }
// }
} else {
err = CancelPromotion(act.Type, 0, outInfoID, getTraceID(ctx))
}
return err
}
func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
traceID := getTraceID(ctx)
if act.Type < model.ActOrderBegin {
outInfoID := utils.Int2Str(act.ID)
err = CancelPromotion(act.Type, 0, outInfoID, traceID)
func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
globals.SugarLogger.Debugf("jd SyncAct, actID:%d", act.ID)
vendorActInfoMap := make(map[string][]*model.ActStoreSku2)
deleteActInfoMap := make(map[string][]*model.ActStoreSku2)
var actStoreSkuList4Create []*model.ActStoreSku2
var updateItems []*dao.KVUpdateItem
actStoreSkuMap := partner.SplitActStoreSku(actStoreSkuList)
for storeID := range actStoreSkuMap {
for _, actStoreSku := range actStoreSkuMap[storeID] {
vendorActInfoMap[actStoreSku.VendorActID] = append(vendorActInfoMap[actStoreSku.VendorActID], actStoreSku)
if model.IsSyncStatusNeedCreate(actStoreSku.SyncStatus) {
actStoreSkuList4Create = append(actStoreSkuList4Create, actStoreSku)
} else if model.IsSyncStatusNeedDelete(actStoreSku.SyncStatus) {
vendorActID := actStoreSku.VendorActID
if vendorActID == "" {
vendorActID = act.VendorActID
}
deleteActInfoMap[vendorActID] = append(deleteActInfoMap[vendorActID], actStoreSku)
}
}
}
err = func() (err error) {
if model.IsSyncStatusNeedCreate(act.SyncStatus) {
if act.VendorActID, err = createSkuAct(ctx, act, actStoreSkuList4Create); err != nil {
return err
}
updateItems = append(updateItems, partner.ActStoreSku2Update(actStoreSkuList4Create, model.SyncFlagNewMask)...)
updateItems = append(updateItems, partner.Act2Update(act, model.SyncFlagNewMask))
} else if model.IsSyncStatusNeedDelete(act.SyncStatus) {
for vendorActID := range vendorActInfoMap {
if vendorActID != "" {
if err = cancelSkuAct(ctx, act.Type, vendorActID); err != nil {
return err
}
}
}
for _, actStoreSkuList := range vendorActInfoMap {
updateItems = append(updateItems, partner.ActStoreSku2Update(actStoreSkuList, model.SyncFlagDeletedMask)...)
}
updateItems = append(updateItems, partner.Act2Update(act, model.SyncFlagDeletedMask))
} else if model.IsSyncStatusNeedUpdate(act.SyncStatus) {
// globals.SugarLogger.Debug(utils.Format4Output(updateItems, false))
for vendorActID := range deleteActInfoMap {
if vendorActID != "" {
if len(vendorActInfoMap[vendorActID]) == len(deleteActInfoMap[vendorActID]) {
err = cancelSkuAct(ctx, act.Type, vendorActID)
} else {
err = cancelSkuActSkus(ctx, act.Type, vendorActID, deleteActInfoMap[vendorActID])
}
if err != nil {
return err
}
}
updateItems = append(updateItems, partner.ActStoreSku2Update(deleteActInfoMap[vendorActID], model.SyncFlagDeletedMask)...)
}
if len(actStoreSkuList4Create) > 0 {
if _, err = createSkuAct(ctx, act, actStoreSkuList4Create); err != nil {
return err
}
updateItems = append(updateItems, partner.ActStoreSku2Update(actStoreSkuList4Create, model.SyncFlagNewMask)...)
}
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
}

28
business/partner/purchase/jd/order.go
View File

@@ -43,6 +43,21 @@ func (c *PurchaseHandler) OnOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi
return retVal
}
func (c *PurchaseHandler) updateOrderFinancialInfo(orderID string) (err error) {
order := &model.GoodsOrder{
VendorOrderID: orderID,
VendorID: model.VendorIDJD,
}
orderSettlement, err := api.JdAPI.OrderShoudSettlementService2(orderID)
if err == nil {
if orderSettlement != nil {
updateOrderBySettleMent(order, orderSettlement)
err = partner.CurOrderManager.UpdateOrderFields(order, []string{"TotalShopMoney", "PmSubsidyMoney"})
}
}
return err
}
func (c *PurchaseHandler) onOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
status := c.callbackMsg2Status(msg)
if jdapi.StatusIDNewOrder == msg.StatusID {
@@ -53,6 +68,7 @@ func (c *PurchaseHandler) onOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi
}
if msg.MsgURL == jdapi.CallbackMsgOrderAccounting {
retVal = c.OnFinancialMsg(msg)
retVal = jdapi.Err2CallbackResponse(c.updateOrderFinancialInfo(msg.BillID), status.VendorStatus)
} else if msg.MsgURL == jdapi.CallbackMsgAfterSaleBillStatus {
retVal = c.OnAfsOrderMsg(msg)
} else {
@@ -77,6 +93,13 @@ func (c *PurchaseHandler) onOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi
return retVal
}
func updateOrderBySettleMent(order *model.GoodsOrder, orderSettlement *jdapi.OrderSettlementInfo) {
if orderSettlement != nil {
order.TotalShopMoney = orderSettlement.SettlementAmount
order.PmSubsidyMoney = orderSettlement.PlatOrderGoodsDiscountMoney + orderSettlement.PlatSkuGoodsDiscountMoney
}
}
func (c *PurchaseHandler) getOrder(orderID string) (order *model.GoodsOrder, orderMap map[string]interface{}, err error) {
globals.SugarLogger.Debugf("jd getOrder orderID:%s", orderID)
var (
@@ -104,10 +127,7 @@ func (c *PurchaseHandler) getOrder(orderID string) (order *model.GoodsOrder, ord
task.Run()
task.GetResult(0)
if order != nil {
if orderSettlement != nil {
order.TotalShopMoney = orderSettlement.SettlementAmount
order.PmSubsidyMoney = orderSettlement.PlatOrderGoodsDiscountMoney + orderSettlement.PlatSkuGoodsDiscountMoney
}
updateOrderBySettleMent(order, orderSettlement)
}
// if orderMap, err = api.JdAPI.QuerySingleOrder(orderID); err == nil {
// globals.SugarLogger.Debugf("jd getOrder2 orderID:%s", orderID)

3
business/partner/purchase/jd/order_afs.go
View File

@@ -70,6 +70,9 @@ func (c *PurchaseHandler) onAfsOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jd
afsInfo, err := api.JdAPI.GetAfsService2(msg.BillID)
if err == nil {
status := c.callbackAfsMsg2Status(msg, afsInfo)
if partner.CurOrderManager.GetStatusDuplicatedCount(status) > 0 {
return nil
}
if status.Status == model.AfsOrderStatusWait4Approve || status.Status == model.AfsOrderStatusNew {
afsOrder := c.buildAfsOrder(afsInfo)
err = partner.CurOrderManager.OnAfsOrderNew(afsOrder, status)

24
business/partner/purchase/jd/store.go
View File

@@ -304,17 +304,17 @@ func (p *PurchaseHandler) GetStoreStatus(ctx *jxcontext.Context, vendorStoreID s
// 当前京东的storeCrud消息不会在门店状态改变时发送，所以意义不大，先放在这里
func (c *PurchaseHandler) OnStoreMsg(msg *jdapi.CallbackOrderMsg) (response *jdapi.CallbackResponse) {
var err error
if msg.StatusID == jdapi.StatusIDUpdateStore {
var storeStatus int
vendorStoreID := msg.BillID
if storeStatus, err = c.GetStoreStatus(jxcontext.AdminCtx, vendorStoreID); err == nil {
err = partner.CurStoreManager.OnStoreStatusChanged(vendorStoreID, model.VendorIDJD, storeStatus)
} else {
// 可能在门店删除的情况下会出查不到门店的错误
if errExt, ok := err.(*utils.ErrorWithCode); ok && errExt.IntCode() == 4 {
err = nil
}
}
}
// if msg.StatusID == jdapi.StatusIDUpdateStore {
// var storeStatus int
// vendorStoreID := msg.BillID
// if storeStatus, err = c.GetStoreStatus(jxcontext.AdminCtx, vendorStoreID); err == nil {
// err = partner.CurStoreManager.OnStoreStatusChanged(vendorStoreID, model.VendorIDJD, storeStatus)
// } else {
// // 可能在门店删除的情况下会出查不到门店的错误
// if errExt, ok := err.(*utils.ErrorWithCode); ok && errExt.IntCode() == 4 {
// err = nil
// }
// }
// }
return jdapi.Err2CallbackResponse(err, "")
}

86
business/partner/purchase/mtwm/act.go
View File

@@ -7,7 +7,6 @@ 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/partner"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/globals/api"
)
@@ -60,11 +59,11 @@ func isCreateOrUpdate(syncStatus int) bool {
return model.IsSyncStatusNeedCreate(syncStatus) || model.IsSyncStatusNeedUpdate(syncStatus)
}
func createOneShopAct(act *model.Act2, storeMap *model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
func createOneShopAct(act *model.Act2, vendorStoreID string, actStoreSku []*model.ActStoreSku2) (err error) {
actData := storeSku2ActData(act, actStoreSku, isCreateOrUpdate)
if len(actData) > 0 {
if globals.EnableMtwmStoreWrite {
actResult, err2 := api.MtwmAPI.RetailDiscountBatchSave(storeMap.VendorStoreID, actData)
actResult, err2 := api.MtwmAPI.RetailDiscountBatchSave(vendorStoreID, actData)
if err = err2; err != nil {
return err
}
@@ -86,84 +85,13 @@ func createOneShopAct(act *model.Act2, storeMap *model.ActStore2, actStoreSku []
return err
}
func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
globals.SugarLogger.Debugf("mtwm CreateAct actID:%d", act.ID)
if act.Type < model.ActOrderBegin {
actStoreSkuMap := partner.ActStoreSku2Map(actStoreSku)
task := tasksch.NewParallelTask("mtwm CreateAct", nil, ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
store := batchItemList[0].(*model.ActStore2)
err = createOneShopAct(act, store, actStoreSkuMap[store.StoreID])
return nil, err
}, actStoreMap)
tasksch.HandleTask(task, parentTask, true).Run()
_, err = task.GetResult(0)
} else {
func cancelOneShopAct(ctx *jxcontext.Context, vendorStoreID string, actStoreSku []*model.ActStoreSku2) (err error) {
if list := storeSku2ActData4Delete(actStoreSku, model.IsSyncStatusNeedDelete); len(list) > 0 {
err = api.MtwmAPI.RetailDiscountDelete(vendorStoreID, list)
}
return err
}
func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
if act.Type < model.ActOrderBegin {
actStoreSkuMap := partner.ActStoreSku2Map(actStoreSku)
if len(actStoreMap2Remove) > 0 {
if err = c.CancelAct(ctx, parentTask, act, actStoreMap2Remove, nil); err != nil {
return err
}
for _, v := range actStoreMap2Remove {
delete(actStoreSkuMap, v.StoreID)
}
}
if len(actStoreMap2Add) > 0 {
if err = c.CreateAct(ctx, parentTask, act, actOrderRules, actStoreMap2Add, actStoreSku); err != nil {
return err
}
for _, v := range actStoreMap2Add {
delete(actStoreSkuMap, v.StoreID)
}
}
task := tasksch.NewParallelTask("mtwm UpdateAct", nil, ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
v := batchItemList[0].(*model.ActStore2)
if storeSkus := actStoreSkuMap[v.StoreID]; storeSkus != nil {
if list := storeSku2ActData4Delete(storeSkus, model.IsSyncStatusNeedDelete); len(list) > 0 {
if err = api.MtwmAPI.RetailDiscountDelete(v.VendorStoreID, list); err != nil {
return nil, err
}
}
if err = createOneShopAct(act, v, actStoreSkuMap[v.StoreID]); err != nil {
return nil, err
}
}
return nil, err
}, actStoreMap2Update)
tasksch.HandleTask(task, parentTask, true).Run()
_, err = task.GetResult(0)
} else {
}
return err
}
func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
if act.Type < model.ActOrderBegin {
actStoreSkuMap := partner.ActStoreSku2Map(actStoreSku)
task := tasksch.NewParallelTask("mtwm DeleteAct", nil, ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
v := batchItemList[0].(*model.ActStore2)
actIDList := storeSku2ActData4Delete(actStoreSkuMap[v.StoreID], nil)
if len(actIDList) > 0 {
if globals.EnableMtwmStoreWrite {
err = api.MtwmAPI.RetailDiscountDelete(v.VendorStoreID, actIDList)
}
}
return nil, err
}, actStoreMap)
tasksch.HandleTask(task, parentTask, true).Run()
_, err = task.GetResult(0)
} else {
}
return err
func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
return nil
}

12
business/partner/purchase/weimob/wsc/act.go
View File

@@ -6,14 +6,6 @@ import (
"git.rosy.net.cn/jx-callback/business/model"
)
func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
return err
}
func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
return err
}
func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
return err
func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
return nil
}