xpggame/modules/web/handler/share.go

package handler

import (
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	"gorm.io/gorm"
	"server/call"
	"server/common"
	"server/config"
	"server/db"
	"server/modules/web/app"
	"server/modules/web/values"
	"server/util"
	"time"
)

// 分享新手任务[done]
func ShareNewTaskInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	resp := &values.ShareNewTaskInfoResp{}
	a.Data = resp
	list := []common.ShareTaskNewData{}
	db.Mysql().QueryAll(fmt.Sprintf("uid = %d", a.UID), "", &common.ShareTaskNewData{}, &list)
	for _, v := range list {
		one := values.OneShareNewTask{
			TaskID:  v.TaskID,
			Desc:    v.GetDesc(),
			Type:    v.Type,
			Progess: v.Progress,
			Target:  v.Target,
			Reward:  v.Reward,
		}
		if one.Progess >= one.Target || v.Status == 1 {
			one.Progess = one.Target
			if v.Status == 1 {
				one.Status = 2
			} else {
				one.Status = 1
			}
		}
		resp.TaskList = append(resp.TaskList, one)
	}
}

// 新手任务领取[done]
func ShareNewTaskDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.ShareNewTaskDrawReq)
	if !a.S(req) {
		return
	}
	resp := &values.ShareNewTaskDrawResp{}
	a.Data = resp

	uid := a.UID

	if !db.Redis().Lock(common.GetRedisKeyShare(uid)) {
		a.Code = values.CodeRetry
		return
	}
	defer func() {
		db.Redis().UnLock(common.GetRedisKeyShare(uid))
	}()

	task := &common.ShareTaskNewData{UID: uid, TaskID: req.TaskID}
	db.Mysql().Get(task)
	if task.ID == 0 || task.Progress < task.Target {
		a.Code = values.CodeParam
		a.Msg = "Task not completed."
		return
	}
	if task.Status == 1 {
		a.Code = values.CodeParam
		a.Msg = "Task received."
		return
	}
	rows, err := db.Mysql().UpdateWRes(&common.ShareTaskNewData{}, map[string]interface{}{"status": 1}, fmt.Sprintf("uid = %d and task_id = %d and status = 0", uid, req.TaskID))
	if rows == 0 || err != nil {
		a.Code = values.CodeRetry
		return
	}
	call.UpdateShare(uid, 3, task.Reward, fmt.Sprintf("%d", task.Target))
	resp.Reward = task.Reward
}

func ShareNewAffiliate(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.ShareNewAffiliateReq)
	if !a.S(req) {
		return
	}
	if req.Num > 50 {
		req.Num = 50
	}

	resp := &values.ShareNewAffiliateResp{}
	a.Data = resp

	si := &common.ShareInfo{UID: a.UID}
	db.Mysql().Get(si)
	if si.ID == 0 {
		return
	}
	resp.Level1 = si.Down1
	resp.Level2 = si.Down2
	resp.Level3 = si.Down3
	resp.Level4 = si.Down4
	resp.Level5 = si.Down5
	list := []common.ShareInfo{}
	sql := fmt.Sprintf("up1 = %d", a.UID)
	if req.Level > 0 {
		sql = fmt.Sprintf("up%d = %d", req.Level, a.UID)
	}
	resp.Count, _ = db.Mysql().QueryList(req.Page, req.Num, sql, "down1 desc", &common.ShareInfo{}, &list)
	for _, v := range list {
		one := values.OneShareNewAffiliate{UID: v.UID, AffiliateCount: v.Down1}
		p, _ := call.GetUserXInfo(v.UID, "nick", "last_login")
		one.Nick = p.Nick
		one.LastLogin = p.LastLogin
		resp.AffiliateList = append(resp.AffiliateList, one)
	}
}

