message/handler/activity/jyActivity.go

package activity

import (
	dateFormate "app.yhyue.com/moapp/jybase/date"
	"app.yhyue.com/moapp/jybase/go-logger/logger"
	"app.yhyue.com/moapp/jybase/redis"
	"app.yhyue.com/moapp/message/db"
	"app.yhyue.com/moapp/message/handler/award"
	"fmt"
	"github.com/gogf/gf/v2/os/gcfg"
	"github.com/gogf/gf/v2/os/gctx"
	"github.com/gogf/gf/v2/os/gtime"
	"github.com/gogf/gf/v2/util/gconv"
	"time"
)

/*
投标人专属免费计划
*/

type JyActivity struct {
	T1, T2, Ed   time.Time           //预热活动、开始时间、结束时间
	DailyClock   string              //预热活动每天开始时间
	ActivityCode string              //活动code
	Missions     map[string]struct { //任务
		Points   int `json:"points"`
		Schedule int `json:"schedule"`
	}
	ScheduleReward map[int]struct { //进度奖励
		SubVip   int `json:"subvip"`
		Schedule int `json:"schedule"`
	}
}

const (
	BidderPlanRedis           = "main" //redis缓存库名
	PowerCacheDb              = "newother"
	PowerCacheKey             = "bigmember_power_3_%s"
	IsGetUserBaseInfoRedisKey = "baseinfo_%s"

	BidderPlanScheduleCache  = "bidderPlan_v1_ScheduleValue_%s" //活动累计进度
	BidderPlanFastClickCheck = "bidderPlanFastClickValue_%s"    //防止连点

	BidderPlanScheduleAwardStatus = "bidderPlan_v1_ScheduleAward_%s_%d" //奖励领取状态

	BidderPlanBuySVipStatus        = "bidderPlanActivity_v1_BuySVipCacheKey_%s" //购买
	BidderPlanInviteMissionsStatus = "bidderPlanActivity_v1_InviteCacheKey_%s"  //邀请
	BidderPlanShareMissionsStatus  = "bidderPlanActivity_v1_ShareCacheKey_%s"   //分享
	BidderPlanDailyBoonKey         = "bidderPlanActivity_v1_DailyBoon_%s"       //领取每日限量福利
	BidderPlanHasDailyBoonKey      = "bidderPlanActivity_v1_HasDailyBoon_%s"    //是否领取过每日限量福利

	BidderPlanShare     = "bidderPlanActivity_v1_ShareOk_%s" //是否分享
	QuestionnaireSubmit = "questionnaireSubmit_%s"           //是否已提交问卷

)

var MembershipDay *JyActivity

func init() {
	MembershipDay = &JyActivity{
		T1: gtime.NewFromStrLayout(gcfg.Instance().MustGet(gctx.New(), "jyactivity.dateRange.t1").String(), "2006-01-02T15:04:05Z").Time,
		T2: gtime.NewFromStrLayout(gcfg.Instance().MustGet(gctx.New(), "jyactivity.dateRange.t2").String(), "2006-01-02T15:04:05Z").Time,
		Ed: gtime.NewFromStrLayout(gcfg.Instance().MustGet(gctx.New(), "jyactivity.dateRange.ed").String(), "2006-01-02T15:04:05Z").Time,
	}
	MembershipDay.DailyClock = gcfg.Instance().MustGet(gctx.New(), "jyactivity.dailyBoon.clock").String()
	MembershipDay.ActivityCode = gcfg.Instance().MustGet(gctx.New(), "jyactivity.code").String()
	//加载任务
	if loadMissionsErr := gcfg.Instance().MustGet(gctx.New(), "jyactivity.missions").Scan(&MembershipDay.Missions); loadMissionsErr != nil {
		logger.Error(fmt.Sprintf("JyBidderPlan 加载任务异常 %v", loadMissionsErr))
	}
	//加载进度奖励
	if loadScheduleErr := gcfg.Instance().MustGet(gctx.New(), "jyactivity.scheduleReward").Scan(&MembershipDay.ScheduleReward); loadScheduleErr != nil {
		logger.Error(fmt.Sprintf("JyBidderPlan 加载进度异常 %v", loadScheduleErr))
	}
}

// InActivity 是否在活动时间内
// bTime 是否在预热时间段内
// iTime 是否在正式活动时间内
// aTime  是否在全部活动时间内
func (BP *JyActivity) InActivity() (bTime, iTime, aTime bool) {
	now := time.Now()
	bTime = now.After(MembershipDay.T1) && now.Before(MembershipDay.T2)
	aTime = now.After(MembershipDay.T1) && now.Before(MembershipDay.Ed)
	if bTime {
		return
	}
	iTime = now.After(MembershipDay.T2) && now.Before(MembershipDay.Ed)
	return
}

