318 lines
8.6 KiB
Go
318 lines
8.6 KiB
Go
package walletser
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"91porn-server/common"
|
|
"91porn-server/common/log"
|
|
"91porn-server/common/stderr"
|
|
"91porn-server/common/timeutil"
|
|
"91porn-server/models/v/proxymod"
|
|
"91porn-server/models/v/txnmod"
|
|
"91porn-server/models/v/usermod"
|
|
"91porn-server/models/v/walletmod"
|
|
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
func GetBills(uid uint64, t int64) (data []txnmod.BillsRes, hasNext bool, timeline int64, err error) {
|
|
data = make([]txnmod.BillsRes, 0)
|
|
if t == 0 {
|
|
trans, queryErr := txnmod.LastLedgerTime(uid, time.Now())
|
|
if queryErr != nil {
|
|
return nil, false, 0, queryErr
|
|
}
|
|
if trans.ID.IsZero() {
|
|
return
|
|
}
|
|
t = trans.CreatedAt.Unix()
|
|
}
|
|
start, end := timeutil.EarlyLastMonth(time.Unix(t, 0))
|
|
var navErr error
|
|
var wg sync.WaitGroup
|
|
wg.Add(2)
|
|
common.Go(func() {
|
|
defer wg.Done()
|
|
br := txnmod.BillsRes{
|
|
Month: start.Format("2006-01"),
|
|
}
|
|
br.List, err = txnmod.FindLedgerByTime(uid, start, end)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if len(br.List) > 0 {
|
|
for _, v := range br.List {
|
|
switch v.TranTypeInt {
|
|
case int64(txnmod.WithdrawTransfer):
|
|
br.Withdraw += -v.Amount
|
|
br.WithdrawStr = strconv.Itoa(int(br.Withdraw))
|
|
if br.WithdrawStr == "" {
|
|
br.WithdrawStr = "0"
|
|
}
|
|
case int64(txnmod.WorksIncome), int64(txnmod.ProxyIncome):
|
|
br.Income += v.Amount
|
|
if br.IncomeStr == "" {
|
|
br.IncomeStr = "0"
|
|
}
|
|
incomeDeci, _ := decimal.NewFromString(br.IncomeStr)
|
|
actualIncomeDeci := decimal.NewFromFloat(v.ActualAmount)
|
|
br.IncomeStr = incomeDeci.Add(actualIncomeDeci).String()
|
|
}
|
|
}
|
|
}
|
|
if len(br.List) > 0 {
|
|
data = append(data, br)
|
|
}
|
|
})
|
|
common.Go(func() {
|
|
defer wg.Done()
|
|
trans, queryErr := txnmod.LastLedgerTime(uid, start)
|
|
if queryErr != nil {
|
|
navErr = queryErr
|
|
return
|
|
}
|
|
if !trans.ID.IsZero() {
|
|
timeline = trans.CreatedAt.Unix()
|
|
hasNext = true
|
|
}
|
|
|
|
})
|
|
wg.Wait()
|
|
if err == nil {
|
|
err = navErr
|
|
}
|
|
return
|
|
}
|
|
|
|
type rechargeLevel struct {
|
|
Min int
|
|
Max int
|
|
Level int
|
|
}
|
|
|
|
var rchgLevel = []rechargeLevel{
|
|
{Min: 0, Max: 4900, Level: 0},
|
|
{Min: 5000, Max: 9900, Level: 1},
|
|
{Min: 10000, Max: 19900, Level: 2},
|
|
{Min: 20000, Max: 29900, Level: 3},
|
|
{Min: 30000, Max: 49900, Level: 4},
|
|
{Min: 50000, Max: 99900, Level: 5},
|
|
{Min: 100000, Max: 199900, Level: 6},
|
|
{Min: 200000, Max: 499900, Level: 7},
|
|
{Min: 500000, Max: 1000000, Level: 8},
|
|
}
|
|
|
|
func calRchgLevel(amount int) (level int, cur int, limit int) {
|
|
l := len(rchgLevel)
|
|
if l == 0 {
|
|
return
|
|
}
|
|
min := rchgLevel[0].Min
|
|
max := rchgLevel[l-1].Max
|
|
if amount < min {
|
|
return rchgLevel[0].Level, 0, (rchgLevel[0].Max - rchgLevel[0].Min)
|
|
}
|
|
if amount > max {
|
|
return rchgLevel[l-1].Level, (rchgLevel[l-1].Max - rchgLevel[l-1].Min), (rchgLevel[l-1].Max - rchgLevel[l-1].Min)
|
|
}
|
|
for _, v := range rchgLevel {
|
|
if amount >= v.Min && amount <= v.Max {
|
|
return v.Level, (amount - v.Min), (v.Max - v.Min)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetRchgLevel 获取用户充值等级
|
|
func GetRchgLevel(uid uint64) (usermod.RechargeLevel, error) {
|
|
wallet, err := walletmod.GetWallet(uid)
|
|
if err != nil {
|
|
return usermod.RechargeLevel{}, err
|
|
}
|
|
level, cur, limit := calRchgLevel(int(wallet.Consumption))
|
|
info := usermod.RechargeLevel{
|
|
Level: level,
|
|
Current: cur / 10,
|
|
Limit: limit / 10,
|
|
}
|
|
return info, err
|
|
}
|
|
|
|
// GetUidsRchgLevel 获取用户充值等级
|
|
func GetUidsRchgLevel(uids []uint64) (map[uint64]usermod.RechargeLevel, error) {
|
|
mInfo := make(map[uint64]usermod.RechargeLevel)
|
|
mWallet, err := walletmod.GetWalletMap(uids)
|
|
if err != nil {
|
|
return mInfo, err
|
|
}
|
|
for _, v := range mWallet {
|
|
level, cur, limit := calRchgLevel(int(v.Consumption))
|
|
info := usermod.RechargeLevel{
|
|
Level: level,
|
|
Current: cur / 10,
|
|
Limit: limit / 10,
|
|
}
|
|
mInfo[v.UID] = info
|
|
}
|
|
return mInfo, err
|
|
}
|
|
|
|
func GetIncome(uid uint64) (interface{}, error) {
|
|
var income string
|
|
var vidIncomeToday float64
|
|
var vidIncomeMonth float64
|
|
var vidTotalIncome float64
|
|
var proxyIncomeToday float64
|
|
var proxyIncomeMonth float64
|
|
var InviteeTotalCount int64
|
|
var proxyTotalIncome float64
|
|
var proxyTotalPer int64
|
|
var InviteedTodayCount int64
|
|
var InviteedMonthCount int64
|
|
var proxyPerMonth int64
|
|
var proxyPerToday int64
|
|
var data []txnmod.AgentIncomeRes
|
|
now := time.Now()
|
|
startM, endM := timeutil.EarlyLastMonth(now)
|
|
startD, endD := timeutil.EarlyLastDay(now)
|
|
var wg sync.WaitGroup
|
|
wg.Add(8)
|
|
common.Go(func() { //1
|
|
defer wg.Done()
|
|
w, _ := walletmod.GetWallet(uid)
|
|
if w == nil {
|
|
return
|
|
}
|
|
income = decimal.NewFromInt(w.Income).Add(decimal.NewFromFloat(w.IncomePot)).String()
|
|
vidTotalIncome = w.VidIncome
|
|
proxyTotalIncome = w.ProxyIncome
|
|
proxyTotalPer = w.Performance
|
|
})
|
|
common.Go(func() { //2
|
|
defer wg.Done()
|
|
InviteeTotalCount, _ = proxymod.NextProxyCount(uid, time.Unix(0, 0), now)
|
|
})
|
|
common.Go(func() { //3
|
|
defer wg.Done()
|
|
InviteedMonthCount, _ = proxymod.NextProxyCount(uid, startM, endM)
|
|
})
|
|
common.Go(func() { //4
|
|
defer wg.Done()
|
|
InviteedTodayCount, _ = proxymod.NextProxyCount(uid, startD, endD)
|
|
|
|
})
|
|
common.Go(func() { //5
|
|
defer wg.Done()
|
|
vidIncomeToday, _, _ = txnmod.GetIncomeByType(uid, txnmod.WorksIncome, startD, endD)
|
|
})
|
|
common.Go(func() { //6
|
|
defer wg.Done()
|
|
vidIncomeMonth, _, _ = txnmod.GetIncomeByType(uid, txnmod.WorksIncome, startM, endM)
|
|
|
|
})
|
|
common.Go(func() { //7
|
|
defer wg.Done()
|
|
proxyIncomeMonth, proxyPerMonth, _ = txnmod.GetIncomeByType(uid, txnmod.ProxyIncome, startM, endM)
|
|
})
|
|
common.Go(func() { //8
|
|
defer wg.Done()
|
|
data, _ = txnmod.GetProxyIncomeForToday(uid, startD, endD)
|
|
})
|
|
wg.Wait()
|
|
m := make(map[string]interface{})
|
|
m["income"] = income
|
|
m["vidIncomeToday"] = strconv.FormatFloat(vidIncomeToday, 'f', 2, 64)
|
|
m["vidIncomeMonth"] = strconv.FormatFloat(vidIncomeMonth, 'f', 2, 64)
|
|
m["vidIncomeTotal"] = strconv.FormatFloat(vidTotalIncome, 'f', 2, 64)
|
|
m["proxyIncomeTotal"] = strconv.FormatFloat(proxyTotalIncome, 'f', 2, 64)
|
|
m["proxyPer"] = strconv.FormatInt(proxyTotalPer, 10)
|
|
m["inviteeCountTotal"] = strconv.FormatInt(InviteeTotalCount, 10)
|
|
m["proxyIncomeLv1"] = "0"
|
|
m["proxyIncomeLv2"] = "0"
|
|
m["proxyIncomeLv3"] = "0"
|
|
m["proxyIncomeLv4"] = "0"
|
|
m["proxyIncomeLv5"] = "0"
|
|
for _, v := range data {
|
|
proxyIncomeToday += v.TotalMoney
|
|
proxyPerToday += v.TotalPerformance
|
|
m["proxyIncomeLv"+strconv.Itoa(v.AgentLevel)] = strconv.FormatFloat(v.TotalMoney, 'f', 2, 64)
|
|
}
|
|
m["proxyPerMonth"] = strconv.FormatInt(proxyPerMonth, 10)
|
|
m["proxyIncomeMonth"] = strconv.FormatFloat(proxyIncomeMonth, 'f', 2, 64)
|
|
m["inviteeCountMonth"] = strconv.FormatInt(InviteedMonthCount, 10)
|
|
m["proxyPerToday"] = strconv.FormatInt(proxyPerToday, 10)
|
|
m["proxyIncomeToday"] = strconv.FormatFloat(proxyIncomeToday, 'f', 2, 64)
|
|
m["inviteeCountToday"] = strconv.FormatInt(InviteedTodayCount, 10)
|
|
return m, nil
|
|
}
|
|
|
|
func GetBills1(uid uint64, year int, month int, pageNumber, pageSize uint64) (res txnmod.Bills1Res, err error) {
|
|
start, end := timeutil.GetTimeByMonthAndYear(month, year)
|
|
if pageNumber > 1 {
|
|
res.List, res.HasNext, err = txnmod.Ibills(uid, pageNumber, pageSize, start, end)
|
|
return
|
|
}
|
|
var incomeErr, expenditureErr, listErr, navigationErr error
|
|
var wg sync.WaitGroup
|
|
wg.Add(4)
|
|
common.Go(func() { //1
|
|
defer wg.Done()
|
|
i, queryErr := txnmod.Income(uid, start, end)
|
|
incomeErr = queryErr
|
|
res.Income = strconv.FormatFloat(i, 'f', 2, 64)
|
|
})
|
|
common.Go(func() { //2
|
|
defer wg.Done()
|
|
e, queryErr := txnmod.Expenditure(uid, start, end)
|
|
expenditureErr = queryErr
|
|
res.Expenditure = strconv.FormatFloat(e, 'f', 2, 64)
|
|
})
|
|
common.Go(func() { //3
|
|
defer wg.Done()
|
|
start, end := timeutil.GetTimeByMonthAndYear(month, year)
|
|
res.List, res.HasNext, listErr = txnmod.Ibills(uid, pageNumber, pageSize, start, end)
|
|
})
|
|
common.Go(func() { //4
|
|
defer wg.Done()
|
|
t, queryErr := txnmod.LastLedgerTime(uid, start)
|
|
navigationErr = queryErr
|
|
if !t.ID.IsZero() {
|
|
res.HasNextMonth = true
|
|
res.Year = t.CreatedAt.Year()
|
|
res.Month = int(t.CreatedAt.Month())
|
|
}
|
|
})
|
|
wg.Wait()
|
|
for _, queryErr := range []error{incomeErr, expenditureErr, listErr, navigationErr} {
|
|
if queryErr != nil {
|
|
return txnmod.Bills1Res{}, queryErr
|
|
}
|
|
}
|
|
if len(res.List) > 0 {
|
|
for i, tlog := range res.List {
|
|
if tlog.TranTypeInt == int64(txnmod.GoldCouplePayVID) {
|
|
res.List[i].ActualAmount = 0
|
|
res.List[i].Amount = 0
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// FruitCoinBill 果币账单
|
|
func FruitCoinBill(uid uint64, in *FruitCoinBillCond) (interface{}, stderr.Code) {
|
|
var data = map[string]interface{}{
|
|
"list": []interface{}{},
|
|
}
|
|
list, err := txnmod.QueryAll(in.Query(uid), in.Options())
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("查询果币账单列表异常[%v]", err))
|
|
return data, stderr.ErrDbQueryError
|
|
}
|
|
data["list"] = list
|
|
return data, stderr.Success
|
|
}
|