jx-callback/business/partner/purchase/jd/act.go

package jd

import (
	"time"

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

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 {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.CreatePromotionSkuSingle(infoId, outInfoId, skus, traceId)
		} else {
			return api.JdAPI.CreatePromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
		}
	}
	return skusResult, err
}

func CancelPromotionSku(promotionType int, infoId int64, outInfoId string, skus []*jdapi.PromotionSku, traceId string) (err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.CancelPromotionSkuSingle(infoId, outInfoId, skus, traceId)
		} else {
			return api.JdAPI.CancelPromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
		}
	}
	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 getTraceID(ctx *jxcontext.Context) (traceID string) {
	traceID = ctx.GetUserName() + utils.GetUUID()
	return traceID
}

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.ActPrice,
				// LimitSkuCount:0,
			})
		}
	}
	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)
	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)
				}
			}
		}
	} else {

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

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