1112 lines
37 KiB
Go
1112 lines
37 KiB
Go
package promotion
|
||
|
||
import (
|
||
"encoding/gob"
|
||
"errors"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
"git.rosy.net.cn/baseapi/platformapi/jdapi"
|
||
"git.rosy.net.cn/baseapi/utils"
|
||
"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/storeskulock"
|
||
"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/globals"
|
||
"git.rosy.net.cn/jx-callback/globals/api"
|
||
)
|
||
|
||
const (
|
||
PromotionTypeNormal = 1
|
||
PromotionTypeDirectDown = 3
|
||
PromotionTypeLimitedTime = 4
|
||
)
|
||
|
||
const (
|
||
PriceTypePrice = 1 // 绝对价格
|
||
PriceTypePercentage = 2 // 百分比
|
||
)
|
||
|
||
const (
|
||
PromotionLimitedTimeMinPercentage = 79
|
||
)
|
||
|
||
const (
|
||
colSkuIDIndex = 0
|
||
colSkuPriceIndex = 3
|
||
colNameIndex = 5
|
||
colStoreIDIndex = 6
|
||
colBeginAtIndex = 9
|
||
colEndAtIndex = 10
|
||
)
|
||
|
||
const (
|
||
DefaultLimitSkuCount = 100
|
||
MaxPromotionSkuCount = jdapi.MaxPromotionSkuCount
|
||
)
|
||
|
||
const (
|
||
defSearchDays = 7
|
||
stockRefreshGap = 5 * time.Minute
|
||
userName = "jdpromotion"
|
||
)
|
||
|
||
const (
|
||
keyPromotionSource = "promotionSource"
|
||
keyPromotionStatus = "promotionStatus"
|
||
keyLimitDevice = "limitDevice"
|
||
keyLimitPin = "limitPin"
|
||
keyLimitCount = "limitCount"
|
||
keyLimitDaily = "limitDaily"
|
||
)
|
||
const (
|
||
PromotionSourceOpenPlatform = "开放平台"
|
||
)
|
||
|
||
type SkuPrice struct {
|
||
SkuID int `json:"skuID"`
|
||
PriceType int `json:"priceType"`
|
||
Price int `json:"price"` // 分，这个不是单价，是这个sku的活动价
|
||
LimitSkuCount int `json:"limitSkuCount"`
|
||
IsLock int8 `json:"isLock"`
|
||
|
||
EarningPrice int `json:"earningPrice"` // 活动商品设置，结算给门店老板的钱
|
||
}
|
||
|
||
type tPromotionItemInfo struct {
|
||
SkuID int `orm:"column(sku_id)"`
|
||
IsLock int8 // 是否锁定门店商品信息
|
||
EndAt time.Time
|
||
JdStoreID string `orm:"column(vendor_store_id)"`
|
||
JdSkuID int64 `orm:"column(jd_id)"`
|
||
}
|
||
|
||
type tSimpleStore struct {
|
||
StoreID int `orm:"column(store_id)" json:"storeID"`
|
||
Name string `orm:"column(name)" json:"name"`
|
||
}
|
||
|
||
type PromotionParams struct {
|
||
Name string
|
||
Advertising string
|
||
Type int
|
||
BeginAt time.Time
|
||
EndAt time.Time
|
||
StoreIDs []int
|
||
SkuPrices []*SkuPrice
|
||
}
|
||
|
||
type tStoreSkuBindExt struct {
|
||
model.StoreSkuBind
|
||
JdSkuID int64 `orm:"column(jd_id)"`
|
||
VendorStoreID string `orm:"column(vendor_store_id)"`
|
||
}
|
||
|
||
type tPromotionInfo struct {
|
||
model.Promotion
|
||
StoreStr string `orm:"column(store_str)" json:"-"`
|
||
SkuPriceStr string `orm:"column(sku_price_str)" json:"-"`
|
||
Stores []*tSimpleStore `orm:"-" json:"stores"`
|
||
SkuPrices []*SkuPrice `orm:"-" json:"skuPrices"`
|
||
}
|
||
|
||
var (
|
||
ErrEmptySkus = errors.New("空sku或指定的SKU没有被门店认领，请检查")
|
||
)
|
||
|
||
var (
|
||
jd2jxPromotionStatusMap = map[int]int{
|
||
jdapi.PromotionStateNotConfirm: model.PromotionStatusRemoteCreated,
|
||
jdapi.PromotionStateConfirmed: model.PromotionStatusRemoteCreated,
|
||
jdapi.PromotionStateCanceled: model.PromotionStatusCanceled,
|
||
jdapi.PromotionStateEnded: model.PromotionStatusEnded,
|
||
}
|
||
)
|
||
|
||
var (
|
||
ErrLimitDeviceIsInvalid = errors.New("必须指定一个limitCount，当limitPin或limitDevice不都为0时")
|
||
)
|
||
|
||
type JdPromotionHandler interface {
|
||
CreatePromotionInfos(name string, beginDate, endDate time.Time, outInfoId, advertising string) (infoId int64, err error)
|
||
CreatePromotionRules(infoId int64, outInfoId string, limitDevice, limitPin, limitCount, limitDaily int) (err error)
|
||
CreatePromotionSku(infoId int64, outInfoId string, skus []*jdapi.PromotionSku) (skusResult []*jdapi.PromotionSku, err error)
|
||
ConfirmPromotion(infoId int64, outInfoId string) (err error)
|
||
CancelPromotion(infoId int64, outInfoId string) (err error)
|
||
}
|
||
|
||
type JdDirectDownHandler struct {
|
||
}
|
||
|
||
func (p *JdDirectDownHandler) CreatePromotionInfos(name string, beginDate, endDate time.Time, outInfoId, advertising string) (infoId int64, err error) {
|
||
return api.JdAPI.CreatePromotionInfosSingle(name, beginDate, endDate, outInfoId, advertising, "")
|
||
}
|
||
func (p *JdDirectDownHandler) CreatePromotionRules(infoId int64, outInfoId string, limitDevice, limitPin, limitCount, limitDaily int) (err error) {
|
||
return api.JdAPI.CreatePromotionRulesSingle(infoId, outInfoId, limitDevice, limitPin, limitCount, limitDaily, "")
|
||
}
|
||
func (p *JdDirectDownHandler) CreatePromotionSku(infoId int64, outInfoId string, skus []*jdapi.PromotionSku) (skusResult []*jdapi.PromotionSku, err error) {
|
||
return api.JdAPI.CreatePromotionSkuSingle(infoId, outInfoId, skus, "")
|
||
}
|
||
func (p *JdDirectDownHandler) ConfirmPromotion(infoId int64, outInfoId string) (err error) {
|
||
return api.JdAPI.ConfirmPromotionSingle(infoId, outInfoId, "")
|
||
}
|
||
func (p *JdDirectDownHandler) CancelPromotion(infoId int64, outInfoId string) (err error) {
|
||
return api.JdAPI.CancelPromotionSingle(infoId, outInfoId, "")
|
||
}
|
||
|
||
type JdLimitedTimeHandler struct {
|
||
}
|
||
|
||
func (p *JdLimitedTimeHandler) CreatePromotionInfos(name string, beginDate, endDate time.Time, outInfoId, advertising string) (infoId int64, err error) {
|
||
return api.JdAPI.CreatePromotionInfosLimitTime(name, beginDate, endDate, outInfoId, advertising, "")
|
||
}
|
||
func (p *JdLimitedTimeHandler) CreatePromotionRules(infoId int64, outInfoId string, limitDevice, limitPin, limitCount, limitDaily int) (err error) {
|
||
return api.JdAPI.CreatePromotionRulesLimitTime(infoId, outInfoId, limitDevice, limitPin, limitCount, limitDaily, "")
|
||
}
|
||
func (p *JdLimitedTimeHandler) CreatePromotionSku(infoId int64, outInfoId string, skus []*jdapi.PromotionSku) (skusResult []*jdapi.PromotionSku, err error) {
|
||
return api.JdAPI.CreatePromotionSkuLimitTime(infoId, outInfoId, skus, "")
|
||
}
|
||
func (p *JdLimitedTimeHandler) ConfirmPromotion(infoId int64, outInfoId string) (err error) {
|
||
return api.JdAPI.ConfirmPromotionLimitTime(infoId, outInfoId, "")
|
||
}
|
||
func (p *JdLimitedTimeHandler) CancelPromotion(infoId int64, outInfoId string) (err error) {
|
||
return api.JdAPI.CancelPromotionLimitTime(infoId, outInfoId, "")
|
||
}
|
||
|
||
type JdNullHandler struct {
|
||
}
|
||
|
||
func (p *JdNullHandler) CreatePromotionInfos(name string, beginDate, endDate time.Time, outInfoId, advertising string) (infoId int64, err error) {
|
||
return jxutils.GenFakeID(), nil
|
||
}
|
||
func (p *JdNullHandler) CreatePromotionRules(infoId int64, outInfoId string, limitDevice, limitPin, limitCount, limitDaily int) (err error) {
|
||
return nil
|
||
}
|
||
func (p *JdNullHandler) CreatePromotionSku(infoId int64, outInfoId string, skus []*jdapi.PromotionSku) (skusResult []*jdapi.PromotionSku, err error) {
|
||
return nil, nil
|
||
}
|
||
func (p *JdNullHandler) ConfirmPromotion(infoId int64, outInfoId string) (err error) {
|
||
return nil
|
||
}
|
||
func (p *JdNullHandler) CancelPromotion(infoId int64, outInfoId string) (err error) {
|
||
return nil
|
||
}
|
||
|
||
func init() {
|
||
gob.Register(&PromotionParams{})
|
||
gob.Register([]*SkuPrice{})
|
||
}
|
||
|
||
func scheduleDailyRoutine(isFirst bool) {
|
||
executeTime := utils.GetCurDate().Add(24*time.Hour + 5*time.Minute) // 凌晨00:05执行
|
||
duration := executeTime.Sub(time.Now())
|
||
if isFirst && duration > 1*time.Hour {
|
||
UpdateJdPromotionStatus()
|
||
}
|
||
// globals.SugarLogger.Debug(duration)
|
||
utils.AfterFuncWithRecover(duration, func() {
|
||
UpdateJdPromotionStatus()
|
||
scheduleDailyRoutine(false)
|
||
})
|
||
}
|
||
|
||
func scheduleRoutine(isFirst bool) {
|
||
if isFirst {
|
||
utils.CallFuncAsync(func() {
|
||
RefreshJdLockStoreSku()
|
||
RefreshJdStoreSkuStock(0, nil)
|
||
})
|
||
}
|
||
utils.AfterFuncWithRecover(stockRefreshGap, func() {
|
||
RefreshJdLockStoreSku()
|
||
RefreshJdStoreSkuStock(0, nil)
|
||
scheduleRoutine(false)
|
||
})
|
||
}
|
||
|
||
func Init() {
|
||
scheduleDailyRoutine(true)
|
||
// scheduleRoutine(true)
|
||
}
|
||
|
||
func CreateJdPromotion(ctx *jxcontext.Context, vendorID int, isIDJd bool, isAsync, isContinueWhenError bool, vendorPromotionID string, params *PromotionParams, mapData map[string]interface{}) (hint string, err error) {
|
||
if vendorID != model.VendorIDJD && vendorID != model.VendorIDJX {
|
||
return "", fmt.Errorf("当前只支持京西与京东活动")
|
||
}
|
||
if vendorPromotionID != "" && len(vendorPromotionID) != len("14863853") {
|
||
return "", fmt.Errorf("%s看起来不像是一个有效的京东活动ID，请仔细检查一下", vendorPromotionID)
|
||
}
|
||
if len(params.SkuPrices) == 0 {
|
||
return "", ErrEmptySkus
|
||
}
|
||
limitDaily := 1
|
||
if limitDaily2, ok := mapData[keyLimitDaily]; ok {
|
||
limitDaily = jxutils.Int2OneZero(limitDaily2.(int))
|
||
}
|
||
limitPin := 1
|
||
if limitPin2, ok := mapData[keyLimitPin]; ok {
|
||
limitPin = jxutils.Int2OneZero(limitPin2.(int))
|
||
}
|
||
limitDevice := 1
|
||
if limitDevice2, ok := mapData[keyLimitDevice]; ok {
|
||
limitDevice = jxutils.Int2OneZero(limitDevice2.(int))
|
||
}
|
||
limitCount := 1
|
||
if limitCount2, ok := mapData[keyLimitCount]; ok {
|
||
limitCount = limitCount2.(int)
|
||
}
|
||
if (limitDevice == 1 || limitPin == 1) && limitCount == 0 {
|
||
return "", ErrLimitDeviceIsInvalid
|
||
}
|
||
|
||
userName := ctx.GetUserName()
|
||
db := dao.GetDB()
|
||
modifyPricesList := make(map[int][]*jdapi.SkuPriceInfo)
|
||
promotionPrices := make([]*jdapi.PromotionSku, len(params.StoreIDs)*len(params.SkuPrices))
|
||
var jxStoreIDs []int
|
||
promotion := &model.Promotion{
|
||
Name: params.Name,
|
||
Advertising: params.Advertising,
|
||
VendorID: vendorID,
|
||
Type: params.Type,
|
||
Status: model.PromotionStatusLocalCreated,
|
||
LimitDevice: int8(limitDevice),
|
||
LimitPin: int8(limitPin),
|
||
LimitCount: limitCount,
|
||
LimitDaily: int8(limitDaily),
|
||
BeginAt: params.BeginAt,
|
||
EndAt: params.EndAt,
|
||
CreateType: model.PromotionCreateTypeByJX,
|
||
Source: PromotionSourceOpenPlatform,
|
||
}
|
||
|
||
skuIDs := make([]int, len(params.SkuPrices))
|
||
skuPriceMap := make(map[int64]*SkuPrice)
|
||
for k, v := range params.SkuPrices {
|
||
skuIDs[k] = v.SkuID
|
||
skuPriceMap[int64(v.SkuID)] = v
|
||
}
|
||
if len(skuIDs) == 0 {
|
||
return "", fmt.Errorf("商品列表为空")
|
||
}
|
||
if vendorID == model.VendorIDJX {
|
||
conflictPromotion, err2 := dao.GetPromotionSkuPriceMap(db, model.VendorIDJX, params.StoreIDs, skuIDs, promotion.BeginAt, promotion.EndAt)
|
||
if err = err2; err != nil {
|
||
return "", err
|
||
}
|
||
if len(conflictPromotion) > 0 {
|
||
return "", fmt.Errorf("有冲突配置:%s", utils.Format4Output(conflictPromotion, false))
|
||
}
|
||
}
|
||
if vendorPromotionID == "" {
|
||
if vendorID == model.VendorIDJD {
|
||
sql := `
|
||
SELECT t1.*, t2.jd_id, t3.vendor_store_id
|
||
FROM store_sku_bind t1
|
||
JOIN sku t2 ON t1.sku_id = t2.id
|
||
JOIN store_map t3 ON t1.store_id = t3.store_id AND t3.vendor_id = ? AND t3.deleted_at = ?
|
||
WHERE t1.deleted_at = ?
|
||
`
|
||
sqlParam := []interface{}{
|
||
model.VendorIDJD,
|
||
utils.DefaultTimeValue,
|
||
utils.DefaultTimeValue,
|
||
skuIDs,
|
||
}
|
||
if isIDJd {
|
||
sql += " AND t2.jd_id IN (" + dao.GenQuestionMarks(len(skuIDs)) + ") AND t3.vendor_store_id = ?"
|
||
} else {
|
||
sql += " AND t1.sku_id IN (" + dao.GenQuestionMarks(len(skuIDs)) + ") AND t1.store_id = ?"
|
||
}
|
||
|
||
errMsg := ""
|
||
index := 0
|
||
for _, storeID := range params.StoreIDs {
|
||
var skuBinds []*tStoreSkuBindExt
|
||
if err = dao.GetRows(db, &skuBinds, sql, append(sqlParam, storeID)...); err != nil {
|
||
return "", err
|
||
}
|
||
for k, skuBind := range skuBinds {
|
||
if k == 0 {
|
||
jxStoreIDs = append(jxStoreIDs, skuBind.StoreID)
|
||
}
|
||
mapSkuID := int64(skuBind.SkuID)
|
||
if isIDJd {
|
||
mapSkuID = skuBind.JdSkuID
|
||
}
|
||
promotionSkuPrice := skuPriceMap[mapSkuID]
|
||
if promotionSkuPrice.PriceType == PriceTypePercentage {
|
||
promotionSkuPrice.Price = skuBind.Price * promotionSkuPrice.Price / 100
|
||
}
|
||
if vendorID != model.VendorIDJX && promotionSkuPrice.Price >= skuBind.Price {
|
||
errMsg += fmt.Sprintf("活动价大于等于原价，storeID:%d, skuID:%d\n", skuBind.StoreID, skuBind.SkuID)
|
||
}
|
||
if promotionSkuPrice.LimitSkuCount <= 0 {
|
||
promotionSkuPrice.LimitSkuCount = DefaultLimitSkuCount
|
||
}
|
||
if errMsg == "" {
|
||
if params.Type == PromotionTypeLimitedTime {
|
||
if skuBind.Price*PromotionLimitedTimeMinPercentage/100 < promotionSkuPrice.Price {
|
||
modifyPricesList[skuBind.StoreID] = append(modifyPricesList[skuBind.StoreID], &jdapi.SkuPriceInfo{
|
||
OutSkuId: utils.Int2Str(skuBind.SkuID),
|
||
Price: promotionSkuPrice.Price*100/PromotionLimitedTimeMinPercentage + 5,
|
||
})
|
||
}
|
||
}
|
||
promotionPrices[index] = &jdapi.PromotionSku{
|
||
StationNo: utils.Str2Int64(skuBind.VendorStoreID),
|
||
SkuID: skuBind.JdSkuID,
|
||
PromotionPrice: int64(promotionSkuPrice.Price),
|
||
LimitSkuCount: promotionSkuPrice.LimitSkuCount,
|
||
}
|
||
index++
|
||
}
|
||
}
|
||
}
|
||
if errMsg != "" {
|
||
return "", errors.New(errMsg)
|
||
}
|
||
promotionPrices = promotionPrices[:index]
|
||
if len(promotionPrices) == 0 {
|
||
return "", ErrEmptySkus
|
||
}
|
||
} else {
|
||
promotion.Status = model.PromotionStatusRemoteCreated
|
||
}
|
||
} else {
|
||
promotion.VendorPromotionID = vendorPromotionID
|
||
promotion.CreateType = model.PromotionCreateTypeByVendor
|
||
if status, ok := mapData[keyPromotionStatus]; ok {
|
||
promotion.Status = status.(int)
|
||
} else {
|
||
promotion.Status = model.PromotionStatusRemoteCreated
|
||
}
|
||
if source, ok := mapData[keyPromotionSource]; ok {
|
||
promotion.Source = source.(string)
|
||
}
|
||
}
|
||
|
||
dao.WrapAddIDCULDEntity(promotion, userName)
|
||
// if promotion.Params, err = refutil.SerializeData(params); err != nil {
|
||
// return "", err
|
||
// }
|
||
// promotion.Params = string(utils.MustMarshal(params))
|
||
dao.Begin(db)
|
||
defer func() {
|
||
dao.Rollback(db)
|
||
}()
|
||
|
||
if err = dao.CreateEntity(db, promotion); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
for _, storeID := range params.StoreIDs {
|
||
promotionStore := &model.PromotionStore{
|
||
PromotionID: promotion.ID,
|
||
StoreID: storeID,
|
||
}
|
||
dao.WrapAddIDCULDEntity(promotionStore, ctx.GetUserName())
|
||
if err = dao.CreateEntity(db, promotionStore); err != nil {
|
||
return "", err
|
||
}
|
||
}
|
||
for _, skuPrice := range params.SkuPrices {
|
||
promotionSku := &model.PromotionSku{
|
||
PromotionID: promotion.ID,
|
||
SkuID: skuPrice.SkuID,
|
||
PriceType: skuPrice.PriceType,
|
||
Price: skuPrice.Price,
|
||
LimitSkuCount: skuPrice.LimitSkuCount,
|
||
IsLock: skuPrice.IsLock,
|
||
EarningPrice: skuPrice.EarningPrice,
|
||
}
|
||
dao.WrapAddIDCULDEntity(promotionSku, ctx.GetUserName())
|
||
if err = dao.CreateEntity(db, promotionSku); err != nil {
|
||
return "", err
|
||
}
|
||
}
|
||
|
||
if vendorID != model.VendorIDJX && vendorPromotionID == "" {
|
||
promotionHandler := getPromotionHander(params.Type)
|
||
if promotionHandler == nil {
|
||
return "", errors.New("非法的活动类型")
|
||
}
|
||
infoId, err2 := promotionHandler.CreatePromotionInfos(params.Name, params.BeginAt, params.EndAt, utils.Int2Str(promotion.ID), params.Advertising)
|
||
if err = err2; err != nil {
|
||
return "", err
|
||
}
|
||
promotion.VendorPromotionID = utils.Int64ToStr(infoId)
|
||
if _, err = dao.UpdateEntity(db, promotion); err != nil {
|
||
return "", err
|
||
}
|
||
dao.Commit(db)
|
||
|
||
rootTask := tasksch.NewSeqTask("CreateJdPromotion", ctx,
|
||
func(task *tasksch.SeqTask, step int, params2 ...interface{}) (result interface{}, err error) {
|
||
if step == 0 {
|
||
task1 := tasksch.NewParallelTask("CreateJdPromotion update sku price", nil, ctx,
|
||
func(t *tasksch.ParallelTask, batchItemList []interface{}, params2 ...interface{}) (retVal interface{}, err error) {
|
||
storeID := batchItemList[0].(int)
|
||
modifyPricesList := jxutils.SplitSlice(modifyPricesList[storeID], jdapi.MaxStoreSkuBatchSize)
|
||
for _, modifyPrices := range modifyPricesList {
|
||
modifyPrices2 := make([]*jdapi.SkuPriceInfo, len(modifyPrices))
|
||
for k, v := range modifyPrices {
|
||
modifyPrices2[k] = v.(*jdapi.SkuPriceInfo)
|
||
}
|
||
if globals.EnableJdStoreWrite {
|
||
if _, err = api.JdAPI.UpdateVendorStationPrice(ctx.GetTrackInfo(), utils.Int2Str(storeID), "", modifyPrices2); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
}
|
||
return nil, nil
|
||
}, jxStoreIDs)
|
||
task.AddChild(task1).Run()
|
||
_, err = task1.GetResult(0)
|
||
} else if step == 1 {
|
||
err = promotionHandler.CreatePromotionRules(infoId, "", limitDevice, limitPin, limitCount, limitDaily)
|
||
} else if step == 2 {
|
||
task2 := tasksch.NewParallelTask("CreateJdPromotion CreatePromotionSku", tasksch.NewParallelConfig().SetBatchSize(MaxPromotionSkuCount).SetIsContinueWhenError(isContinueWhenError), ctx,
|
||
func(task *tasksch.ParallelTask, batchItemList []interface{}, params2 ...interface{}) (retVal interface{}, err error) {
|
||
skus := make([]*jdapi.PromotionSku, len(batchItemList))
|
||
for k, v := range batchItemList {
|
||
skus[k] = v.(*jdapi.PromotionSku)
|
||
}
|
||
_, err = promotionHandler.CreatePromotionSku(infoId, "", skus)
|
||
return nil, err
|
||
}, promotionPrices)
|
||
task.AddChild(task2).Run()
|
||
_, err = task2.GetResult(0)
|
||
if isContinueWhenError && err != nil { // todo isContinueWhenError为true时，强制忽略此步的错误
|
||
err = nil
|
||
}
|
||
} else if step == 3 {
|
||
err = promotionHandler.ConfirmPromotion(infoId, "")
|
||
if err == nil {
|
||
db := dao.GetDB()
|
||
if _, err = dao.UpdateEntityLogically(db, promotion, map[string]interface{}{
|
||
model.FieldStatus: model.PromotionStatusRemoteCreated,
|
||
}, ctx.GetUserName(), nil); err == nil {
|
||
RefreshJdPromotionLockStatus(ctx, promotion.ID)
|
||
}
|
||
}
|
||
}
|
||
if err != nil {
|
||
db := dao.GetDB()
|
||
dao.UpdateEntityLogically(db, promotion, map[string]interface{}{
|
||
model.FieldStatus: model.PromotionStatusRemoteFailed,
|
||
model.FieldRemark: err.Error(),
|
||
}, ctx.GetUserName(), nil)
|
||
}
|
||
return nil, err
|
||
}, 4)
|
||
tasksch.HandleTask(rootTask, nil, true).Run()
|
||
if !isAsync {
|
||
_, err = rootTask.GetResult(0)
|
||
}
|
||
hint = rootTask.ID
|
||
} else {
|
||
dao.Commit(db)
|
||
}
|
||
return hint, err
|
||
}
|
||
|
||
func GetJdPromotions(ctx *jxcontext.Context, keyword string, params map[string]interface{}, offset, pageSize int) (pagedInfo *model.PagedInfo, err error) {
|
||
sql := `
|
||
SELECT SQL_CALC_FOUND_ROWS
|
||
t1.id,
|
||
t1.created_at,
|
||
t1.updated_at,
|
||
t1.last_operator,
|
||
t1.vendor_id,
|
||
t1.name,
|
||
t1.type,
|
||
t1.status,
|
||
t1.vendor_promotion_id,
|
||
t1.begin_at,
|
||
t1.end_at,
|
||
t1.advertising,
|
||
CONCAT("[", GROUP_CONCAT(DISTINCT CONCAT('{"storeID":', t2.store_id, ', "name":"', REPLACE(REPLACE(t22.name, '\t', ''), '"', ''), '"}')), "]") store_str,
|
||
CONCAT("[", GROUP_CONCAT(DISTINCT CONCAT('{"skuID":', t3.sku_id, ', "priceType":', t3.price_type, ', "price":', t3.price,
|
||
', "limitSkuCount":', t3.limit_sku_count, ', "isLock":', t3.is_lock, ', "earningPrice":', t3.earning_price, '}')), "]") sku_price_str
|
||
FROM promotion t1
|
||
JOIN promotion_store t2 ON t1.id = t2.promotion_id
|
||
JOIN store t22 ON t2.store_id = t22.id
|
||
JOIN promotion_sku t3 ON t1.id = t3.promotion_id
|
||
WHERE t1.deleted_at = ?
|
||
`
|
||
sqlParams := []interface{}{
|
||
utils.DefaultTimeValue,
|
||
}
|
||
if keyword != "" {
|
||
keywordLike := "%" + keyword + "%"
|
||
sql += " AND ( t1.name LIKE ?"
|
||
sqlParams = append(sqlParams, keywordLike)
|
||
keywordInt := utils.Str2Int64WithDefault(keyword, 0)
|
||
if keywordInt > 0 {
|
||
sql += `
|
||
OR t1.id = ? OR t1.vendor_promotion_id = ?
|
||
OR (SELECT COUNT(*) FROM promotion_store tt1 WHERE tt1.promotion_id = t1.id AND tt1.store_id = ?) > 0
|
||
OR (SELECT COUNT(*) FROM promotion_sku tt1 WHERE tt1.promotion_id = t1.id AND tt1.sku_id = ?) > 0
|
||
`
|
||
sqlParams = append(sqlParams, keywordInt, keywordInt, keywordInt, keywordInt)
|
||
}
|
||
sql += ")"
|
||
}
|
||
if params["vendorID"] != nil {
|
||
sql += " AND t1.vendor_id = ?"
|
||
sqlParams = append(sqlParams, params["vendorID"].(int))
|
||
}
|
||
if params["promotionID"] != nil {
|
||
sql += " AND t1.id = ?"
|
||
sqlParams = append(sqlParams, params["promotionID"].(int))
|
||
}
|
||
if params["vendorPromotionID"] != nil {
|
||
sql += " AND t1.vendor_promotion_id = ?"
|
||
sqlParams = append(sqlParams, params["vendorPromotionID"].(string))
|
||
}
|
||
if params["name"] != nil {
|
||
sql += " AND t1.name LIKE ?"
|
||
sqlParams = append(sqlParams, "%"+params["name"].(string)+"%")
|
||
}
|
||
if params["beginAt"] != nil {
|
||
sql += " AND t1.begin_at <= ?"
|
||
beginAt, err2 := utils.TryStr2Time(params["beginAt"].(string))
|
||
if err = err2; err != nil {
|
||
return nil, err
|
||
}
|
||
sqlParams = append(sqlParams, beginAt)
|
||
}
|
||
if params["endAt"] != nil {
|
||
sql += " AND t1.end_at >= ?"
|
||
endAt, err2 := utils.TryStr2Time(params["endAt"].(string))
|
||
if err = err2; err != nil {
|
||
return nil, err
|
||
}
|
||
sqlParams = append(sqlParams, endAt)
|
||
}
|
||
days := defSearchDays
|
||
if params["days"] != nil {
|
||
days = params["days"].(int)
|
||
}
|
||
sql += " AND t1.created_at >= ?"
|
||
sqlParams = append(sqlParams, time.Now().Add(-time.Duration(days)*24*time.Hour))
|
||
if params["type"] != nil {
|
||
sql += " AND t1.type = ?"
|
||
sqlParams = append(sqlParams, params["type"].(int))
|
||
}
|
||
if params["storeID"] != nil || params["cityCode"] != nil {
|
||
sql += " AND (SELECT COUNT(*) FROM promotion_store tt1 "
|
||
if params["cityCode"] != nil {
|
||
sql += " JOIN store st ON st.id = tt1.store_id AND st.city_code = ?"
|
||
sqlParams = append(sqlParams, params["cityCode"].(int))
|
||
}
|
||
sql += " WHERE tt1.promotion_id = t1.id"
|
||
if params["storeID"] != nil {
|
||
sql += " AND tt1.store_id = ?"
|
||
sqlParams = append(sqlParams, params["storeID"].(int))
|
||
}
|
||
sql += ") > 0"
|
||
}
|
||
if params["skuID"] != nil {
|
||
sql += " AND (SELECT COUNT(*) FROM promotion_sku tt1 WHERE tt1.promotion_id = t1.id AND tt1.sku_id = ?) > 0"
|
||
sqlParams = append(sqlParams, params["skuID"].(int))
|
||
}
|
||
sql += `
|
||
GROUP BY
|
||
1,2,3,4,5,6,7,8,9,10,11,12
|
||
ORDER BY t1.id DESC
|
||
LIMIT ? OFFSET ?
|
||
`
|
||
pageSize = jxutils.FormalizePageSize(pageSize)
|
||
if offset < 0 {
|
||
offset = 0
|
||
}
|
||
sqlParams = append(sqlParams, pageSize, offset)
|
||
|
||
db := dao.GetDB()
|
||
dao.Begin(db)
|
||
defer func() {
|
||
dao.Rollback(db)
|
||
if r := recover(); r != nil {
|
||
panic(r)
|
||
}
|
||
}()
|
||
// globals.SugarLogger.Debug(utils.Format4Output(sqlParams, false))
|
||
// globals.SugarLogger.Debug(sql)
|
||
var promotionList []*tPromotionInfo
|
||
if err = dao.GetRows(db, &promotionList, sql, sqlParams...); err == nil {
|
||
pagedInfo = &model.PagedInfo{
|
||
TotalCount: dao.GetLastTotalRowCount(db),
|
||
Data: promotionList,
|
||
}
|
||
dao.Commit(db)
|
||
for _, v := range promotionList {
|
||
if v.StoreStr != "" {
|
||
if err = utils.UnmarshalUseNumber([]byte(v.StoreStr), &v.Stores); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
if v.SkuPriceStr != "" {
|
||
if err = utils.UnmarshalUseNumber([]byte(v.SkuPriceStr), &v.SkuPrices); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
dao.Rollback(db)
|
||
}
|
||
return pagedInfo, err
|
||
}
|
||
|
||
func CancelJdPromotion(ctx *jxcontext.Context, promotionID int) (err error) {
|
||
globals.SugarLogger.Debug("CancelJdPromotion promotionID:%d", promotionID)
|
||
|
||
db := dao.GetDB()
|
||
promotion := &model.Promotion{}
|
||
promotion.ID = promotionID
|
||
if err = dao.GetEntity(db, promotion); err != nil {
|
||
return err
|
||
}
|
||
if promotion.Status == model.PromotionStatusCanceled {
|
||
return errors.New("当前状态已经是取消")
|
||
}
|
||
if promotion.Status == model.PromotionStatusRemoteCreated {
|
||
if promotion.VendorPromotionID != "" {
|
||
promotionHandler := getPromotionHander(promotion.Type)
|
||
if promotionHandler == nil {
|
||
return errors.New("非法的活动类型")
|
||
}
|
||
if err = promotionHandler.CancelPromotion(utils.Str2Int64(promotion.VendorPromotionID), ""); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
if _, err = dao.UpdateEntityLogically(db, promotion, map[string]interface{}{
|
||
"Status": model.PromotionStatusCanceled,
|
||
}, ctx.GetUserName(), nil); err == nil {
|
||
// RefreshJdPromotionLockStatus(ctx, promotionID)
|
||
}
|
||
return err
|
||
}
|
||
|
||
// 每一段时间运行一次
|
||
func RefreshJdLockStoreSku() (err error) {
|
||
globals.SugarLogger.Debug("RefreshJdLockStoreSku")
|
||
|
||
sql := `
|
||
SELECT t22.vendor_store_id, t3.sku_id, t32.jd_id, MAX(t3.is_lock) is_lock, MAX(t1.end_at) end_at
|
||
FROM promotion t1
|
||
JOIN promotion_store t2 ON t1.id = t2.promotion_id
|
||
JOIN store_map t22 ON t2.store_id = t22.store_id AND t22.vendor_id = ? AND t22.deleted_at = ?
|
||
JOIN promotion_sku t3 ON t1.id = t3.promotion_id AND t3.is_lock = 1
|
||
JOIN sku t32 ON t3.sku_id = t32.id
|
||
WHERE t1.deleted_at = ? AND t1.vendor_id = ? AND t1.status = ? AND (t1.begin_at <= ? AND t1.end_at >= ?)
|
||
GROUP BY 1,2,3
|
||
`
|
||
nowDate := time.Now()
|
||
sqlParams := []interface{}{
|
||
model.VendorIDJD,
|
||
utils.DefaultTimeValue,
|
||
utils.DefaultTimeValue,
|
||
model.VendorIDJD,
|
||
model.PromotionStatusRemoteCreated,
|
||
nowDate,
|
||
nowDate,
|
||
}
|
||
var promotionItemList []*tPromotionItemInfo
|
||
db := dao.GetDB()
|
||
if err = dao.GetRows(db, &promotionItemList, sql, sqlParams...); err != nil {
|
||
if !dao.IsNoRowsError(err) {
|
||
globals.SugarLogger.Warnf("RefreshJdLockStoreSku GetRows failed with error:%v", err)
|
||
}
|
||
return err
|
||
}
|
||
storeskulock.ClearJdStoreSkuLock()
|
||
return RefreshJdPromotionItemListLockStatus(promotionItemList)
|
||
}
|
||
|
||
func RefreshJdStoreSkuStock(promotionID int, skuIDs []int) (err error) {
|
||
globals.SugarLogger.Debugf("RefreshJdStoreSkuStock promotionID:%d", promotionID)
|
||
|
||
sql := `
|
||
SELECT t22.vendor_store_id, t3.sku_id, t32.jd_id, MAX(t3.is_lock) is_lock, MAX(t1.end_at) end_at
|
||
FROM promotion t1
|
||
JOIN promotion_store t2 ON t1.id = t2.promotion_id
|
||
JOIN store_map t22 ON t2.store_id = t22.store_id AND t22.vendor_id = ? AND t22.deleted_at = ?
|
||
JOIN promotion_sku t3 ON t1.id = t3.promotion_id AND t3.is_lock = 1
|
||
JOIN sku t32 ON t3.sku_id = t32.id
|
||
JOIN store_sku_bind t4 ON t2.store_id = t4.store_id AND t3.sku_id = t4.sku_id AND t4.deleted_at = ?
|
||
WHERE t1.deleted_at = ? AND t1.vendor_id = ? AND t1.status = ? AND (t1.begin_at <= ? AND t1.end_at >= ?)
|
||
`
|
||
nowDate := time.Now()
|
||
sqlParams := []interface{}{
|
||
model.VendorIDJD,
|
||
utils.DefaultTimeValue,
|
||
utils.DefaultTimeValue,
|
||
utils.DefaultTimeValue,
|
||
model.VendorIDJD,
|
||
model.PromotionStatusRemoteCreated,
|
||
nowDate,
|
||
nowDate,
|
||
}
|
||
if promotionID != 0 {
|
||
sql += " AND t1.id = ?"
|
||
sqlParams = append(sqlParams, promotionID)
|
||
}
|
||
if len(skuIDs) > 0 {
|
||
sql += " AND t3.sku_id IN (" + dao.GenQuestionMarks(len(skuIDs)) + ")"
|
||
sqlParams = append(sqlParams, skuIDs)
|
||
}
|
||
sql += `
|
||
GROUP BY 1,2,3
|
||
ORDER BY 1,2,3
|
||
`
|
||
var promotionItemList []*tPromotionItemInfo
|
||
db := dao.GetDB()
|
||
if err = dao.GetRows(db, &promotionItemList, sql, sqlParams...); err != nil {
|
||
if !dao.IsNoRowsError(err) {
|
||
globals.SugarLogger.Warnf("RefreshJdStoreSkuStock GetRows failed with error:%v", err)
|
||
}
|
||
return err
|
||
}
|
||
globals.SugarLogger.Debugf("RefreshJdStoreSkuStock promotionID:%d, len(promotionItemList)=%d", promotionID, len(promotionItemList))
|
||
if len(promotionItemList) > 0 {
|
||
task := tasksch.NewParallelTask("RefreshJdStoreSkuStock", tasksch.NewParallelConfig().SetBatchSize(jdapi.MaxStoreSkuBatchSize).SetIsContinueWhenError(true), jxcontext.AdminCtx,
|
||
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
|
||
stockList := make([]*jdapi.SkuStock, 0)
|
||
stationNo := batchItemList[0].(*tPromotionItemInfo).JdStoreID
|
||
for _, v := range batchItemList {
|
||
promotionItem := v.(*tPromotionItemInfo)
|
||
if promotionItem.JdStoreID != stationNo {
|
||
// globals.SugarLogger.Debugf("RefreshJdStoreSkuStock BatchUpdateCurrentQtys stationNo:%s, stockList:%s", stationNo, utils.Format4Output(stockList, false))
|
||
_, err = api.JdAPI.BatchUpdateCurrentQtys("", "", stationNo, stockList, userName)
|
||
if err != nil {
|
||
globals.SugarLogger.Warnf("RefreshJdStoreSkuStock BatchUpdateCurrentQtys failed with error:%v", err)
|
||
}
|
||
stockList = make([]*jdapi.SkuStock, 0)
|
||
stationNo = promotionItem.JdStoreID
|
||
}
|
||
stockList = append(stockList, &jdapi.SkuStock{
|
||
OutSkuId: utils.Int2Str(promotionItem.SkuID),
|
||
StockQty: model.MaxStoreSkuStockQty,
|
||
})
|
||
}
|
||
// globals.SugarLogger.Debugf("RefreshJdStoreSkuStock BatchUpdateCurrentQtys stationNo:%s, stockList:%s", stationNo, utils.Format4Output(stockList, false))
|
||
_, err = api.JdAPI.BatchUpdateCurrentQtys("", "", stationNo, stockList, userName)
|
||
if err != nil {
|
||
globals.SugarLogger.Warnf("RefreshJdStoreSkuStock BatchUpdateCurrentQtys failed with error:%v", err)
|
||
}
|
||
return nil, err
|
||
}, promotionItemList)
|
||
task.Run()
|
||
_, err = task.GetResult(0)
|
||
}
|
||
return err
|
||
}
|
||
|
||
// 每晚凌晨运行一次
|
||
func UpdateJdPromotionStatus() (num int64, err error) {
|
||
sql := `
|
||
UPDATE promotion t1
|
||
SET t1.status = ?
|
||
WHERE t1.deleted_at = ? AND t1.vendor_id IN (?, ?) AND t1.status = ? AND t1.end_at < ?
|
||
`
|
||
nowDate := utils.GetCurDate()
|
||
sqlParams := []interface{}{
|
||
model.PromotionStatusEnded,
|
||
utils.DefaultTimeValue,
|
||
[]int{model.VendorIDJX, model.VendorIDJD},
|
||
model.PromotionStatusRemoteCreated,
|
||
nowDate,
|
||
}
|
||
db := dao.GetDB()
|
||
return dao.ExecuteSQL(db, sql, sqlParams...)
|
||
}
|
||
|
||
func RefreshJdPromotionItemListLockStatus(promotionItemList []*tPromotionItemInfo) (err error) {
|
||
globals.SugarLogger.Debugf("RefreshJdPromotionItemListLockStatus len(promotionItemList):%d", len(promotionItemList))
|
||
if len(promotionItemList) > 0 {
|
||
expire := promotionItemList[0].EndAt.Add(24 * time.Hour)
|
||
for _, item := range promotionItemList {
|
||
if item.IsLock != 0 {
|
||
storeskulock.LockJdStoreSku(item.JdStoreID, item.JdSkuID, expire)
|
||
} else {
|
||
storeskulock.UnlockJdStoreSku(item.JdStoreID, item.JdSkuID)
|
||
}
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
func RefreshJdPromotionLockStatus(ctx *jxcontext.Context, promotionID int) (err error) {
|
||
globals.SugarLogger.Debugf("RefreshJdPromotionLockStatus promotionID:%d", promotionID)
|
||
|
||
sql := `
|
||
SELECT t22.vendor_store_id, t3.sku_id, t32.jd_id, IF(t1.begin_at <= ? AND t1.end_at >= ? AND t1.status = ?, t3.is_lock, 0) is_lock, t1.end_at
|
||
FROM promotion t1
|
||
JOIN promotion_store t2 ON t1.id = t2.promotion_id
|
||
JOIN store_map t22 ON t2.store_id = t22.store_id AND t22.vendor_id = ? AND t22.deleted_at = ?
|
||
JOIN promotion_sku t3 ON t1.id = t3.promotion_id
|
||
JOIN sku t32 ON t3.sku_id = t32.id
|
||
WHERE t1.id = ?
|
||
`
|
||
nowDate := time.Now()
|
||
sqlParams := []interface{}{
|
||
nowDate,
|
||
nowDate,
|
||
model.PromotionStatusRemoteCreated,
|
||
model.VendorIDJD,
|
||
utils.DefaultTimeValue,
|
||
promotionID,
|
||
}
|
||
var promotionItemList []*tPromotionItemInfo
|
||
db := dao.GetDB()
|
||
// globals.SugarLogger.Debug(sql)
|
||
// globals.SugarLogger.Debug(utils.Format4Output(sqlParams, false))
|
||
if err = dao.GetRows(db, &promotionItemList, sql, sqlParams...); err != nil {
|
||
return err
|
||
}
|
||
return RefreshJdPromotionItemListLockStatus(promotionItemList)
|
||
}
|
||
|
||
func LockPromotionSkus(ctx *jxcontext.Context, promotionID int, isLock int, skuIDs []int) (num int64, err error) {
|
||
globals.SugarLogger.Debugf("begin LockPromotionSkus promotionID:%d, isLock:%d, skuIDs:%v", promotionID, isLock, skuIDs)
|
||
if isLock != 0 {
|
||
isLock = 1
|
||
}
|
||
|
||
sql := `
|
||
UPDATE promotion_sku t1
|
||
SET t1.is_lock = ?
|
||
WHERE t1.promotion_id = ?
|
||
`
|
||
sqlParams := []interface{}{
|
||
isLock,
|
||
promotionID,
|
||
}
|
||
if len(skuIDs) > 0 {
|
||
sql += " AND t1.sku_id IN (" + dao.GenQuestionMarks(len(skuIDs)) + ")"
|
||
sqlParams = append(sqlParams, skuIDs)
|
||
}
|
||
db := dao.GetDB()
|
||
num, err = dao.ExecuteSQL(db, sql, sqlParams...)
|
||
if err == nil {
|
||
if isLock != 0 {
|
||
if err = UpdatePromotionStatusFromRemote(ctx, promotionID); err != nil {
|
||
return 0, err
|
||
}
|
||
}
|
||
RefreshJdPromotionLockStatus(ctx, promotionID)
|
||
if isLock != 0 {
|
||
// RefreshJdStoreSkuStock(promotionID, skuIDs) 这里比较耗时，实时更新意义也不大，留到定时任务自动处理
|
||
}
|
||
}
|
||
globals.SugarLogger.Debugf("end LockPromotionSkus promotionID:%d, isLock:%d, skuIDs:%v", promotionID, isLock, skuIDs)
|
||
return num, err
|
||
}
|
||
|
||
func UpdatePromotionSkusEarningPrice(ctx *jxcontext.Context, promotionID int, skuPriceList []*SkuPrice) (num int64, err error) {
|
||
db := dao.GetDB()
|
||
dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil || err != nil {
|
||
dao.Rollback(db)
|
||
if r != nil {
|
||
panic(r)
|
||
}
|
||
}
|
||
}()
|
||
for _, v := range skuPriceList {
|
||
var tmpNum int64
|
||
if tmpNum, err = dao.UpdateEntityLogically(db, &model.PromotionSku{}, map[string]interface{}{
|
||
"EarningPrice": v.EarningPrice,
|
||
}, ctx.GetUserName(), map[string]interface{}{
|
||
"PromotionID": promotionID,
|
||
model.FieldSkuID: v.SkuID,
|
||
model.FieldDeletedAt: utils.DefaultTimeValue,
|
||
}); err != nil {
|
||
return 0, err
|
||
}
|
||
num += tmpNum
|
||
}
|
||
dao.Commit(db)
|
||
return num, err
|
||
}
|
||
|
||
func OnStoreStockMsg(msg *jdapi.CallbackStoreStockMsg) (retVal *jdapi.CallbackResponse) {
|
||
var err error
|
||
// globals.SugarLogger.Debugf("OnStoreStockMsg IsJdStoreSkuLocked:%t", storeskulock.IsJdStoreSkuLocked(msg.StationNo, msg.SkuId))
|
||
if (msg.Vendibility == 1 || !msg.Have) && storeskulock.IsJdStoreSkuLocked(msg.StationNo, msg.SkuId) {
|
||
globals.SugarLogger.Debugf("OnStoreStockMsg msg:%s", utils.Format4Output(msg, false))
|
||
db := dao.GetDB()
|
||
sku := &model.Sku{}
|
||
sku.JdID = msg.SkuId
|
||
if err = dao.GetEntity(db, sku, model.FieldJdID); err == nil {
|
||
utils.CallFuncAsync(func() {
|
||
if msg.Vendibility == 1 {
|
||
vendibility := &jdapi.StockVendibility{
|
||
OutSkuId: utils.Int2Str(sku.ID),
|
||
DoSale: true,
|
||
}
|
||
_, err = api.JdAPI.BatchUpdateVendibility("", "", msg.StationNo, []*jdapi.StockVendibility{
|
||
vendibility,
|
||
}, userName)
|
||
}
|
||
if !msg.Have {
|
||
stock := &jdapi.SkuStock{
|
||
OutSkuId: utils.Int2Str(sku.ID),
|
||
StockQty: model.MaxStoreSkuStockQty,
|
||
}
|
||
_, err = api.JdAPI.BatchUpdateCurrentQtys("", "", msg.StationNo, []*jdapi.SkuStock{
|
||
stock,
|
||
}, userName)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
return jdapi.Err2CallbackResponse(err, "")
|
||
}
|
||
|
||
func OnNewPromotionMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
|
||
return createLocalPromotionFromRemote(utils.Str2Int64(msg.BillID))
|
||
}
|
||
|
||
func createLocalPromotionFromRemote(promotionInfoId int64) (retVal *jdapi.CallbackResponse) {
|
||
utils.CallFuncAsync(func() {
|
||
result, err := api.JdAPI.QueryPromotionInfo(promotionInfoId)
|
||
if err == nil {
|
||
db := dao.GetDB()
|
||
promotion := &model.Promotion{
|
||
VendorPromotionID: utils.Int64ToStr(promotionInfoId),
|
||
}
|
||
if err = dao.GetEntity(db, promotion, "VendorPromotionID"); dao.IsNoRowsError(err) {
|
||
storeIDMap := make(map[int64]int)
|
||
skuIDMap := make(map[int64]int)
|
||
skuMap := make(map[int64]*jdapi.PromotionLspQuerySkuResult)
|
||
// 注意，这样处理可能是有问题，我们假定的是门店信息与SKU信息的叉乘
|
||
for _, v := range result.SkuResultList {
|
||
storeIDMap[v.StationNo] = 1
|
||
skuIDMap[v.SkuID] = 1
|
||
skuMap[v.SkuID] = v
|
||
}
|
||
jdStoreIDs := make([]string, len(storeIDMap))
|
||
index := 0
|
||
for k := range storeIDMap {
|
||
jdStoreIDs[index] = utils.Int64ToStr(k)
|
||
index++
|
||
}
|
||
jdSkuIDs := jxutils.Int64Map2List(skuIDMap)
|
||
|
||
var skuList []*model.Sku
|
||
var storeMapList []*model.StoreMap
|
||
if err = dao.GetRows(db, &storeMapList, `
|
||
SELECT *
|
||
FROM store_map
|
||
WHERE vendor_id = ? AND deleted_at = ? AND vendor_store_id IN (`+
|
||
dao.GenQuestionMarks(len(jdStoreIDs))+")",
|
||
model.VendorIDJD, utils.DefaultTimeValue, jdStoreIDs); err != nil {
|
||
globals.SugarLogger.Warnf("createLocalPromotionFromRemote get storeMapList failed with error:%v", err)
|
||
return
|
||
}
|
||
if err = dao.GetRows(db, &skuList, `
|
||
SELECT *
|
||
FROM sku
|
||
WHERE jd_id IN (`+
|
||
dao.GenQuestionMarks(len(jdSkuIDs))+")",
|
||
jdSkuIDs); err != nil {
|
||
globals.SugarLogger.Warnf("createLocalPromotionFromRemote get skuList failed with error:%v", err)
|
||
return
|
||
}
|
||
jxStoreIDs := make([]int, len(storeMapList))
|
||
for k, v := range storeMapList {
|
||
jxStoreIDs[k] = v.StoreID
|
||
}
|
||
priceList := make([]*SkuPrice, len(skuList))
|
||
var skuResult *jdapi.PromotionLspQuerySkuResult
|
||
for k, v := range skuList {
|
||
skuResult = skuMap[v.JdID]
|
||
priceList[k] = &SkuPrice{
|
||
SkuID: v.ID,
|
||
PriceType: PriceTypePrice,
|
||
Price: skuResult.PromotionPrice,
|
||
LimitSkuCount: 0,
|
||
IsLock: 0,
|
||
}
|
||
}
|
||
// globals.SugarLogger.Debugf("jxStoreIDs:%s", utils.Format4Output(jxStoreIDs, false))
|
||
// globals.SugarLogger.Debugf("priceList:%s", utils.Format4Output(priceList, false))
|
||
source := strings.Trim(result.Source, "来源")
|
||
promotionParams := &PromotionParams{
|
||
Name: source + "-" + utils.Int64ToStr(result.PromotionInfoID),
|
||
Advertising: "",
|
||
Type: result.PromotionType,
|
||
BeginAt: result.BeginTime.GoTime(),
|
||
EndAt: result.EndTime.GoTime(),
|
||
StoreIDs: jxStoreIDs,
|
||
SkuPrices: priceList,
|
||
}
|
||
mapData := map[string]interface{}{
|
||
keyPromotionStatus: jd2jxPromotionStatusMap[result.PromotionState],
|
||
keyPromotionSource: source,
|
||
}
|
||
if skuResult != nil {
|
||
mapData[keyLimitDaily] = skuResult.LimitDaily
|
||
mapData[keyLimitDevice] = skuResult.LimitDevice
|
||
mapData[keyLimitPin] = skuResult.LimitPin
|
||
}
|
||
_, err = CreateJdPromotion(jxcontext.AdminCtx, model.VendorIDJD, false, true, false, utils.Int64ToStr(promotionInfoId), promotionParams, mapData)
|
||
if dao.IsDuplicateError(err) || err == ErrLimitDeviceIsInvalid {
|
||
err = nil
|
||
}
|
||
}
|
||
}
|
||
})
|
||
return jdapi.Err2CallbackResponse(nil, "")
|
||
}
|
||
|
||
func UpdatePromotionStatusFromRemote(ctx *jxcontext.Context, promotionID int) (err error) {
|
||
globals.SugarLogger.Debugf("UpdatePromotionStatusFromRemote promotionID:%d", promotionID)
|
||
|
||
db := dao.GetDB()
|
||
promotion := &model.Promotion{}
|
||
promotion.ID = promotionID
|
||
if err = dao.GetEntity(db, promotion); err != nil {
|
||
return err
|
||
}
|
||
result, err := api.JdAPI.QueryPromotionInfo(utils.Str2Int64(promotion.VendorPromotionID))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
newStatus := jd2jxPromotionStatusMap[result.PromotionState]
|
||
if newStatus != promotion.Status {
|
||
_, err = dao.UpdateEntityLogically(db, promotion, map[string]interface{}{
|
||
model.FieldStatus: newStatus,
|
||
}, ctx.GetUserName(), nil)
|
||
}
|
||
return err
|
||
}
|
||
|
||
func excelStr2Time(timeStr string) (tm time.Time, err error) {
|
||
return time.ParseInLocation("2006年1月2日15点4分5秒", timeStr, time.Local)
|
||
}
|
||
|
||
func getPromotionHander(promotionType int) JdPromotionHandler {
|
||
var promotionHandler JdPromotionHandler
|
||
if promotionType == PromotionTypeDirectDown {
|
||
promotionHandler = &JdDirectDownHandler{}
|
||
} else if promotionType == PromotionTypeLimitedTime {
|
||
promotionHandler = &JdLimitedTimeHandler{}
|
||
} else {
|
||
// panic(fmt.Sprintf("unknown promotion type:%d", promotionType))
|
||
return nil
|
||
}
|
||
if !globals.EnableJdStoreWrite {
|
||
promotionHandler = &JdNullHandler{}
|
||
}
|
||
return promotionHandler
|
||
}
|