xpggame/call/share.go

package call

import (
	"fmt"
	"reflect"
	"server/common"
	"server/db"
	"server/pb"
	"server/util"
	"time"

	"github.com/liangdas/mqant/log"
	"gorm.io/gorm"
)

func GetShareInfo(uid int) *common.ShareInfo {
	shareInfo := &common.ShareInfo{UID: uid}
	db.Mysql().Get(shareInfo)
	if shareInfo.ID <= 0 {
		info, _ := GetUserXInfo(uid, "channel_id")
		shareInfo.ChannelID = info.ChannelID
		shareInfo.Share = util.GetShareCode(uid)
		shareInfo.Time = time.Now().Unix()
		db.Mysql().Create(shareInfo)
	}
	return shareInfo
}
func GetShareInfoByCode(code string) *common.ShareInfo {
	shareInfo := &common.ShareInfo{Share: code}
	db.Mysql().Get(shareInfo)
	return shareInfo
}

// 分享查询
func ShareBind(share string, isOld bool, uid, cid int) {
	// 绑定
	if share == "" {
		return
	}
	activityId := 0
	now := time.Now().Unix()
	// 关联活动分享码
	codeInfo := &common.ShareActivityCode{ShareCode: share}
	upInfo := &common.ShareInfo{}
	db.Mysql().Get(codeInfo)
	if codeInfo.Id > 0 {
		upInfo.UID = codeInfo.UID
		activityId = codeInfo.ActivityId
		// 判断是否过期
		if now < codeInfo.ExpireAt {
			util.Go(func() {
				SendShareReward(cid, codeInfo.UID, codeInfo.ActivityId)
			})
		}
	} else {
		// 一级
		upInfo = &common.ShareInfo{Share: share}
	}
	db.Mysql().Get(upInfo)
	if upInfo.ID <= 0 {
		return
	}
	if !isOld {
		shareInfo := &common.ShareInfo{UID: uid, UP1: upInfo.UID, UP2: upInfo.UP1, UP3: upInfo.UP2, Time: time.Now().Unix(), ChannelID: cid, Share: util.GetShareCode(uid), ActivityId: activityId}
		db.Mysql().Create(shareInfo)
	} else {
		err := db.Mysql().Update(&common.ShareInfo{UID: uid}, map[string]interface{}{
			"up1": upInfo.UID,
			"up2": upInfo.UP1,
			"up3": upInfo.UP2,
		})
		if err != nil {
			log.Error("ShareBind err:%v", err)
		}
	}
	// 更新上级邀请玩家数
	db.Mysql().Update(&common.ShareInfo{UID: upInfo.UID}, map[string]interface{}{"invites": gorm.Expr("invites + 1")})

	// 完成邀请任务
	CheckTask(Task{Uid: upInfo.UID, Value: 1, Types: []common.TaskType{common.TaskTypeInvite}})
	// todo
	util.Go(func() {
		if upInfo.UID != 0 {
			err := db.Mysql().C().Model(&common.PddDataNew{}).Where("uid = ?", upInfo.UID).
				Updates(map[string]interface{}{
					"spin": gorm.Expr("spin + ?", 1),
				}).Error
			if err != nil {
				log.Error("update spin err, %s", err.Error())
				return
			}
		}
	})
}

// 判断分享,发放有效用户奖励
func CheckShare(r *common.RechargeOrder) {
	shareInfo := GetShareInfo(r.UID)
	// todo
	if GetConfigShareSys() == nil {
		return
	}
	reward := GetConfigShareSys().ShareReward
	// 付费分享
	// CheckShareTask(shareInfo.UP1, 1, common.TaskTypePayShare)
	// 发放奖励
	update := map[string]interface{}{
		"recharge_amount": gorm.Expr("recharge_amount + ?", r.Amount),
	}
	if shareInfo.BetAmount != -1 {
		update["bet_amount"] = gorm.Expr("bet_amount + ?", r.Amount)
	}
	db.Mysql().Update(&common.ShareInfo{UID: r.UID}, update)
	betAmount := shareInfo.BetAmount
	if betAmount == -1 {
		betAmount = 0
	}
	if shareInfo.RechargeAmount+r.Amount < GetConfigShareSys().ShareRecharge {
		return
	}
	if shareInfo.UP1 == 0 {
		return
	}
	if shareInfo.BetAmount >= 0 {
		db.Mysql().Update(&common.ShareInfo{UID: r.UID}, map[string]interface{}{
			"bet_amount": -1,
		})
		update = map[string]interface{}{
			"invalid_invites":  gorm.Expr("invalid_invites + 1"),
			"invite_reward":    gorm.Expr("invite_reward + ?", reward),
			"available_reward": gorm.Expr("available_reward + ?", reward),
		}
		db.Mysql().Update(&common.ShareInfo{UID: shareInfo.UP1}, update)
		ShareRecharge(r.UID, r.Amount+betAmount, 1)
		IncreaseInviteCount(fmt.Sprintf("%v", shareInfo.UP1), 1, false)
	} else {
		ShareRecharge(r.UID, r.Amount+betAmount, 2)
	}
}

