xpggame/modules/backend/models/db.go

package models

import (
	"fmt"
	"server/call"
	"server/common"
	"server/db"
	"server/util"
	"time"

	"server/modules/backend/values"

	utils "server/modules/backend/util"

	"github.com/liangdas/mqant/log"
	"github.com/olivere/elastic/v7"
)

/*
  该区域存放mysql查询方法

   1.充值金额数据
   2.退出金额数据
   3.当天新用户
*/
// 通过sql查询充值金额
func GetAmountTotalBySQL(s, e int64, channel *int) int64 {
	var RechargeAmount int64

	if s == e {
		e += 24 * 60 * 60
	}

	amountTotal := `SELECT IFNULL(SUM(amount),0) as RechargeAmount FROM recharge_order WHERE event = %v and status = %v and callback_time >= %d and callback_time < %d `
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" and channel_id = %v ", common.CurrencyEventReCharge, common.StatusROrderPay, s, e, *channel), &RechargeAmount)
		if err != nil {
			log.Error("查询支付总金额失败, error : [%s]", err.Error())
		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, common.CurrencyEventReCharge, common.StatusROrderPay, s, e), &RechargeAmount)
		if err != nil {
			log.Error("查询支付总金额失败, error : [%s]", err.Error())
		}
	}
	return RechargeAmount
}

// 通过sql查询代付金额
func GetWithdrawAmountTotalBySQL(s, e int64, channel *int) int64 {
	var amount int64
	if s == e {
		e += 24 * 60 * 60
	}
	amountTotal := `SELECT IFNULL(SUM(amount),0) as amount FROM recharge_order WHERE event = %v and status = %v and callback_time >= "%d" and callback_time < "%d" `
	if channel != nil {
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" and channel_id = %v ", common.CurrencyEventWithDraw, common.StatusROrderFinish, s, e, *channel), &amount)
		if err != nil {
			log.Error("查询支付总金额失败, error : [%s]", err.Error())
		}
	} else {
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, common.CurrencyEventWithDraw, common.StatusROrderFinish, s, e), &amount)
		if err != nil {
			log.Error("查询支付总金额失败, error : [%s]", err.Error())
		}
	}
	return amount
}

// 通过出生日期查询用户次日付费金额
func GetAmountTotalByBirth(channel *int, birth int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	s := birth + oneDay
	e := birth + oneDay + oneDay
	var RechargeAmount int64
	amountTotal := `SELECT SUM(amount) as RechargeAmount FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND re.callback_time >= "%d" AND re.callback_time < "%d" AND u.birth >= "%d" AND u.birth < "%d"`
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, s, e, birth, birth+24*60*60, *channel, *channel), &RechargeAmount)
		if err != nil {
			log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, common.CurrencyEventReCharge, common.StatusROrderPay, s, e, birth, birth+24*60*60), &RechargeAmount)
		if err != nil {
			log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
		}
	}
	return RechargeAmount
}

// 通过出生日期查询用户次日付费人数
func GetPlayerCountByBirth(channel *int, birth int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	s := birth + oneDay
	e := birth + oneDay + oneDay

	var count int64
	str := `SELECT COUNT(DISTINCT(re.uid)) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND re.callback_time >= "%d" AND re.callback_time < %d AND u.birth >= %d AND u.birth < %d`
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v ", common.CurrencyEventReCharge, common.StatusROrderPay, s, e, birth, s, *channel, *channel), &count)
		if err != nil {
			log.Error("通过出生日期查询用户次日付费人数失败, error : [%s]", err.Error())
		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, s, e, birth, s), &count)
		if err != nil {
			log.Error("通过出生日期查询用户次日付费人数失败, error : [%s]", err.Error())
		}
	}
	return count
}

// 查询玩家次日存留数量
func GetNextDayReserved(channel *int, birth int64) int64 {
	var count int64
	nextDay := time.Unix(birth, 0).Format("20060102")
	str := `SELECT COUNT(*) AS count FROM login_record AS lo LEFT JOIN users AS u ON lo.uid = u.id WHERE u.birth >= "%d" AND u.birth < "%d" AND lo.date = "%s"`
	if channel != nil {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND lo.channel_id = %v AND u.channel_id = %v", birth, birth+24*60*60, nextDay, *channel, *channel), &count)
		if err != nil {
			log.Error("查询玩家次日存留数量失败, error : [%s]", err.Error())
		}
	} else {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str, birth, birth+24*60*60, nextDay), &count)
		if err != nil {
			log.Error("查询玩家次日存留数量失败, error : [%s]", err.Error())
		}
	}
	return count
}

// 获取当天注册用户数量 按天计算
func GetNewPlayerCountBySql(channel *int, start, end int64) int64 {
	var count int64
	var oneDay int64 = 24 * 60 * 60

	if end == start {
		end += oneDay
	}

	for i := start; i < end; i += oneDay {
		var temp int64
		str := fmt.Sprintf(" SELECT COUNT(*) AS count FROM users WHERE birth >= %d AND birth < %d ", i, i+oneDay)
		if channel != nil {
			str += fmt.Sprintf(" AND channel_id = %d", *channel)
		}
		err := db.Mysql().QueryBySql(str, &temp)
		if err != nil {
			log.Error("查询当天注册用户数失败, error : [%s]", err.Error())
		}
		count += temp
	}

	return count
}

// 获取当天注册用户数量 按天计算
func GetNewPlayerCountBySqlT(channel *int, start, end int64) int64 {
	var count int64
	str := fmt.Sprintf(" SELECT COUNT(*) FROM users WHERE birth >= %d AND birth < %d ", start, end)
	if channel != nil {
		str += fmt.Sprintf(" AND channel_id = %d", *channel)
	}
	err := db.Mysql().QueryBySql(str, &count)
	if err != nil {
		log.Error("查询注册用户数失败, error : [%s]", err.Error())
	}
	return count
}