// 收益列表
func ShareNewCommission(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.ShareNewCommissionReq)
	if !a.S(req) {
		return
	}
	resp := &values.ShareNewCommissionResp{Count: 100, List: []values.OneShareNewCommission{}}
	a.Data = resp
	total := &common.ShareRewardData{UID: a.UID}
	db.Mysql().QueryBySql(fmt.Sprintf("select * from share_reward_data where uid = %d and time = 0", a.UID), total)
	resp.All = total.TotalReward
	resp.Invitation = total.InviteReward
	resp.Affiliate = total.AffiliateReward
	resp.Recharge = total.RechargeReward
	resp.Other = total.OtherReward

	if req.Num*req.Page >= 100 {
		return
	}
	list := []common.ShareRewardData{}
	db.Mysql().QueryList(0, 100, fmt.Sprintf("uid = %d", a.UID), "time desc", &common.ShareRewardData{}, &list)
	now := time.Now()
	zero := util.GetZeroTime(now)
	if req.Page > 0 {
		zero = zero.AddDate(0, 0, -req.Page*req.Num)
	}
	for i := 0; i < req.Num; i++ {
		one := values.OneShareNewCommission{Date: zero.Format("20060102")}
		for _, v := range list {
			if v.Date == one.Date {
				one.Invitation = v.InviteReward
				one.Recharge = v.RechargeReward
				one.Affiliate = v.AffiliateReward
				one.Other = v.OtherReward
				break
			}
		}
		resp.List = append(resp.List, one)
		zero = zero.AddDate(0, 0, -1)
	}
}

// 排行榜
func ShareNewRank(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.ShareNewRankReq)
	if !a.S(req) {
		return
	}
	resp := &values.ShareNewRankResp{
		List: []*common.ShareRank{},
	}
	a.Data = resp

	now := time.Now()
	dayNow := now
	for i := 0; i < 7; i++ {
		resp.Days = append(resp.Days, dayNow.Format("01/02"))
		dayNow = dayNow.AddDate(0, 0, -1)
	}
	weekNow := util.GetWeekZeroTime(now)
	for i := 0; i < 4; i++ {
		resp.Weeks = append(resp.Weeks, fmt.Sprintf("%s-%s", weekNow.Format("01/02"), weekNow.AddDate(0, 0, 7).Format("01/02")))
		weekNow = weekNow.AddDate(0, 0, -7)
	}
	monthNow := util.GetFirstDateOfMonth(now)
	for i := 0; i < 3; i++ {
		resp.Months = append(resp.Months, fmt.Sprintf("%s-%s", monthNow.Format("01/02"), monthNow.AddDate(0, 1, 0).Format("01/02")))
		monthNow = monthNow.AddDate(0, -1, 0)
	}

	var list []*common.ShareRank
	resp.Self = &common.ShareRank{
		UID:  a.UID,
		Type: req.Type,
		Rank: -1,
	}
	if req.Time == 0 {
		resp.Self.Time = time.Now().Unix()
		switch req.Type {
		case common.ShareRankTypeDaily:
			list = values.ShareRankDaily
		case common.ShareRankTypeWeekly:
			list = values.ShareRankWeekly
		case common.ShareRankTypeMonthly:
			list = values.ShareRankMonthly
		}
	} else {
		var ti int64
		switch req.Type {
		case common.ShareRankTypeDaily:
			ti = util.GetZeroTime(now.AddDate(0, 0, -req.Time)).Unix()
		case common.ShareRankTypeWeekly:
			ti = util.GetWeekZeroTime(now.AddDate(0, 0, -req.Time*7)).Unix()
		case common.ShareRankTypeMonthly:
			ti = util.GetFirstDateOfMonth(now.AddDate(0, -req.Time, 0)).Unix()
		}
		resp.Self.Time = ti
		list = call.GetShareRank(req.Type, ti)
	}
	for i, v := range list {
		v.Rank = i + 1
		if v.UID == a.UID {
			resp.Self = v
		}
	}
	if resp.Self.Rank == -1 {
		resp.Self = call.GetShareRewardData(a.UID, req.Type, resp.Self.Time)
		resp.Self.Rank = -1
	}
	start := req.Page * req.Num
	if start > common.ShareRankMaxNum {
		return
	}
	if start > len(list) {
		return
	}
	end := start + req.Num
	if end > common.ShareRankMaxNum {
		end = common.ShareRankMaxNum
	}
	if end > len(list) {
		end = len(list)
	}
	resp.List = list[start:end]
}

func ShareNewBroadcast(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	// req := new(values.ShareNewBroadcastReq)
	// if !a.S(req) {
	// 	return
	// }
	// if req.Num > 100 {
	// 	req.Num = 100
	// }

	resp := &values.ShareNewBroadcastResp{List: values.ShareWithdrawBroadcast}
	a.Data = resp
}

func ShareNewWithdrawInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	resp := &values.ShareNewWithdrawInfoResp{Tips: call.GetConfigPlatform().WithdrawTips}
	a.Data = resp
	si := call.GetShareInfo(a.UID)
	resp.TotalBalance = si.Reward
	resp.Withdrawable = si.Withdrawable
	list := call.GetConfigWithdrawProduct(common.WithdrawSorceShare)
	db.Mysql().QueryList(0, 3, fmt.Sprintf("uid = %d and draw_type = '%s'", a.UID, common.WithdrawTypeBank), "id desc", &common.PayInfo{}, &resp.Accounts)
	sw := call.GetShareWithdrawInfo(a.UID)
	resp.WithDrawCount = sw.DayCount
	for _, v := range list {
		// todo
		one := &values.WithdrawProduct{ID: v.ProductID, Amount: v.Amount}
		resp.List = append(resp.List, one)
	}

	con := call.GetConfigShare(si.Level, a.Channel)
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	resp.TotalWithdrawCount = con.DayWithdrawCount
	channels := call.GetConfigWithdrawChannels()
	if len(channels) > 0 {
		resp.NewList = []*common.ConfigWithdrawChannels{channels[0]}
	} else {
		resp.NewList = []*common.ConfigWithdrawChannels{}
	}
}

func ShareNewWithdraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	req := new(values.WithdrawReq)
	if !a.S(req) {
		return
	}
	if req.CurrencyType != common.CurrencyINR {
		req.CurrencyType = common.CurrencyINR
	}

	one := call.GetConfigWithdrawProductByID(req.AmountID)
	if one == nil {
		a.Code = values.CodeParam
		a.Msg = "Withdraw product not found."
		return
	}

	uid := a.UID
	log.Debug("player %v withdraw %+v,one:%+v", uid, *req, *one)

	amount := one.Amount * 100
	si := call.GetShareInfo(uid)
	if si.Withdrawable < amount {
		a.Code = values.CodeParam
		a.Msg = "Insufficient balance."
		return
	}

	con := call.GetConfigShare(si.Level, a.Channel)
	if con == nil {
		a.Code = values.CodeRetry
		return
	}

	sw := call.GetShareWithdrawInfo(uid)
	if sw.DayCount >= con.DayWithdrawCount {
		a.Code = values.CodeParam
		a.Msg = "Withdrawal limit."
		return
	}

	// 到游戏账户
	if req.Type == 1 {
		tx := db.Mysql().Begin()
		defer a.MCommit(tx)
		// 更新余额
		res := tx.Model(&common.ShareInfo{}).Where("uid = ? and reward >= ? and withdrawable >= ?", uid, amount, amount).
			Updates(map[string]interface{}{
				"reward":       gorm.Expr("reward - ?", amount),
				"withdrawable": gorm.Expr("withdrawable - ?", amount),
			})
		if res.RowsAffected == 0 || res.Error != nil {
			log.Error("err:%v", res.Error)
			a.Code = values.CodeRetry
			return
		}
		// 更新次数
		res = tx.Model(&common.ShareWithdrawInfo{}).Where("uid = ? and day_time = ?", uid, sw.DayTime).
			Updates(map[string]interface{}{"day_count": sw.DayCount + 1, "day_time": time.Now().Unix(), "total_withdraw": gorm.Expr("total_withdraw + ?", one.Amount)})
		if res.RowsAffected == 0 || res.Error != nil {
			log.Error("err:%v", res.Error)
			a.Code = values.CodeRetry
			return
		}
		// 更新rechargeinfo,转移到游戏等同于充值
		re := call.GetRechargeInfo(uid)
		if re.ID == 0 {
			res = tx.Model(&common.RechargeInfo{}).Create(&common.RechargeInfo{UID: uid, TotalRecharge: one.Amount})
		} else {
			res = tx.Model(&common.RechargeInfo{}).Where("uid = ? ", uid).
				Updates(map[string]interface{}{
					"total_charge": gorm.Expr("total_charge + ?", one.Amount),
				})
		}
		if res.RowsAffected == 0 || res.Error != nil {
			log.Error("err:%v", res.Error)
			a.Code = values.CodeRetry
			return
		}
		db.Mysql().Create(&common.RechargeOrder{
			UID:      uid,
			OrderID:  util.NewOrderID(uid, config.GetBase().ServerFlag),
			APIPayID: "",
			// ProductID:    common.ActivityIDPddShare,
			Amount:       one.Amount,
			WithdrawCash: amount,
			Status:       common.StatusROrderFinish,
			PaySource:    common.PaySourceModulePay,
			Event:        int(common.CurrencyEventShareWithdraw),
			// PayAccount:   payInfo,
			// Extra:      strconv.FormatInt(serviceFee, 10),
			CallbackTime: time.Now().Unix(),
			ChannelID:    a.Channel,
			UPI:          -1,
			Scene:        common.ActivityIDShare,
		})
		_, err := call.UpdateCurrencyPro(&common.UpdateCurrency{
			CurrencyBalance: &common.CurrencyBalance{
				UID:   uid,
				Value: amount * -1,
				Event: common.CurrencyEventShareWithdraw,
				Type:  common.CurrencyINR,
			},
		})
		if err != nil {
			a.Code = values.CodeRetry
			return
		}
		a.Msg = "Withdraw to game successfully."
		return
	}

	ip := a.GetRemoteIP()
	payInfo, code := NewWithdraw(req, a.UID, ip, a.UUID)
	if code != values.CodeOK {
		a.Code = code
		a.Msg = payInfo
		return
	}

	tx := db.Mysql().Begin()
	defer a.MCommit(tx)

	// 发起tx
	// 更新余额
	res := tx.Model(&common.ShareInfo{}).Where("uid = ? and reward >= ? and withdrawable >= ?", uid, amount, amount).
		Updates(map[string]interface{}{
			"reward":       gorm.Expr("reward - ?", amount),
			"withdrawable": gorm.Expr("withdrawable - ?", amount),
		})
	if res.RowsAffected == 0 || res.Error != nil {
		log.Error("err:%v", res.Error)
		a.Code = values.CodeRetry
		return
	}

	// 更新次数
	sw.SubRecord[one.Amount]++
	byt, _ := json.Marshal(sw.SubRecord)
	res = tx.Model(&common.ShareWithdrawInfo{}).Where("uid = ? and day_time = ?", uid, sw.DayTime).
		Updates(map[string]interface{}{"day_count": sw.DayCount + 1, "day_time": time.Now().Unix(), "record": string(byt),
			"total_withdraw": gorm.Expr("total_withdraw + ?", one.Amount)})
	if res.RowsAffected == 0 || res.Error != nil {
		log.Error("err:%v", res.Error)
		a.Code = values.CodeRetry
		return
	}

	orderID := util.NewOrderID(uid, config.GetBase().ServerFlag)

	order := &common.RechargeOrder{
		UID:          uid,
		OrderID:      orderID,
		APIPayID:     "",
		ProductID:    one.ProductID,
		Amount:       one.Amount,
		WithdrawCash: amount,
		Status:       common.StatusROrderCreate,
		PaySource:    common.PaySourceModulePay,
		Event:        int(common.CurrencyEventWithDraw),
		PayAccount:   payInfo,
		// Extra:      strconv.FormatInt(serviceFee, 10),
		ChannelID: a.Channel,
		UPI:       -1,
		Scene:     common.ActivityIDShare,
	}
	if config.GetBase().Release && amount < con.WithdrawAudit {
		order.Status = common.StatusROrderWaitting
	}
	if err := tx.Model(order).Create(order).Error; err != nil {
		a.Code = values.CodeRetry
		log.Error("create withdraw order fail err:%v", err)
		return
	}

	a.Data = values.ShareNewWithdrawResp{TotalBalance: si.Reward - amount, Withdrawable: si.Withdrawable - amount}
}

