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

package mtwm

import (
	"git.rosy.net.cn/baseapi/platformapi/mtwmapi"
	"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/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"
)

func actOrderRules2Mtwm(actOrderRules []*model.ActOrderRule) (actDetails []*mtwmapi.FullDiscountActDetail) {
	for _, v := range actOrderRules {
		actDetails = append(actDetails, &mtwmapi.FullDiscountActDetail{
			OriginalPrice: jxutils.IntPrice2Standard(v.SalePrice),
			ActPrice:      jxutils.IntPrice2Standard(v.DeductPrice),
		})
	}
	return actDetails
}

func storeSku2ActData(act *model.Act2, actStoreSku []*model.ActStoreSku2, handler func(int) bool) (actData []*mtwmapi.RetailDiscountActData) {
	for _, v := range actStoreSku {
		if handler == nil || handler(v.SyncStatus) {
			actData = append(actData, &mtwmapi.RetailDiscountActData{
				AppFoodCode: utils.Int2Str(v.SkuID),
				// UserType:    0,
				StartTime:  act.BeginAt.Unix(),
				EndTime:    act.EndAt.Unix(),
				OrderLimit: act.LimitCount,
				DayLimit:   act.LimitDaily,
				// Period:     "",
				// WeeksTime: "",
				SettingType: mtwmapi.SettingTypeAsPrice,
				ActPrice:    jxutils.IntPrice2Standard(v.ActPrice),
				// DiscountCoefficient: 0,
				Sequence: int(v.ActPrice),
				ItemID:   utils.Str2Int64WithDefault(v.VendorActID, 0),
			})
		}
	}
	return actData
}

func storeSku2ActData4Delete(actStoreSku []*model.ActStoreSku2, handler func(int) bool) (actIDList []string) {
	for _, v := range actStoreSku {
		if handler == nil || handler(v.SyncStatus) {
			if v.VendorActID != "" {
				actIDList = append(actIDList, v.VendorActID)
			}
		}
	}
	return actIDList
}

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) {
	actData := storeSku2ActData(act, actStoreSku, isCreateOrUpdate)
	if len(actData) > 0 {
		if globals.EnableMtwmStoreWrite {
			actResult, err2 := api.MtwmAPI.RetailDiscountBatchSave(storeMap.VendorStoreID, actData)
			if err = err2; err != nil {
				return err
			}
			actResultMap := make(map[string]*mtwmapi.RetailDiscountActResult)
			for _, v := range actResult {
				actResultMap[v.AppFoodCode] = v
			}
			for _, v := range actStoreSku {
				if result := actResultMap[utils.Int2Str(v.SkuID)]; result != nil {
					v.VendorActID = utils.Int64ToStr(result.ActID)
				}
			}
		} else {
			for _, v := range actStoreSku {
				v.VendorActID = utils.Int64ToStr(jxutils.GenFakeID())
			}
		}
	}
	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 {

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