// 获取当天老用户数
func GetOldPlayerCountBySql(channel *int, s, e int64) int64 {
	var count int64
	var str string
	var oneDay int64 = 24 * 60 * 60
	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		date := time.Unix(i, 0).Format("20060102")
		if channel != nil {
			str = fmt.Sprintf("SELECT count(DISTINCT(uid)) FROM login_record WHERE date = '%s' and channel_id = %d and status = 2", date, *channel)
		} else {
			str = fmt.Sprintf("SELECT count(DISTINCT(uid)) FROM login_record WHERE date = '%s' and status = 2", date)
		}

		err := db.Mysql().QueryBySql(str, &temp)
		if err != nil {
			log.Error("查询当天老用户数失败, error : [%s]", err.Error())
		}
		count += temp
	}

	return count
}

// 查询当天注册用户付费人数
func GetNewPayCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		str := `SELECT COUNT(DISTINCT(re.uid)) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth >= %d AND u.birth < %d`
		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		}

		count += temp
	}

	return count
}

// 查询当天注册用户付费且成功退出人数
func GetNewPayWithdrawCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		str := `SELECT COUNT(DISTINCT(re.uid)) AS count FROM withdraw_order AS re LEFT JOIN users AS u ON re.uid = u.id 
			WHERE re.event = %v AND re.status = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth >= %d AND u.birth < %d`
		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v",
				common.CurrencyEventWithDraw, common.StatusROrderFinish, i, i+oneDay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventWithDraw, common.StatusROrderFinish, i, i+oneDay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		}

		count += temp
	}

	return count
}

// 查询当天新增付费总额
func GetNewPayAmountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var RechargeAmount int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		amountTotal := `SELECT IFNULL(SUM(amount),0) as RechargeAmount FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND re.callback_time >= "%d" AND re.callback_time < "%d" AND u.birth >= "%d" AND u.birth < "%d"`
		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
			}
		}
		RechargeAmount += temp
	}

	return RechargeAmount
}

// 查询当天老用户付费总额
func GetOldPayAmountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var RechargeAmount int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		amountTotal := `SELECT IFNULL(SUM(re.amount),0) as RechargeAmount FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND re.callback_time >= "%d" AND re.callback_time < "%d" AND u.birth < "%d"`
		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" AND re.channel_id = %v AND u.channel_id = %v ", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, *channel, *channel), &temp)
			if err != nil {
				log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i), &temp)
			if err != nil {
				log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
			}
		}
		RechargeAmount += temp
	}

	return RechargeAmount
}

// 查询老用户付费人数
func GetOldPayCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		str := `SELECT COUNT(DISTINCT(re.uid)) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth < %d `
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, *channel, *channel), &temp)
			if err != nil {
				log.Error("查询老用户付费人数失败, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i), &temp)
			if err != nil {
				log.Error("查询老用户付费人数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}
	return count
}

// 查询付费人数(新用户 + 老用户付费人数)
func GetPayCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		str := `SELECT COUNT(DISTINCT(uid)) AS count FROM recharge_order WHERE event = %v AND status = %v AND callback_time >= %d AND callback_time < %d `
		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, *channel), &temp)
			if err != nil {
				log.Error("查询活跃付费人数失败, error : [%s]", err.Error())
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("查询活跃付费人数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}
	return count
}

/*---------------------------------退出查询-----------------------------*/
// 查询老用户退出人数
func GetOldWithdrawCount(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		str := `SELECT COUNT(DISTINCT(re.uid)) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth < %d `
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventWithDraw, i, i+oneDay, i, *channel, *channel), &temp)
			if err != nil {
				log.Error("查询老用户退出人数, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventWithDraw, i, i+oneDay, i), &temp)
			if err != nil {
				log.Error("查询老用户退出人数, error : [%s]", err.Error())
			}
		}
		count += temp
	}
	return count
}

// 查询老用户退出次数
func GetOldWithdrawCount2(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		str := `SELECT COUNT(re.uid) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth < %d `
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventWithDraw, i, i+oneDay, i, *channel, *channel), &temp)
			if err != nil {
				log.Error("查询老用户退出人数, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventWithDraw, i, i+oneDay, i), &temp)
			if err != nil {
				log.Error("查询老用户退出人数, error : [%s]", err.Error())
			}
		}
		count += temp
	}
	return count
}

// 查询当天注册用户退出人数
func GetNewWithdrawCount(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		str := `SELECT COUNT(DISTINCT(re.uid)) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth >= %d AND u.birth < %d`
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventWithDraw, i, i+oneDay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventWithDraw, i, i+oneDay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		}

		count += temp
	}

	return count
}

// 查询当天注册用户退出次数
func GetNewWithdrawCount2(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		str := `SELECT COUNT(re.uid) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.callback_time >= "%d" AND re.callback_time < "%d" AND u.birth >= "%d" AND u.birth < "%d"`
		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventWithDraw, i, i+oneDay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventWithDraw, i, i+oneDay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
			}
		}

		count += temp
	}

	return count
}

/*----------------------------------------------------------------------*/

// 新用户付费人数
func GetNewAllPayCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	str := `SELECT COUNT(DISTINCT(re.uid)) AS count FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND u.birth >= %d AND u.birth < %d`

	for i := s; i < e; i += oneDay {
		var temp int64
		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("获取当批次新用户总付费人数失败, error : [%s]", err.Error())
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("获取当批次新用户总付费人数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}

	return count
}

// 获取当批次新用户总付费总额
func GetNewAllPayAmountBySql(channel *int, s int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var RechargeAmount int64

	amountTotal := `SELECT SUM(amount) as RechargeAmount FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND u.birth >= %d AND u.birth < %d`
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, s, s+oneDay, *channel, *channel), &RechargeAmount)
		if err != nil {
			log.Error("获取当批次新用户总付费总额失败, error : [%s]", err.Error())
		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, common.CurrencyEventReCharge, common.StatusROrderPay, s, s+oneDay), &RechargeAmount)
		if err != nil {
			log.Error("获取当批次新用户总付费总额失败, error : [%s]", err.Error())
		}
	}

	return RechargeAmount
}