func ShareRecharge(uid int, amount int64, typ int) {
	shareInfo := &common.ShareInfo{UID: uid}
	db.Mysql().Get(shareInfo)
	if shareInfo.UP1 == 0 {
		return
	}
	ref := reflect.ValueOf(shareInfo).Elem()
	// 循环查询上级
	for i := 1; i <= 3; i++ {
		upUid := int(ref.FieldByName(fmt.Sprintf("UP%d", i)).Int())
		if upUid == 0 {
			break
		}
		con := GetConfigShareByLevel(i)
		if con == nil {
			log.Error("unknown config share level:%v", i)
			continue
		}
		// 发奖
		reward := amount * con.Per / 1000
		if reward <= 0 {
			continue
		}
		db.Mysql().Update(&common.ShareInfo{UID: upUid}, map[string]interface{}{
			"bet_reward":       gorm.Expr("bet_reward + ?", reward),
			"available_reward": gorm.Expr("available_reward + ?", reward),
		})
		db.Mysql().Create(&common.ShareDetail{
			UID:            uid,
			Type:           typ,
			Up:             upUid,
			RechargeAmount: amount,
			Reward:         reward,
			Time:           time.Now().Unix(),
		})
	}
}

// 投注奖励结算
func ShareSettle(d *pb.InnerAfterSettle) {
	shareInfo := &common.ShareInfo{UID: int(d.UID)}
	db.Mysql().Get(shareInfo)
	if shareInfo.UP1 == 0 {
		return
	}
	db.Mysql().Update(&common.ShareInfo{UID: int(d.UID)}, map[string]interface{}{"bet": gorm.Expr("bet + ?", d.TotalBet)})

	ref := reflect.ValueOf(shareInfo).Elem()
	// 循环查询上级
	for i := 1; i <= 3; i++ {
		uid := int(ref.FieldByName(fmt.Sprintf("UP%d", i)).Int())
		if uid == 0 {
			break
		}
		con := GetConfigShareByLevel(i)
		if con == nil {
			log.Error("unknown config share level:%v", i)
			continue
		}
		// 发奖
		reward := d.TotalBet * con.Per / 1000
		if reward <= 0 {
			continue
		}
		db.Mysql().Update(&common.ShareInfo{UID: uid}, map[string]interface{}{
			"bet_reward":       gorm.Expr("bet_reward + ?", reward),
			"available_reward": gorm.Expr("available_reward + ?", reward),
		})
	}
}

func PackLevelSql(uid, level int) (sql string) {
	if level == 0 {
		sql = fmt.Sprintf("up1 = %d or up2 = %d or up3 = %d", uid, uid, uid)
	} else {
		sql = fmt.Sprintf("up%d = %d", level, uid)
	}
	return
}

// GetUserShares 查询玩家下级数量
func GetUserShares(uid, level int) int64 {
	return db.Mysql().Count(&common.ShareInfo{}, PackLevelSql(uid, level))
}

// GetUserShareRecharges 查询玩家下级充值人数
func GetUserShareRecharges(uid, level int) (count int64) {
	sql := fmt.Sprintf(`SELECT count(*) as count from 
	(SELECT uid from share_info WHERE %s)a
	INNER JOIN
	(SELECT uid from recharge_info WHERE total_recharge > 0)b
	on a.uid = b.uid`, PackLevelSql(uid, level))
	err := db.Mysql().C().Raw(sql).Scan(&count).Error
	if err != nil {
		log.Error("err:%v", err)
	}
	return
}

// GetUserShareValidRecharges 查询玩家下级有效充值人数
func GetUserShareValidRecharges(uid, level int) (count int64) {
	sql := fmt.Sprintf(`SELECT count(*) as count from 
	(SELECT uid from share_info WHERE %s)a
	INNER JOIN
	(SELECT uid from recharge_info WHERE total_recharge >= %d)b
	on a.uid = b.uid`, PackLevelSql(uid, level), GetConfigShareSys().ShareRecharge)
	err := db.Mysql().C().Raw(sql).Scan(&count).Error
	if err != nil {
		log.Error("err:%v", err)
	}
	return
}