func ShareNewWithdrawHis(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	req := new(values.ShareNewWithdrawHisReq)
	if !a.S(req) {
		return
	}
	if req.Num > 100 {
		req.Num = 100
	}

	resp := &values.ShareNewWithdrawHisResp{}
	a.Data = resp
	list, count := call.GetShareWithdrawHis(a.UID, req.Page, req.Num)
	resp.Count = count
	for i, v := range list {
		if v.Status <= common.StatusROrderCreate {
			list[i].Status = common.StatusROrderPay
		} else if v.Status == common.StatusROrderRefuse || v.Status == common.StatusROrderCancel {
			list[i].Status = common.StatusROrderFail
		}
		one := common.WithdrawCommon{}
		if v.PayAccount != "" {
			err := json.Unmarshal([]byte(v.PayAccount), &one)
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
		}
		list[i].PayAccount = one.BankCardNo
		resp.List = append(resp.List, values.OneShareNewWithdrawHis{
			CreatedAt:    v.CreatedAt.Format("2006-01-02 15:04:05"),
			OrderID:      v.OrderID,
			PayAccount:   v.PayAccount,
			UID:          v.UID,
			Amount:       v.Amount,
			Event:        v.Event,
			ProductID:    v.ProductID,
			Status:       v.Status,
			FailReason:   v.FailReason,
			ChannelID:    v.ChannelID,
			UPI:          v.UPI,
			Scene:        v.Scene,
			WithdrawCash: v.WithdrawCash,
		})
	}
}

// todo

// ShareCfg 分享配置数据
func ShareCfg(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDShare) {
		return
	}
	resp := &values.ShareCfgResp{}
	a.Data = resp
	resp.ShareCfg = call.GetConfigShareAll()
	shareInfo := call.GetShareInfo(a.UID)
	resp.ShareLevel = shareInfo.Level
	resp.InviteCount = shareInfo.Down1 + shareInfo.Down2 + shareInfo.Down3 + shareInfo.Down4 + shareInfo.Down5
	resp.BetCount = shareInfo.BetAmountTeam
	resp.Amount = shareInfo.Withdrawable
	resp.TotalAward = shareInfo.Reward
	err := db.Mysql().C().Model(&common.ShareReward{}).
		Select("COALESCE(SUM(reward_count), 0) as todayAmount").
		Where("uid = ? and reward_at > ? and reward_count > 0 ", a.UID, util.GetZeroTime(time.Now()).Unix()).
		Scan(&resp.TodayAward).Error
	if err != nil {
		log.Error("get todayAmount err, %s", err.Error())
	}
	if resp.TotalAward == 0 {
		resp.TotalAward = shareInfo.Reward
	}

	resp.ShareLink = call.GetShareLink(a.Channel, a.UID)
}