// cacheLong 缓存时间
func (BP *JyActivity) cacheLong() int {
	return 60 * 60 * 24 * 30
}

// FastClickCheck 连点处理,防止重复领取
func (BP *JyActivity) FastClickCheck(userId string) bool {
	key := fmt.Sprintf(BidderPlanFastClickCheck, userId)
	if redis.Incr(BidderPlanRedis, key) == 1 {
		_ = redis.SetExpire(BidderPlanRedis, key, 1)
		return true
	}
	return false
}

// GetSchedule 查询活动任务进度
func (BP *JyActivity) GetSchedule(userId string) int {
	return -redis.GetInt(BidderPlanRedis, fmt.Sprintf(BidderPlanScheduleCache, userId))
}

func (BP *JyActivity) GetScheduleQuery(userId string, schedule int) (status int) {
	if BP.GetSchedule(userId) < schedule {
		return 0
	}
	key := fmt.Sprintf(BidderPlanScheduleAwardStatus, userId, schedule)
	if redis.Get(BidderPlanRedis, key) == nil {
		status = gconv.Int(redis.Incr(BidderPlanRedis, key))
		_ = redis.SetExpire(BidderPlanRedis, key, BP.cacheLong())
	} else {
		status = redis.GetInt(BidderPlanRedis, key)
	}
	if status > 1 {
		status = 1
	}
	return
}

// ScheduleGiven 活动任务进度奖励
func (BP *JyActivity) ScheduleGiven(userId string, schedule int) error {
	if _, inActivity, _ := BP.InActivity(); !inActivity {
		return fmt.Errorf("不在活动时间内")
	}
	if BP.GetScheduleQuery(userId, schedule) != 1 {
		return fmt.Errorf("非领取状态")
	}
	scheduleAward, ok := BP.ScheduleReward[schedule]
	if !ok {
		return fmt.Errorf("未知请求")
	}

	if err := award.GivenSubVip(userId, award.SubVip{
		Num:          gconv.Int64(scheduleAward.SubVip),
		ActivityCode: BP.ActivityCode,
		Desc:         fmt.Sprintf("达到%d剑鱼币", schedule),
		Date:         time.Now().Unix(),
	}); err != nil {
		return fmt.Errorf("领取奖励异常")
	}
	key := fmt.Sprintf(BidderPlanScheduleAwardStatus, userId, schedule)
	redis.Put(BidderPlanRedis, key, -1, BP.cacheLong())
	return nil
}

// AddSchedule 增加活动进度
func (BP *JyActivity) AddSchedule(userId string, value int) (after int) {
	if value > 0 {
		key := fmt.Sprintf(BidderPlanScheduleCache, userId)
		after = -gconv.Int(redis.Decrby(BidderPlanRedis, key, value))
		if value == after { //首次设置过期值
			_ = redis.SetExpire(BidderPlanRedis, key, BP.cacheLong())
		}
	}
	return
}

// FreeSubscribe 免费订阅
type FreeSubscribe struct {
	OAreaP map[string]interface{} `json:"o_area"`
	AKey   []interface{}          `json:"a_key"`
}

// MissionsSVipBuyQuery 购买超级订阅
// status:0 未完成 1 待领取 -1已领取
// 是否购买超级订阅
func (BP *JyActivity) MissionsSVipBuyQuery(userId string) (status int) {
	finish := func() bool {
		count := db.Mysql.CountBySql(`SELECT count(id) FROM dataexport_order WHERE product_type ='VIP订阅' AND order_money > 0 AND order_status>0  AND create_time > ? AND create_time < ? AND user_id=? `, BP.T2.Format(dateFormate.Date_Full_Layout), BP.Ed.Format(dateFormate.Date_Full_Layout), userId)
		if count > 0 {
			return true
		}
		return false
	}()

	if !finish {
		return 0
	}

	key := fmt.Sprintf(BidderPlanBuySVipStatus, userId)
	if redis.Get(BidderPlanRedis, key) == nil {
		status = gconv.Int(redis.Incr(BidderPlanRedis, key))
		_ = redis.SetExpire(BidderPlanRedis, key, BP.cacheLong())
	} else {
		status = redis.GetInt(BidderPlanRedis, key)
	}
	if status > 1 {
		status = 1
	}
	return
}