// GetUserShareRechargeAmount 查询玩家下级充值总额
func GetUserShareRechargeAmount(uid, level int) (count int64) {
	sql := fmt.Sprintf(`SELECT sum(b.total_recharge) as count from 
	(SELECT uid from share_info WHERE %s)a
	INNER JOIN
	(SELECT uid,total_recharge from recharge_info WHERE total_recharge > 0)b
	on a.uid = b.uid`, PackLevelSql(uid, level))
	err := db.Mysql().C().Raw(sql).Scan(&count).Error
	if err != nil {
		log.Error("err:%v", err)
	}
	return
}

// GetActivityShareCode 根据actid获取share code
func GetActivityShareCode(uid, actId int) (code string, err error) {
	now := time.Now()
	ret := make([]*common.ShareActivityCode, 0, 1)
	_, err = db.Mysql().QueryList(0, 1, fmt.Sprintf("uid = %d and activity_id = %d ", uid, actId), "id", &common.ShareActivityCode{}, &ret)
	if err != nil {
		log.Error("GetActivityShareCode err:%v", err)
		return
	}
	expireTime := util.GetZeroTime(now.AddDate(0, 0, 1))
	if len(ret) == 0 {
		code = util.GetShareCode(-uid - actId)
		err = db.Mysql().Create(&common.ShareActivityCode{
			UID:        uid,
			ShareCode:  code,
			ActivityId: actId,
			ExpireAt:   expireTime.Unix(),
			CreateAt:   now.Unix(),
		})
		if err != nil {
			log.Error("GetActivityShareCode err:%v", err)
			return
		}
	} else {
		code = ret[0].ShareCode
		_, err = db.Mysql().UpdateRes(&common.ShareActivityCode{UID: uid, ActivityId: actId}, map[string]interface{}{
			"expire_at": expireTime.Unix(),
		})
		if err != nil {
			log.Error("GetActivityShareCode err:%v", err)
		}
	}
	return
}

// SendShareReward 发送分享奖励
func SendShareReward(channel, uid, actId int) {
	log.Info("SendShareReward channel:%v,uid:%v,actId:%d", channel, uid, actId)
	if common.ActivityIDFreeSpin == actId {
		freespin := GetUserFreeSpinData(uid)
		now := time.Now().Unix()
		if freespin.LastSpin == 0 && freespin.SpinNum == 0 {
			// 未参与活动
			p, _ := GetUserXInfo(uid, "birth")
			data := &common.ActivityFreeSpinData{UID: uid, SpinNum: common.DefaultFreeSpinNum}
			if util.IsSameDayTimeStamp(now, p.Birth) {
				data.LastSpin = now
			}
			err := db.Mysql().Create(data)
			if err != nil {
				log.Error("SendShareReward uid:%v,err:%v", uid, err)
			}
		} else {
			_, err := db.Mysql().UpdateRes(&common.ActivityFreeSpinData{UID: uid},
				map[string]interface{}{"last_spin": now, "spin_num": gorm.Expr("spin_num + ?", 1)})
			if err != nil {
				log.Error("SendShareReward uid:%v,err:%v", uid, err)
			}
		}
	} else if common.ActivityIDSign == actId {
		// 判断今日参与签到
		// 如果参与就再发送奖励，同时发送邮件
		list := GetConfigActivitySign()
		data := &common.ActivitySignData{UID: uid}
		db.Mysql().Get(data)
		first := util.GetZeroTime(time.Unix(data.Time, 0)).Unix()
		today := util.GetZeroTime(time.Now()).Unix()
		day := int((today-first)/common.OneDay) + 1
		log.Info("SendShareReward day:%v", day)
		// 给前两天
		if day > 2 {
			return
		}
		sign := data.Sign
		for i := 0; i < day; i++ {
			if sign&1 == 1 && day == i+1 {
				// 发放当日奖励
				for _, v := range list {
					if v.Day == day {
						reward := v.Reward
						log.Info("SendShareReward reward:%v", reward)
						UpdateCurrencyPro(&common.UpdateCurrency{
							CurrencyBalance: &common.CurrencyBalance{
								UID:       uid,
								Type:      common.CurrencyINR,
								ChannelID: channel,
								Value:     reward,
								Event:     common.CurrencyEventActivitySign,
								NeedBet:   GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward),
							},
						})
						break
					}
				}
				break
			}
			sign >>= 1
		}
	}
}