// Reward 奖励页面数据
func Reward(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	resp := &values.RewardResp{}
	a.Data = resp
	if !a.CheckActivityExpire(common.ActivityIDShare) {
		return
	}
	jackpot, _ := call.ShareRankJackpotGet()
	resp.JackPot = jackpot
	weekAt := util.GetWeekZeroTime(time.Now())
	shareRankUsers, _, err := call.ShareRankUserGet(1, 3, weekAt, false)
	if err != nil {
		log.Error("get share rank user err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}
	resp.TopUsers = make([]values.ShareRankUser, 0, len(shareRankUsers))
	rankAwards := call.GetConfigShareRankAwardMap()
	for index, shareRankUser := range shareRankUsers {
		var userAward int
		var userAwardExpected int64
		rank := index + 1
		if rankAwards != nil {
			if rankAward, ok := rankAwards[index+1]; ok {
				userAward = rankAward.AwardRate
				userAwardExpected = jackpot * int64(rankAward.AwardRate) / 10000
			}
		}
		resp.TopUsers = append(resp.TopUsers, values.ShareRankUser{
			UserRank:          rank,
			UserName:          shareRankUser.UserInfo.Nick,
			UserCount:         shareRankUser.RankValue,
			UserIcon:          shareRankUser.UserInfo.Avatar,
			UserAward:         userAward,
			UserAwardExpected: userAwardExpected,
		})
	}

	// 任务详情
	list := []common.ShareTaskNewData{}
	_, err = db.Mysql().QueryAll(fmt.Sprintf("uid = %d", a.UID), "", &common.ShareTaskNewData{}, &list)
	if err != nil {
		log.Error("get task info err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}
	if len(list) == 0 { // 任务初始化
		con := call.GetConfigShareTaskNew()
		for _, v := range con {
			task := &common.ShareTaskNewData{UID: a.UID, TaskID: v.TaskID, Type: v.Type, Progress: 0, Target: v.Target, Reward: v.Reward, Condition: v.Condition}
			if v.Type == common.ShareTaskNewTypeFirst {
				task.Progress = 1
			}
			db.Mysql().Create(task)
		}
		_, err = db.Mysql().QueryAll(fmt.Sprintf("uid = %d", a.UID), "", &common.ShareTaskNewData{}, &list)
		if err != nil {
			log.Error("get task info err, %s", err.Error())
			a.Code = values.CodeRetry
			return
		}
	}
	for _, v := range list {
		one := values.OneShareNewTask{
			TaskID:  v.TaskID,
			Desc:    v.GetDesc(),
			Type:    v.Type,
			Progess: v.Progress,
			Target:  v.Target,
			Reward:  v.Reward,
		}
		if one.Progess >= one.Target || v.Status == 1 {
			one.Progess = one.Target
			if v.Status == 1 {
				one.Status = 2
			} else {
				one.Status = 1
			}
		}
		resp.TaskList = append(resp.TaskList, one)
	}

	err = db.Mysql().C().Model(&common.ShareReward{}).
		Select("COALESCE(SUM(reward_count), 0) as inviteAmount").
		Where("uid = ? and reward_type = 4", a.UID).
		Scan(&resp.InviteRewardTotal).Error
	if err != nil {
		log.Error("get todayAmount err, %s", err.Error())
	}
	shareInfo := call.GetShareInfo(a.UID)
	shareCfg := call.GetConfigShare(shareInfo.Level, a.Channel)
	resp.InviteReward = shareCfg.InviteRebate
	resp.BeInviteReward = shareCfg.BeInviteRebate
	resp.InviteCount = shareInfo.Down1
}

// RewardDetails 玩家奖励详情
func RewardDetails(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	req := new(values.RewardDetailsReq)
	if !a.S(req) {
		return
	}
	resp := &values.RewardDetailsResp{}
	a.Data = resp
	if !a.CheckActivityExpire(common.ActivityIDShare) {
		return
	}

	mdb := db.Mysql().C().Model(&common.ShareReward{}).Where("uid = ?", a.UID)
	if req.RewardType != 0 {
		mdb = mdb.Where("reward_type = ?", req.RewardType)
	}
	if req.StartAt != 0 {
		mdb = mdb.Where("reward_at >= ?", req.StartAt)
	}
	if req.EndAt != 0 {
		mdb = mdb.Where("reward_at <= ?", req.EndAt)
	}
	err := mdb.Count(&resp.Total).Error
	if err != nil {
		log.Error("get total err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}
	// 计算奖励金额总和
	var rewardAmount int64
	err = mdb.Select("COALESCE(SUM(reward_count), 0)").Row().Scan(&rewardAmount)
	if err != nil {
		log.Error("get reward amount err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}
	resp.RewardAmount = rewardAmount
	err = mdb.Order("reward_at desc").Offset((req.Page - 1) * req.PageSize).Limit(req.PageSize).Find(&resp.List).Error
	if err != nil {
		log.Error("get list err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}
}

// RankDetails 排行榜详情
func RankDetails(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	req := new(values.RankDetailsReq)
	if !a.S(req) {
		return
	}
	resp := &values.RankDetailsResp{}
	a.Data = resp
	if !a.CheckActivityExpire(common.ActivityIDShare) {
		return
	}

	rankAt := util.GetWeekZeroTime(time.Now())
	if req.Previous {
		rankAt = rankAt.AddDate(0, 0, -7)
	}

	log.Debug("share rankDetails, %+v rankAt:%d", req, rankAt.Unix())
	shareRankUsers, count, err := call.ShareRankUserGet(req.Page, req.PageSize, rankAt, true)
	if err != nil {
		log.Error("get rank user err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}

	jackpot, _ := call.ShareRankJackpotGet()
	if req.Previous {
		jackpot = call.ShareRankJackpotPreGet()
		resp.LessJackPot = call.ShareRankJackpotPreLessGet()
	}
	resp.JackPot = jackpot
	resp.Total = count

	rankAwards := call.GetConfigShareRankAwardMap()
	for index, shareRankUser := range shareRankUsers {
		var userAward int
		var userAwardExpected int64
		rank := (req.Page-1)*req.PageSize + index + 1
		if !req.Previous {
			if rankAwards != nil {
				if rankAward, ok := rankAwards[rank]; ok {
					userAward = rankAward.AwardRate
					userAwardExpected = jackpot * int64(rankAward.AwardRate) / 10000
				}
			}
		} else {
			rank = shareRankUser.Rank
			userAward = shareRankUser.UserAward
			userAwardExpected = shareRankUser.UserAwardCount
		}
		resp.RankUsers = append(resp.RankUsers, values.ShareRankUser{
			UserRank:          rank,
			UserName:          shareRankUser.UserInfo.Nick,
			UserCount:         shareRankUser.RankValue,
			UserIcon:          shareRankUser.UserInfo.Avatar,
			UserAward:         userAward,
			UserAwardExpected: userAwardExpected,
		})
	}
}

func ShareBanner(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	resp := &values.ShareBannerResp{}
	a.Data = resp

	shareBanners := call.GetConfigShareBanner()
	if len(shareBanners) == 0 {
		return
	}
	shareBanner := shareBanners[0]

	resp.SearchWord = shareBanner.SearchWord
	resp.JpgUrl = shareBanner.URL
	resp.Desc = shareBanner.Desc

	shareInfo := call.GetShareInfo(a.UID)
	resp.ShareCode = shareInfo.Share
	resp.ShareLink = call.GetShareLink(a.Channel, a.UID)
}

func ShareWithdraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	req := new(values.ShareWithdrawReq)
	if !a.S(req) {
		return
	}

	if req.Opt == 0 {
		req.Opt = 1
	}

	uid := a.UID

	if !db.Redis().Lock(common.GetRedisKeyShare(uid)) {
		a.Code = values.CodeRetry
		return
	}
	defer func() {
		db.Redis().UnLock(common.GetRedisKeyShare(uid))
	}()

	if req.Amount < 0 {
		a.Code = values.CodeParam
		a.Msg = "Insufficient Amount."
		return
	}
	shareInfo := call.GetShareInfo(uid)
	if shareInfo.Reward < req.Amount {
		a.Code = values.CodeParam
		a.Msg = "Insufficient balance."
		return
	}

	con := call.GetConfigShare(shareInfo.Level, a.Channel)
	if con == nil {
		a.Code = values.CodeRetry
		return
	}

	shareWithdrawInfo := call.GetShareWithdrawInfo(uid)
	if shareWithdrawInfo.DayCount >= con.DayWithdrawCount {
		a.Code = values.CodeParam
		a.Msg = fmt.Sprintf("Your current agent level is %d, with a maximum of %d withdrawals per day.", shareInfo.Level, con.DayWithdrawCount)
		return
	}
	if shareWithdrawInfo.TodayWithdraw+req.Amount >= con.WithdrawAudit {
		a.Code = values.CodeParam
		a.Msg = fmt.Sprintf("Your current agent level is %d, with a max amount of %d withdrawals per day.", shareInfo.Level, con.WithdrawAudit/common.DecimalDigits)
		return
	}
	err := call.UpdateShare(uid, 5, req.Amount, fmt.Sprintf("%d", req.Amount))
	if err != nil {
		log.Error("update share err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}
	_, err = call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:     uid,
			Value:   req.Amount,
			Event:   common.CurrencyEventShare,
			Type:    common.CurrencyINR,
			NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, req.Amount, 1),
		},
	})
	if err != nil {
		log.Error("update balance err, %s", err.Error())
		call.UpdateShare(uid, 6, req.Amount, "callback")
		a.Code = values.CodeRetry
		return
	}
	now := time.Now()
	updateValues := map[string]interface{}{
		"day_count":      1,
		"day_time":       now.Unix(),
		"today_withdraw": req.Amount,
		"total_withdraw": gorm.Expr("total_withdraw + ?", req.Amount),
	}
	if shareWithdrawInfo.DayTime != 0 && util.IsSameDayTimeStamp(shareWithdrawInfo.DayTime, now.Unix()) {
		updateValues["day_count"] = gorm.Expr("day_count + ?", 1)
		updateValues["today_withdraw"] = gorm.Expr("today_withdraw + ?", req.Amount)
		delete(updateValues, "day_time")
	}
	err = db.Mysql().C().Model(&common.ShareWithdrawInfo{}).Where("id = ?", shareWithdrawInfo.ID).Updates(updateValues).Error
	if err != nil {
		log.Error("update share withdraw info err, %s", err.Error())
	}
	call.UploadActivityData(a.UID, common.ActivityIDShare, common.ActivityDataJoin, req.Amount)
}