// 获取当批次新用户总退出
func GetNewAllWithDrawAmountBySql(channel *int, s int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var RechargeAmount int64

	amountTotal := `SELECT SUM(amount) as RechargeAmount FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND u.birth >= %d AND u.birth < %d`
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventWithDraw, common.StatusROrderFinish, s, s+oneDay, *channel, *channel), &RechargeAmount)
		if err != nil {
			log.Error("获取当批次新用户总退出失败, error : [%s]", err.Error())
		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, common.CurrencyEventWithDraw, common.StatusROrderFinish, s, s+oneDay), &RechargeAmount)
		if err != nil {
			log.Error("获取当批次新用户总退出失败, error : [%s]", err.Error())
		}
	}

	return RechargeAmount
}

// 查询当天创建的充值订单数
func GetCreateOrderCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	// su := time.Unix(s, 0).Format("2006-01-02")
	// eu := time.Unix(e, 0).Format("2006-01-02")

	for i := s; i < e; i += oneDay {
		var temp int64
		str := " SELECT COUNT(*) AS count FROM recharge_order WHERE event = %v AND create_time >= %d AND create_time < %d "
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND channel_id = %v ", common.CurrencyEventReCharge, s, e, *channel), &temp)
			if err != nil {
				log.Error("查询当天创建的充值订单数, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, s, e), &temp)
			if err != nil {
				log.Error("查询当天创建的充值订单数, error : [%s]", err.Error())
			}
		}
		count += temp
	}
	return count
}

// 获取成功充值订单数
func GetSuccessRechargeOrderCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		str := `SELECT  COUNT(*) FROM recharge_order WHERE event = %v AND status = %v AND callback_time >= %d AND callback_time < %d`
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND channel_id = %v ", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, *channel), &temp)
			if err != nil {
				log.Error("获取成功充值订单数失败, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("获取成功充值订单数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}

	return count
}

// 获取新用户充值订单数
func GetNewRechargeOrderCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		str := `SELECT COUNT(*) FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.uid = u.id AND re.event = %v AND u.birth >= %d AND u.birth < %d`
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, i, i+oneDay), &temp)
			if err != nil {
				log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}

	return count
}

// 获取新用户充值订单数(成功)
func GetNewRechargeSuccessOrderCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		str := `SELECT  COUNT(*) FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.uid = u.id AND re.event = %v AND re.status = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth >= %d AND u.birth < %d`
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}

	return count
}

// 获取创建订单人数
func GetCreateOrderPlayerCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	// su := time.Unix(s, 0).Format("2006-01-02 15:04:05")
	// eu := time.Unix(e, 0).Format("2006-01-02 15:04:05")

	for i := s; i < e; i += oneDay {
		var temp int64
		str := " SELECT COUNT(DISTINCT(uid)) FROM recharge_order WHERE event = %v AND create_time >= %d AND create_time < %d "
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND channel_id = %v ", common.CurrencyEventReCharge, s, e, *channel), &temp)
			if err != nil {
				log.Error("查询创建充值订单人数, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, s, e), &temp)
			if err != nil {
				log.Error("查询创建充值订单人数, error : [%s]", err.Error())
			}
		}
		count += temp
	}
	return count
}

// 查询充值成功订单人数(新用户 + 老用户人数)
func GetOrderSuccessPlayerCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		str := " SELECT COUNT(DISTINCT(uid)) FROM recharge_order WHERE event = %v AND status = %v AND callback_time >= %d AND callback_time < %d "
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND channel_id = %v ", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, *channel), &temp)
			if err != nil {
				log.Error("查询充值成功订单人数失败, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("查询充值成功订单人数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}
	return count
}

// 充值成功的新用户人数
func GetOrderSuccessNewPlayerCountBySql(channel *int, s, e int64) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		str := `SELECT  COUNT(DISTINCT(re.uid)) FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.event = %v AND re.status = %v AND re.callback_time >= %d AND re.callback_time < %d AND u.birth >= %d AND u.birth < %d`
		if channel != nil {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay, *channel, *channel), &temp)
			if err != nil {
				log.Error("获取充值成功的新用户人数失败, error : [%s]", err.Error())
			}
		} else {
			err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay), &temp)
			if err != nil {
				log.Error("获取充值成功的新用户人数失败, error : [%s]", err.Error())
			}
		}
		count += temp
	}

	return count
}

// 未充值新用户的货币总额
func GetUnRechargePlayerAmount(channel *int, s, e int64) (int64, int64) {
	var oneDay int64 = 24 * 60 * 60
	if e == s {
		e += oneDay
	}

	var CashTotal int64
	var AmountTotal int64

	amountTotal := `SELECT SUM(cash) AS CashTotal, SUM(cash + bind_cash) AS AmountTotal FROM users AS a LEFT JOIN (SELECT uid, total_recharge FROM recharge_info) AS b ON a.id = b.uid WHERE a.id = b.uid AND b.total_charge > 0 AND birth >= %d AND birth < %d`
	for i := s; i < e; i += oneDay {
		var res struct {
			CashTotal   int64
			AmountTotal int64
		}

		if channel != nil {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal+" AND a.channel_id = %v ", s, s+oneDay, *channel), &res)
			if err != nil {
				log.Error("获取未充值新用户的货币总额失败, error : [%s]", err.Error())
				continue
			}
		} else {
			// 充值总金额
			err := db.Mysql().QueryBySql(fmt.Sprintf(amountTotal, s, s+oneDay), &res)
			if err != nil {
				log.Error("获取未充值新用户的货币总额失败, error : [%s]", err.Error())
				continue
			}
		}
		CashTotal += res.CashTotal
		AmountTotal += res.AmountTotal
	}
	return CashTotal, AmountTotal
}

