272 lines
9.8 KiB
Go
272 lines
9.8 KiB
Go
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"
|
|
"git.rosy.net.cn/jx-callback/globals/api"
|
|
|
|
"git.rosy.net.cn/baseapi/platformapi/jdapi"
|
|
"git.rosy.net.cn/baseapi/utils"
|
|
"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"
|
|
)
|
|
|
|
type LogicUpdateInfo struct {
|
|
Item interface{}
|
|
KVs map[string]interface{}
|
|
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 {
|
|
return api.JdAPI.CreatePromotionInfosSingle(name, beginDate, endDate, outInfoId, advertising, traceId)
|
|
} else {
|
|
return api.JdAPI.CreatePromotionInfosLimitTime(name, beginDate, endDate, outInfoId, advertising, traceId)
|
|
}
|
|
} else {
|
|
infoId = jxutils.GenFakeID()
|
|
}
|
|
return infoId, err
|
|
}
|
|
|
|
func CreatePromotionRules(promotionType int, infoId int64, outInfoId string, limitDevice, limitPin, limitCount, limitDaily int, traceId string) (err error) {
|
|
if globals.EnableJdStoreWrite {
|
|
if promotionType == model.ActSkuDirectDown {
|
|
return api.JdAPI.CreatePromotionRulesSingle(infoId, outInfoId, limitDevice, limitPin, limitCount, limitDaily, traceId)
|
|
} else {
|
|
return api.JdAPI.CreatePromotionRulesLimitTime(infoId, outInfoId, limitDevice, limitPin, limitCount, limitDaily, traceId)
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
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 {
|
|
tmpSkusResult, tmpErr = api.JdAPI.CreatePromotionSkuSingle(infoId, outInfoId, batchSkus, traceId)
|
|
} else {
|
|
tmpSkusResult, tmpErr = api.JdAPI.CreatePromotionSkuLimitTime(infoId, outInfoId, batchSkus, traceId)
|
|
}
|
|
if err = tmpErr; err != nil {
|
|
break
|
|
}
|
|
skusResult = append(skusResult, tmpSkusResult...)
|
|
}
|
|
}
|
|
return skusResult, err
|
|
}
|
|
|
|
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 {
|
|
tmpErr = api.JdAPI.CancelPromotionSkuSingle(infoId, outInfoId, batchSkus, traceId)
|
|
} else {
|
|
tmpErr = api.JdAPI.CancelPromotionSkuLimitTime(infoId, outInfoId, batchSkus, traceId)
|
|
}
|
|
if err = tmpErr; err != nil {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func ConfirmPromotion(promotionType int, infoId int64, outInfoId, traceId string) (err error) {
|
|
if globals.EnableJdStoreWrite {
|
|
if promotionType == model.ActSkuDirectDown {
|
|
return api.JdAPI.ConfirmPromotionSingle(infoId, outInfoId, traceId)
|
|
} else {
|
|
return api.JdAPI.ConfirmPromotionLimitTime(infoId, outInfoId, traceId)
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func CancelPromotion(promotionType int, infoId int64, outInfoId, traceId string) (err error) {
|
|
if globals.EnableJdStoreWrite {
|
|
if promotionType == model.ActSkuDirectDown {
|
|
return api.JdAPI.CancelPromotionSingle(infoId, outInfoId, traceId)
|
|
} else {
|
|
return api.JdAPI.CancelPromotionLimitTime(infoId, outInfoId, traceId)
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func AdjustPromotionTime(promotionType int, infoId int64, outInfoId string, endDate time.Time, traceId string) (err error) {
|
|
if globals.EnableJdStoreWrite {
|
|
if promotionType == model.ActSkuDirectDown {
|
|
return api.JdAPI.AdjustPromotionTimeSingle(infoId, outInfoId, endDate, traceId)
|
|
} else {
|
|
return api.JdAPI.AdjustPromotionTimeLimitTime(infoId, outInfoId, endDate, traceId)
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func AdjustPromotionSku(promotionType int, infoId int64, outInfoId string, skus []*jdapi.PromotionSku, traceId string) (skusResult []*jdapi.PromotionSku, err error) {
|
|
if globals.EnableJdStoreWrite {
|
|
if promotionType == model.ActSkuDirectDown {
|
|
return api.JdAPI.AdjustPromotionSkuSingle(infoId, outInfoId, skus, traceId)
|
|
} else {
|
|
return api.JdAPI.AdjustPromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
|
|
}
|
|
}
|
|
return skusResult, err
|
|
}
|
|
|
|
func storeSku2Jd(actStoreSku []*model.ActStoreSku2, handler func(syncStatus int) bool) (jdActStoreSku []*jdapi.PromotionSku) {
|
|
for _, v := range actStoreSku {
|
|
if handler(v.SyncStatus) {
|
|
jdActStoreSku = append(jdActStoreSku, &jdapi.PromotionSku{
|
|
StationNo: utils.Str2Int64(v.VendorStoreID),
|
|
SkuID: utils.Str2Int64(v.VendorSkuID),
|
|
PromotionPrice: v.ActualActPrice,
|
|
LimitSkuCount: v.Stock,
|
|
})
|
|
}
|
|
}
|
|
return jdActStoreSku
|
|
}
|
|
|
|
func createSkuAct(ctx *jxcontext.Context, act *model.Act2, actStoreSku []*model.ActStoreSku2) (vendorActID string, err error) {
|
|
traceID := ctx.GetAccessUUID()
|
|
outInfoID := ""
|
|
if act.VendorActID == "" {
|
|
outInfoID = utils.Int2Str(act.ID)
|
|
}
|
|
infoID, err2 := CreatePromotionInfos(act.Type, act.GetRealActName(), act.BeginAt, act.EndAt, outInfoID, act.Advertising, traceID)
|
|
if err = err2; err == nil {
|
|
vendorActID = utils.Int64ToStr(infoID)
|
|
if err = CreatePromotionRules(act.Type, infoID, "", 0, act.LimitUser, 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
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return vendorActID, err
|
|
}
|
|
|
|
func cancelSkuActSkus(ctx *jxcontext.Context, actType int, vendorActID string, actStoreSku []*model.ActStoreSku2) (err error) {
|
|
if vendorActID != "" {
|
|
if skuList := storeSku2Jd(actStoreSku, model.IsSyncStatusNeedDelete); len(skuList) > 0 {
|
|
err = CancelPromotionSku(actType, utils.Str2Int64(vendorActID), "", skuList, ctx.GetAccessUUID())
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func cancelSkuAct(ctx *jxcontext.Context, actType int, vendorActID string) (err error) {
|
|
if vendorActID != "" {
|
|
err = CancelPromotion(actType, utils.Str2Int64(vendorActID), "", ctx.GetAccessUUID())
|
|
}
|
|
return 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("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.IsSyncStatusDelete(actStoreSku.SyncStatus) {
|
|
vendorActID := actStoreSku.VendorActID
|
|
if vendorActID == "" {
|
|
vendorActID = act.VendorActID
|
|
}
|
|
deleteActInfoMap[vendorActID] = append(deleteActInfoMap[vendorActID], actStoreSku)
|
|
} else if model.IsSyncStatusNew(actStoreSku.SyncStatus) {
|
|
actStoreSkuList4Create = append(actStoreSkuList4Create, actStoreSku)
|
|
}
|
|
}
|
|
}
|
|
err = func() (err error) {
|
|
if model.IsSyncStatusDelete(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.IsSyncStatusNew(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.IsSyncStatusUpdate(act.SyncStatus) {
|
|
// globals.SugarLogger.Debug(utils.Format4Output(updateItems, false))
|
|
if len(actStoreSkuList4Create) > 0 {
|
|
if _, err = createSkuAct(ctx, act, actStoreSkuList4Create); err != nil {
|
|
return err
|
|
}
|
|
updateItems = append(updateItems, partner.ActStoreSku2Update(actStoreSkuList4Create, model.SyncFlagNewMask)...)
|
|
}
|
|
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 err == nil {
|
|
updateItems = append(updateItems, partner.Act2Update(act, model.SyncFlagModifiedMask))
|
|
}
|
|
}
|
|
return err
|
|
}()
|
|
db := dao.GetDB()
|
|
// globals.SugarLogger.Debug(utils.Format4Output(updateItems, false))
|
|
_, err2 := dao.BatchUpdateEntityByKV(db, updateItems)
|
|
if err == nil {
|
|
err = err2
|
|
}
|
|
return err
|
|
}
|