// MissionsSVipBuyGiven 订阅任务领取奖励
func (BP *JyActivity) MissionsSVipBuyGiven(userId string) error {
	if _, inActivity, _ := BP.InActivity(); !inActivity {
		return fmt.Errorf("不在活动时间内")
	}
	status := BP.MissionsSVipBuyQuery(userId)
	if status != 1 {
		return fmt.Errorf("非领取状态")
	}

	if givenPointsErr := award.GivenPoints(userId, award.Points{
		Num:          gcfg.Instance().MustGet(gctx.New(), "jyactivity.missions.buysubvip.points").Int64(),
		Type:         1010,
		ActivityCode: BP.ActivityCode,
		Desc:         "购买超级订阅任务完成",
		Date:         time.Now().Unix(),
	}); givenPointsErr != nil {
		return fmt.Errorf("领取奖励异常")
	}

	//设置已领取
	redis.Put(BidderPlanRedis, fmt.Sprintf(BidderPlanBuySVipStatus, userId), -1, BP.cacheLong())
	//增加任务进度
	BP.AddSchedule(userId, gcfg.Instance().MustGet(gctx.New(), "jyactivity.missions.buysubvip.schedule").Int())
	return nil
}

// MissionsInviteQuery 邀请任务状态查询
// status:0 未完成 1 待领取 -1已领取
func (BP *JyActivity) MissionsInviteQuery(userId string) (status int) {
	status = redis.GetInt(BidderPlanRedis, fmt.Sprintf(BidderPlanInviteMissionsStatus, userId))
	if status > 1 {
		status = 1
	}
	return status
}

// MissionsInviteGiven 邀请任务奖励领取
func (BP *JyActivity) MissionsInviteGiven(userId string) error {
	if _, inActivity, _ := BP.InActivity(); !inActivity {
		return fmt.Errorf("不在活动时间内")
	}
	status := BP.MissionsInviteQuery(userId)
	if status != 1 {
		return fmt.Errorf("非领取状态")
	}
	//领取
	if givenPointsErr := award.GivenPoints(userId, award.Points{
		Num:          gcfg.Instance().MustGet(gctx.New(), "jyactivity.missions.invite.points").Int64(),
		Type:         1008,
		ActivityCode: BP.ActivityCode,
		Desc:         "邀请领好礼任务完成",
		Date:         time.Now().Unix(),
	}); givenPointsErr != nil {
		return fmt.Errorf("领取奖励异常")
	}

	//设置已领取
	redis.Put(BidderPlanRedis, fmt.Sprintf(BidderPlanInviteMissionsStatus, userId), -1, BP.cacheLong())
	//增加任务进度
	BP.AddSchedule(userId, gcfg.Instance().MustGet(gctx.New(), "jyactivity.missions.invite.schedule").Int())
	return nil
}

// MissionsShareQuery 分享活动
// status:0 未完成 1 待领取 -1已领取
func (BP *JyActivity) MissionsShareQuery(userId string) (status int) {
	finished, _ := redis.Exists(BidderPlanRedis, fmt.Sprintf(BidderPlanShare, userId))
	if !finished {
		return 0
	}
	key := fmt.Sprintf(BidderPlanShareMissionsStatus, userId)
	if redis.Get(BidderPlanRedis, key) == nil {
		status = gconv.Int(redis.Incr(BidderPlanRedis, key))
		_ = redis.SetExpire(BidderPlanRedis, key, BP.cacheLong())
	} else {
		status = redis.GetInt(BidderPlanRedis, key)
	}
	if status > 1 {
		status = 1
	}
	return
}

// MissionsShareGiven 分享活动
func (BP *JyActivity) MissionsShareGiven(userId string) error {
	if _, inActivity, _ := BP.InActivity(); !inActivity {
		return fmt.Errorf("不在活动时间内")
	}
	status := BP.MissionsShareQuery(userId)
	if status != 1 {
		return fmt.Errorf("非领取状态")
	}

	if givenPointsErr := award.GivenPoints(userId, award.Points{
		Num:          gcfg.Instance().MustGet(gctx.New(), "jyactivity.missions.share.points").Int64(),
		Type:         1011,
		ActivityCode: BP.ActivityCode,
		Desc:         "分享活动任务完成",
		Date:         time.Now().Unix(),
	}); givenPointsErr != nil {
		return fmt.Errorf("领取奖励异常")
	}

	//设置已领取
	redis.Put(BidderPlanRedis, fmt.Sprintf(BidderPlanShareMissionsStatus, userId), -1, BP.cacheLong())
	//增加任务进度
	BP.AddSchedule(userId, gcfg.Instance().MustGet(gctx.New(), "jyactivity.missions.share.schedule").Int())
	return nil
}