// 获取一天内某个时间段进来的新用户在当天的充值人数
func GetNewPlayerPayDisCount(channel *int, s, e, end int64) int64 {
	var count int64
	str := fmt.Sprintf(" SELECT COUNT(DISTINCT(a.id)) FROM users AS a LEFT JOIN (SELECT DISTINCT(uid) FROM recharge_order"+
		" WHERE `event` = %d AND `status` = %d AND callback_time < %d and callback_time > %d) AS b ON a.id = b.uid WHERE a.id = b.uid AND a.birth >= %d AND a.birth < %d ",
		common.CurrencyEventReCharge,
		common.StatusROrderPay,
		end,
		s,
		s,
		e)
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND a.channel_id = %v ", *channel), &count)
		if err != nil {
			log.Error("获取一天内某个时间段进来的新用户在当天的充值人数失败, error : [%s]", err.Error())

		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(str, &count)
		if err != nil {
			log.Error("获取一天内某个时间段进来的新用户在当天的充值人数失败, error : [%s]", err.Error())
		}
	}
	return count
}

// 查询玩家充值总次数
func GetOneRechargeCountBySql(uid int) int64 {
	var temp int64
	str := `SELECT  COUNT(*) FROM recharge_order WHERE event = %v AND uid = %d `
	err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, uid), &temp)
	if err != nil {
		log.Error("获取玩家充值总次数失败, error : [%s]", err.Error())
	}
	return temp
}

// 查询玩家充值成功次数
func GetOneRechargeSuccessCountBySql(uid int) int64 {
	var temp int64
	str := `SELECT  COUNT(*) FROM recharge_order WHERE event = %v AND status = %v AND uid = %d `
	err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, uid), &temp)
	if err != nil {
		log.Error("获取玩家成功充值订单数失败, error : [%s]", err.Error())
	}
	return temp
}

// 获取充值人数
func GetRechargeSuPlayerCountBySql(channel *int, su, eu int64) int64 {
	var count int64

	str := " SELECT COUNT(DISTINCT(a.id)) FROM users AS a LEFT JOIN ( SELECT uid FROM recharge_order WHERE event = %v AND status = %v ) AS b ON a.id = b.uid WHERE a.id = b.uid AND a.birth >= %d AND a.birth < %d "
	if channel != nil {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND a.channel_id = %v ", common.CurrencyEventReCharge, common.StatusROrderPay, su, eu, *channel), &count)
		if err != nil {
			log.Error("查询创建充值订单人数, error : [%s]", err.Error())
		}
	} else {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, su, eu), &count)
		if err != nil {
			log.Error("查询创建充值订单人数, error : [%s]", err.Error())
		}
	}

	return count
}

// 获取指定时间注册用户在24小时内付费金额
func Get24HourNewPlayerRechargeAmount(channel *int, s, e int64) int64 {
	var count int64
	str := fmt.Sprintf(" SELECT IFNULL(SUM(b.amount),0) FROM users AS a LEFT JOIN (SELECT * FROM recharge_order WHERE `event` = %d AND `status` = %d AND callback_time < %d) AS b ON a.id = b.uid WHERE a.id = b.uid AND a.birth >= %d AND a.birth < %d ",
		common.CurrencyEventReCharge,
		common.StatusROrderPay,
		s+24*60*60,
		s,
		e)
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND a.channel_id = %v ", *channel), &count)
		if err != nil {
			log.Error("获取指定时间注册用户在24小时内付费金额失败, error : [%s]", err.Error())

		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(str, &count)
		if err != nil {
			log.Error("获取指定时间注册用户在24小时内付费金额失败, error : [%s]", err.Error())
		}
	}
	return count
}

// 获取指定时间注册用户付费金额
func GetNewPlayerRechargeAmount(channel *int, s, e int64) int64 {
	var count int64
	str := fmt.Sprintf(" SELECT IFNULL(SUM(b.amount),0) FROM users AS a LEFT JOIN (SELECT * FROM recharge_order WHERE `event` = %d AND `status` = %d ) AS b ON a.id = b.uid WHERE a.id = b.uid AND a.birth >= %d AND a.birth < %d ",
		common.CurrencyEventReCharge,
		common.StatusROrderPay,
		s,
		e)
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND a.channel_id = %v ", *channel), &count)
		if err != nil {
			log.Error("获取指定时间注册用户在24小时内付费金额失败, error : [%s]", err.Error())

		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(str, &count)
		if err != nil {
			log.Error("获取指定时间注册用户在24小时内付费金额失败, error : [%s]", err.Error())
		}
	}
	return count
}

// 获取指定时间注册用户在24小时内付费人数
func Get24HourNewPlayerPayCount(channel *int, s, e int64) int64 {
	var count int64
	str := fmt.Sprintf("SELECT COUNT(DISTINCT(a.id)) FROM users AS a LEFT JOIN (SELECT DISTINCT(uid) FROM recharge_order WHERE `event` = %d"+
		" AND `status` = %d AND callback_time < %d and callback_time > %d) AS b ON a.id = b.uid WHERE a.id = b.uid AND a.birth >= %d AND a.birth < %d ",
		common.CurrencyEventReCharge,
		common.StatusROrderPay,
		e+24*60*60,
		s,
		s,
		e)
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND a.channel_id = %v ", *channel), &count)
		if err != nil {
			log.Error("获取指定时间注册用户在24小时内付费人数失败, error : [%s]", err.Error())

		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(str, &count)
		if err != nil {
			log.Error("获取指定时间注册用户在24小时内付费人数失败, error : [%s]", err.Error())
		}
	}
	return count
}

