You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1730 lines
58 KiB
1730 lines
58 KiB
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 in (%v,%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.CurrencyEventActivityWeekCard, 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 GetNewPayRepeatCountBySqls(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 uid from recharge_order WHERE event in (%v,%v) AND status = %v AND callback_time >= %d AND callback_time < %d GROUP BY uid HAVING COUNT(*) >= 2)as re |
|
ON re.uid = u.id |
|
where u.birth >= %d AND u.birth < %d`, common.CurrencyEventReCharge, common.CurrencyEventActivityWeekCard, 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 in (%d,%d) AND status = %d and callback_time >= %d AND callback_time < %d and currency_type = %d`, |
|
i, i+oneDay, common.CurrencyEventReCharge, common.CurrencyEventActivityWeekCard, 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 in (%d,%d) AND status = %d AND re.callback_time >= %d AND re.callback_time < %d AND event = %d`, |
|
i, common.CurrencyEventReCharge, common.CurrencyEventActivityWeekCard, 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 in (%v,%v) and status = %v and callback_time >= %d and callback_time < %d `, |
|
common.CurrencyEventReCharge, common.CurrencyEventActivityWeekCard, 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 |
|
} |
|
|
|
// 通过sql查询代付金额 |
|
func GetWithdrawingAmountTotalBySQLs(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 in (%v,%v,%v,%v,%v,%v) and callback_time >= %d and callback_time < %d and currency_type = %d`, |
|
common.CurrencyEventWithDraw, common.StatusROrderWaitting, common.StatusROrderCreate, common.StatusROrderPay, common.StatusROrderFail, common.StatusROrderCancel, common.StatusROrderPending, 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 in (%d,%d) ", common.CurrencyEventReCharge, common.CurrencyEventActivityWeekCard) |
|
} 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, game_name as GameName,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" |
|
sql += " group by game_id order by amount desc" |
|
case 2: |
|
sql = fmt.Sprintf(`SELECT provider as Provider,game_id as GameID,game_name as GameName,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" |
|
sql += " group by game_id order by amount desc" |
|
case 3: |
|
sql = fmt.Sprintf(`SELECT provider as Provider,game_id as GameID,game_name as GameName,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" |
|
sql += " 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 { |
|
var gameCfg *common.ConfigGameList |
|
if v.Provider == common.ProviderJin { |
|
gameCfg = call.GetConfigGameListByCode(v.Provider, v.GameName) |
|
} else { |
|
gameCfg = call.GetConfigGameListByID(v.Provider, v.GameID) |
|
} |
|
if gameCfg != nil { |
|
v.Name = gameCfg.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) |
|
}
|
|
|