// 获取一天内某个时间段进来的新用户在当天的充值人数
func GetNewPlayerPayDisCount1(channel *int, s, e int64) int64 {
	var count int64
	str := fmt.Sprintf(" SELECT COUNT(DISTINCT(a.id)) FROM users AS a LEFT JOIN (SELECT DISTINCT(uid) FROM recharge_order WHERE `event` = %d AND `status` = %d) AS b ON a.id = b.uid WHERE a.id = b.uid AND a.birth >= %d AND a.birth < %d ",
		common.CurrencyEventReCharge,
		common.StatusROrderPay,
		s,
		e)
	if channel != nil {
		// 充值总金额
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND a.channel_id = %v ", *channel), &count)
		if err != nil {
			log.Error("获取一天内某个时间段进来的新用户在当天的充值人数失败, error : [%s]", err.Error())

		}
	} else {
		// 充值总金额
		err := db.Mysql().QueryBySql(str, &count)
		if err != nil {
			log.Error("获取一天内某个时间段进来的新用户在当天的充值人数失败, error : [%s]", err.Error())
		}
	}
	return count
}

// 获取新用户充值订单数(成功)
func GetNewRechargeSuccessOrderCountBySql2(channel *int, s, e int64) int64 {
	var count int64

	str := `SELECT  COUNT(*) FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.uid = u.id AND re.event = %v AND re.status = %v AND re.callback_time >= %d AND u.birth >= %d AND u.birth < %d`
	if channel != nil {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, common.StatusROrderPay, s, s, e, *channel, *channel), &count)
		if err != nil {
			log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
		}
	} else {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, common.StatusROrderPay, s, s, e), &count)
		if err != nil {
			log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
		}
	}

	return count
}

// 获取新用户充值订单数
func GetNewRechargeOrderCountBySql2(channel *int, s, e int64) int64 {
	var count int64

	str := `SELECT COUNT(*) FROM recharge_order AS re LEFT JOIN users AS u ON re.uid = u.id WHERE re.uid = u.id AND re.event = %v AND u.birth >= %d AND u.birth < %d`
	if channel != nil {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str+" AND re.channel_id = %v AND u.channel_id = %v", common.CurrencyEventReCharge, s, e, *channel, *channel), &count)
		if err != nil {
			log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
		}
	} else {
		err := db.Mysql().QueryBySql(fmt.Sprintf(str, common.CurrencyEventReCharge, s, e), &count)
		if err != nil {
			log.Error("获取新用户充值订单数失败, error : [%s]", err.Error())
		}
	}

	return count
}

func PackChannels(channel ...*int) string {
	if len(channel) == 0 {
		return ""
	}
	sql := ""
	for i, v := range channel {
		if v == nil {
			continue
		}
		if i == 0 {
			sql += " and ("
		}
		sql += fmt.Sprintf(" channel_id = %v", *v)
		if i != len(channel)-1 {
			sql += " or"
		} else {
			sql += ")"
		}
	}
	return sql
}

// 获取当天注册用户数量 按天计算
func GetNewPlayerCountBySqls(start, end int64, channel ...*int) int64 {
	var count int64
	var oneDay int64 = 24 * 60 * 60

	if end == start {
		end += oneDay
	}

	for i := start; i < end; i += oneDay {
		var temp int64
		str := fmt.Sprintf(" SELECT COUNT(*) AS count FROM users WHERE birth >= %d AND birth < %d ", i, i+oneDay)
		if len(channel) > 0 {
			str += PackChannels(channel...)
		}
		err := db.Mysql().QueryBySql(str, &temp)
		if err != nil {
			log.Error("查询当天注册用户数失败, error : [%s]", err.Error())
		}
		count += temp
	}

	return count
}

// 查询当天注册用户付费人数
func GetNewPayCountBySqls(s, e int64, channel ...*int) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		sql := fmt.Sprintf(`SELECT COUNT(u.id) AS count FROM users AS u 
		inner JOIN 
		(select distinct(uid) from recharge_order WHERE event = %v AND status = %v AND callback_time >= %d AND callback_time < %d )as re
		ON re.uid = u.id 
		where u.birth >= %d AND u.birth < %d`, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, i, i+oneDay)
		if len(channel) > 0 {
			sql += PackChannels(channel...)
		}
		err := db.Mysql().QueryBySql(sql, &temp)
		if err != nil {
			log.Error("查询当日新增付费人数失败, error : [%s]", err.Error())
		}
		count += temp
	}

	return count
}

// 查询新用户复充人数
func GetNewMultiPayCountBySqls(s, e int64, channel ...*int) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		sql := fmt.Sprintf(`SELECT count(*) as count from
		(SELECT uid as u,count(*) as count FROM recharge_order WHERE event = %d AND status = %d AND callback_time >= %d AND callback_time < %d %s GROUP BY uid)a
		INNER JOIN 
		(SELECT id from users WHERE birth >= %d and birth < %d)b
		ON a.u = b.id 
		WHERE a.count>1`, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, PackChannels(channel...), i, i+oneDay)
		err := db.Mysql().QueryBySql(sql, &temp)
		if err != nil {
			log.Error("查询老用户付费人数失败, error : [%s]", err.Error())
		}
		count += temp
	}
	return count
}

// 查询当天新增付费总额
func GetNewPayAmountBySqls(s, e int64, t common.CurrencyType, channel ...*int) int64 {
	var oneDay int64 = 24 * 60 * 60
	var RechargeAmount int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		sql := fmt.Sprintf(`SELECT IFNULL(SUM(amount),0) as RechargeAmount from recharge_order as re
			INNER JOIN
			(SELECT id from users where birth >= %d AND birth < %d) as u
			ON re.uid = u.id
			WHERE event = %d AND status = %d and callback_time >= %d AND callback_time < %d and currency_type = %d`,
			i, i+oneDay, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, t)
		if len(channel) > 0 {
			sql += PackChannels(channel...)
		}
		err := db.Mysql().QueryBySql(sql, &temp)
		if err != nil {
			log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
		}
		// temp = call.Rate(t, temp)
		RechargeAmount += temp
	}

	return RechargeAmount
}

func GetOldPlayerCountBySqls(s, e int64, channel ...*int) int64 {
	var count int64
	var oneDay int64 = 24 * 60 * 60
	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64

		date := time.Unix(i, 0).Format("20060102")
		sql := fmt.Sprintf("SELECT count(DISTINCT(uid)) FROM login_record WHERE date = '%s' and status = 2", date)
		if len(channel) > 0 {
			sql += PackChannels(channel...)
		}

		err := db.Mysql().QueryBySql(sql, &temp)
		if err != nil {
			log.Error("查询当天老用户数失败, error : [%s]", err.Error())
		}
		count += temp
	}

	return count
}

// 查询老用户付费人数
func GetOldPayCountBySqls(s, e int64, channel ...*int) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		sql := fmt.Sprintf(`SELECT COUNT(DISTINCT(re.uid)) AS count FROM recharge_order AS re 
		INNER JOIN 
		(SELECT id from users WHERE birth < %d)AS u 
		ON re.uid = u.id 
		WHERE event = %d AND status = %d AND re.callback_time >= %d AND re.callback_time < %d AND event = %d`,
			i, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, common.CurrencyEventReCharge)
		if len(channel) > 0 {
			sql += PackChannels(channel...)
		}
		err := db.Mysql().QueryBySql(sql, &temp)
		if err != nil {
			log.Error("查询老用户付费人数失败, error : [%s]", err.Error())
		}
		count += temp
	}
	return count
}

// 查询老用户复充人数
func GetOldMultiPayCountBySqls(s, e int64, channel ...*int) int64 {
	var oneDay int64 = 24 * 60 * 60
	var count int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		sql := fmt.Sprintf(`SELECT count(*) as count from
		(SELECT uid as u,count(*) as count FROM recharge_order WHERE event = %d AND status = %d AND callback_time >= %d AND callback_time < %d %s GROUP BY uid)a
		INNER JOIN 
		(SELECT id from users WHERE birth < %d)b
		ON a.u = b.id 
		WHERE a.count>1`, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, PackChannels(channel...), i)
		err := db.Mysql().QueryBySql(sql, &temp)
		if err != nil {
			log.Error("查询老用户付费人数失败, error : [%s]", err.Error())
		}
		count += temp
	}
	return count
}

// 查询当天老用户付费总额
func GetOldPayAmountBySqls(s, e int64, t common.CurrencyType, channel ...*int) int64 {
	var oneDay int64 = 24 * 60 * 60
	var RechargeAmount int64

	if e == s {
		e += oneDay
	}

	for i := s; i < e; i += oneDay {
		var temp int64
		sql := fmt.Sprintf(`SELECT IFNULL(SUM(amount),0) as RechargeAmount from recharge_order as re
			INNER JOIN
			(SELECT id from users where birth < %d) as u
			ON re.uid = u.id
			WHERE event = %d AND status = %d and callback_time >= %d AND callback_time < %d and currency_type = %d`,
			i, common.CurrencyEventReCharge, common.StatusROrderPay, i, i+oneDay, t)
		if len(channel) > 0 {
			sql += PackChannels(channel...)
		}
		err := db.Mysql().QueryBySql(sql, &temp)
		if err != nil {
			log.Error("通过出生日期查询用户次日付费金额失败, error : [%s]", err.Error())
		}
		// temp = call.Rate(t, temp)
		RechargeAmount += temp
	}

	return RechargeAmount
}

// 通过sql查询充值金额
func GetAmountTotalBySQLs(s, e int64, channel ...*int) int64 {
	var RechargeAmount int64

	if s == e {
		e += 24 * 60 * 60
	}

	sql := fmt.Sprintf(`SELECT IFNULL(SUM(amount),0) as RechargeAmount FROM recharge_order 
	WHERE event = %v and status = %v and callback_time >= %d and callback_time < %d `,
		common.CurrencyEventReCharge, common.StatusROrderPay, s, e,
	)
	if len(channel) > 0 {
		sql += PackChannels(channel...)
	}
	err := db.Mysql().QueryBySql(sql, &RechargeAmount)
	if err != nil {
		log.Error("查询支付总金额失败, error : [%s]", err.Error())
	}
	return RechargeAmount
}

// 通过sql查询代付金额
func GetWithdrawAmountTotalBySQLs(s, e int64, t common.CurrencyType, channel ...*int) int64 {
	var amount int64
	if s == e {
		e += 24 * 60 * 60
	}
	sql := fmt.Sprintf(`SELECT IFNULL(SUM(amount),0) as amount FROM withdraw_order WHERE event = %v and status = %v and callback_time >= %d and callback_time < %d and currency_type = %d`,
		common.CurrencyEventWithDraw, common.StatusROrderFinish, s, e, t)
	sql += PackChannels(channel...)
	err := db.Mysql().QueryBySql(sql, &amount)
	if err != nil {
		log.Error("查询支付总金额失败, error : [%s]", err.Error())
	}
	return amount
}

// 获取首充人数
func GetFirstPayCount(s, e int64, t common.CurrencyType, channel ...*int) int64 {
	q := elastic.NewBoolQuery()
	q.Filter(elastic.NewTermQuery("Type", 1))
	q.Filter(elastic.NewRangeQuery("FirstAmount").Gt(0))
	q.Filter(elastic.NewRangeQuery("Time").Gte(s))
	q.Filter(elastic.NewRangeQuery("Time").Lt(e))
	cids := []interface{}{}
	if len(channel) > 0 {
		for _, v := range channel {
			if v == nil {
				continue
			}
			cids = append(cids, *v)
		}
	}
	if len(cids) > 0 {
		q.Filter(elastic.NewTermsQuery("Channel", cids...))
	}
	return db.ES().CountCard(common.ESIndexBackPlayerPayData, "UID", q)
}

func GetGameInOut(su, eu int64, opt int, channel ...*int) int64 {
	q := elastic.NewBoolQuery()
	q.Filter(elastic.NewRangeQuery("time").Gte(su))
	q.Filter(elastic.NewRangeQuery("time").Lt(eu))
	cids := []interface{}{}
	if len(channel) > 0 {
		for _, v := range channel {
			if v == nil {
				continue
			}
			cids = append(cids, *v)
		}
	}
	if len(cids) > 0 {
		q.Filter(elastic.NewTermsQuery("channel_id", cids...))
	}
	if opt == 1 {
		q.Filter(elastic.NewTermsQuery("event", common.GetGameInEvents()...))
	} else {
		q.Filter(elastic.NewTermsQuery("event", common.GetGameOutEvents()...))
	}
	return util.Abs(db.ES().SumByInt64(common.ESIndexBalance, "value", q))
}

func GetOrderCount(su, eu int64, status, opt int, channel ...*int) int64 {
	condi := ""
	var model interface{}
	if opt == 1 {
		model = &common.RechargeOrder{}
		condi = fmt.Sprintf("event = %d ", common.CurrencyEventReCharge)
	} else {
		model = &common.WithdrawOrder{}
		condi = fmt.Sprintf("event = %d ", common.CurrencyEventWithDraw)
	}
	if status == common.StatusROrderCreate {
		condi += fmt.Sprintf(" and create_time >= %d and create_time < %d", su, eu)
	} else {
		condi += fmt.Sprintf(" and callback_time >= %d and callback_time < %d and status = %d", su, eu, status)
	}
	condi += PackChannels(channel...)
	// if channel != nil {
	// 	condi += fmt.Sprintf(" and channel_id = %d", *channel)
	// }
	return db.Mysql().Count(model, condi)
}

// 链接sql查询语句
func LinkMysqlCondi(sql []string) (str string) {
	if len(sql) == 0 {
		return
	}
	for i, v := range sql {
		if i == 0 {
			str = "where " + v
		} else {
			str += " and " + v
		}
	}
	return
}

// opt 1总下注前n 2总盈利前n 3总亏损前n
func GetTopGames(su, eu int64, opt, num int, channel ...*int) []*values.OneGameData {
	sql := ""
	switch opt {
	case 1:
		sql = fmt.Sprintf(`SELECT provider as Provider,game_id as GameID,sum(amount) as Amount from provider_bet_record WHERE time>=%d and time <%d and (type = %d or type = %d or type = %d)`,
			su, eu, common.SessionTypeBet, common.SessionTypeSettle, common.SessionTypeBuyIn)
		sql += PackChannels(channel...) + " group by game_id order by amount desc"
	case 2:
		sql = fmt.Sprintf(`SELECT provider as Provider,game_id as GameID,sum(amount - settle) as Amount from provider_bet_record WHERE time>=%d and time <%d`, su, eu)
		sql += PackChannels(channel...) + " group by game_id order by amount desc"
	case 3:
		sql = fmt.Sprintf(`SELECT provider as Provider,game_id as GameID,sum(settle - amount) as Amount from provider_bet_record WHERE time>=%d and time <%d`, su, eu)
		sql += PackChannels(channel...) + " group by game_id order by amount desc"
	default:
		return nil
	}
	sql += fmt.Sprintf(" limit %d", num)

	ret := []*values.OneGameData{}
	db.Mysql().QueryBySql(sql, &ret)

	index := -1
	for i, v := range ret {
		game := call.GetConfigGameListByID(v.Provider, v.GameID)
		if game != nil {
			v.Name = game.Name
		}
		// 去掉amount<0的部分
		if opt > 1 {
			if v.Amount < 0 {
				index = i
				break
			}
		}
	}
	if index >= 0 {
		ret = ret[:index]
	}

	return ret
}

type ActivityDataGroupSumBuckets struct {
	Buckets []struct {
		Key       interface{}
		Doc_count int
		Amount    struct {
			Value float64
		}
	}
}

func GetActivityData(su, eu int64, channel ...*int) (ret []*values.RealActivityData) {
	q := NewQ(&su, &eu)
	getChannelQ(q, channel...)
	q.Filter(elastic.NewTermQuery("Type", common.ActivityDataClick))
	esRet, _ := db.ES().GroupByCard(common.ESIndexBackActivity, "ActivityID", "UID", q, 5000)
	for _, v := range esRet.Buckets {
		ret = append(ret, &values.RealActivityData{
			ActivityID: util.GetInt(v.Key),
			ClickCount: util.GetInt64(v.Sub.Value),
		})
	}
	// fmt.Println("1:", esRet)

	q = NewQ(&su, &eu)
	getChannelQ(q, channel...)
	q.Filter(elastic.NewTermQuery("Type", common.ActivityDataJoin))
	esRet, _ = db.ES().GroupByCard(common.ESIndexBackActivity, "ActivityID", "UID", q, 5000)
	for _, v := range esRet.Buckets {
		find := false
		for _, k := range ret {
			if k.ActivityID == util.GetInt(v.Key) {
				k.JoinCount = util.GetInt64(v.Sub.Value)
				find = true
				break
			}
		}
		if !find {
			ret = append(ret, &values.RealActivityData{
				ActivityID: util.GetInt(v.Key),
				JoinCount:  util.GetInt64(v.Sub.Value),
			})
		}
	}
	// fmt.Println("2:", esRet)

	q = NewQ(&su, &eu)
	// q = elastic.NewBoolQuery()
	// q.Filter(elastic.NewRangeQuery("Time").Gte(1713404103))
	// q.Filter(elastic.NewTermQuery("ActivityID", 10006))
	getChannelQ(q, channel...)
	sumBucket := ActivityDataGroupSumBuckets{}
	db.ES().GroupSumBy(common.ESIndexBackActivity, "ActivityID", q, &sumBucket, "", false, 5000, "Amount")
	for _, v := range sumBucket.Buckets {
		find := false
		for _, k := range ret {
			if k.ActivityID == util.GetInt(v.Key) {
				k.Reward = util.GetInt64(v.Amount.Value)
				find = true
				break
			}
		}
		if !find {
			ret = append(ret, &values.RealActivityData{
				ActivityID: util.GetInt(v.Key),
				Reward:     util.GetInt64(v.Amount.Value),
			})
		}
	}
	// fmt.Println("3:", sumBucket)
	return ret
}

// 查询当天注册用户付费次数
func GetNewPayCounts(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT count(*) as count FROM
	(SELECT id FROM users WHERE birth>= %d and birth < %d %s)a
	INNER JOIN
	(SELECT uid from recharge_order WHERE status = %d and event = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, e, channelStr, common.StatusROrderPay, common.CurrencyEventReCharge, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 查询当天老用户付费次数
func GetOldPayCounts(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT count(*) as count FROM
	(SELECT id FROM users WHERE birth < %d %s)a
	INNER JOIN
	(SELECT uid from recharge_order WHERE status = %d and event = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, channelStr, common.StatusROrderPay, common.CurrencyEventReCharge, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 查询当天注册用户赠送次数
func GetNewWithdrawCounts(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT count(*) as count FROM
	(SELECT id FROM users WHERE birth>= %d and birth < %d %s)a
	INNER JOIN
	(SELECT uid from withdraw_order WHERE status = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, e, channelStr, common.StatusROrderFinish, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 查询当天注册用户赠送人数
func GetNewWithdrawPlayerNum(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT count(*) as count FROM
	(SELECT id FROM users WHERE birth>= %d and birth < %d %s)a
	INNER JOIN
	(SELECT DISTINCT(uid) from withdraw_order WHERE status = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, e, channelStr, common.StatusROrderFinish, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 查询当天注册用户赠送总额
func GetNewWithdrawAmount(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT IFNULL(sum(b.amount),0) as count FROM
	(SELECT id FROM users WHERE birth>= %d and birth < %d %s)a
	INNER JOIN
	(SELECT uid,amount from withdraw_order WHERE status = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, e, channelStr, common.StatusROrderFinish, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 查询当天老用户赠送次数
func GetOldWithdrawCounts(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT count(*) as count FROM
	(SELECT id FROM users WHERE birth < %d %s)a
	INNER JOIN
	(SELECT uid from withdraw_order WHERE status = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, channelStr, common.StatusROrderFinish, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 查询当天老用户赠送人数
func GetOldWithdrawplayerNum(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT count(*) as count FROM
	(SELECT id FROM users WHERE birth < %d %s)a
	INNER JOIN
	(SELECT DISTINCT(uid) from withdraw_order WHERE status = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, channelStr, common.StatusROrderFinish, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 查询当天老用户赠送总数
func GetOldWithdrawAmount(s, e int64, channel ...*int) (count int64) {
	channelStr := PackChannels(channel...)
	str := fmt.Sprintf(`SELECT IFNULL(sum(b.amount),0) as count FROM
	(SELECT id FROM users WHERE birth < %d %s)a
	INNER JOIN
	(SELECT uid,amount from withdraw_order WHERE status = %d and callback_time >= %d and callback_time < %d %s)b
	on a.id = b.uid`, s, channelStr, common.StatusROrderFinish, s, e, channelStr)
	// 充值次数
	db.Mysql().QueryBySql(str, &count)
	return
}

// 获取某日的次日留存 opt 1活跃留存 2总付费留存 3新增付费留存
func GetKeepPer(opt int, date string, su int64, channel ...*int) string {
	// 前一天
	yes := time.Unix(su, 0).AddDate(0, 0, -1).Format("20060102")
	channelStr := PackChannels(channel...)
	var sql, totalSql string
	var total, count int64
	if opt == 1 {
		totalSql = fmt.Sprintf(`SELECT count(*) FROM login_record WHERE date = '%v'%v`, yes, channelStr)
		sql = fmt.Sprintf(`SELECT count(a.uid) FROM
		(SELECT uid FROM login_record WHERE date = '%v'%v)a 
		INNER JOIN 
		(SELECT uid FROM login_record WHERE date = '%v'%v)b 
		on a.uid = b.uid `,
			yes, channelStr, date, channelStr)
	} else if opt == 2 {
		totalSql = fmt.Sprintf(`SELECT count(*)  FROM login_record WHERE is_recharge = 2 and date = '%v'%v`, yes, channelStr)
		sql = fmt.Sprintf(`SELECT count(a.uid) FROM
		(SELECT uid FROM login_record WHERE is_recharge = 2 and date = '%v'%v)a 
		INNER JOIN 
		(SELECT uid FROM login_record WHERE is_recharge = 2 and date = '%v'%v)b 
		on a.uid = b.uid `,
			yes, channelStr, date, channelStr)
	} else {
		totalSql = fmt.Sprintf(`SELECT count(*)  FROM login_record WHERE is_recharge = 2 and status = 1 and date = '%v'%v`, yes, channelStr)
		sql = fmt.Sprintf(`SELECT count(a.uid) FROM
		(SELECT uid FROM login_record WHERE is_recharge = 2 and status = 1 and date = '%v'%v)a 
		INNER JOIN 
		(SELECT uid FROM login_record WHERE is_recharge = 2 and date = '%v'%v)b 
		on a.uid = b.uid `,
			yes, channelStr, date, channelStr)
	}
	db.Mysql().QueryBySql(sql, &count)
	db.Mysql().QueryBySql(totalSql, &total)
	return utils.GetPer(count, total)
}