You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1523 lines
34 KiB
Go
1523 lines
34 KiB
Go
package scripts
|
|
|
|
import (
|
|
"fmt"
|
|
"mygo/api"
|
|
"mygo/conf"
|
|
"mygo/dbhelper"
|
|
"mygo/libs"
|
|
"mygo/model"
|
|
"mygo/response"
|
|
"mygo/say"
|
|
"mygo/validator"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/fatih/color"
|
|
"github.com/labstack/echo/v4"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
)
|
|
|
|
func GetHome(c echo.Context) error {
|
|
data := response.AdminHomeResponse{}
|
|
|
|
collection := dbhelper.GetMongoCollection("user")
|
|
|
|
today_count, err := model.GetTodayCreateCount(collection)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.TodayUserTotal = today_count
|
|
|
|
total_count, err1 := model.GetTotalCreateCount(collection)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
data.UserTotal = total_count
|
|
|
|
col := dbhelper.GetMongoCollection("recharge_order")
|
|
|
|
today_recharge_total, err2 := model.GetTodayRechargeToTal(col)
|
|
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.TodayRechargeTotal = int64(today_recharge_total)
|
|
|
|
recharge_total, err3 := model.GetRechargeToTal(col)
|
|
if err3 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.RechargeTotal = int64(recharge_total)
|
|
|
|
thisWeek, lastWeek, err4 := model.CalculateThisWeekAndLastWeekPaymentTotal(col)
|
|
|
|
if err4 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
data.ThisWeek = thisWeek
|
|
data.LastWeek = lastWeek
|
|
|
|
thisMonth, lastMonth, err5 := model.CalculateThisMonthAndLastMonthPaymentTotal(col)
|
|
|
|
if err5 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
data.ThisMonth = thisMonth
|
|
data.LastMonth = lastMonth
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func AgentLogin(c echo.Context) error {
|
|
body := &validator.LoginBody{}
|
|
err := c.Bind(body)
|
|
data := response.AgentLoginResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.Username == "" || body.PassWord == "" || body.T == "" || body.Code == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
username := body.Username
|
|
password := body.PassWord
|
|
t := body.T
|
|
code := body.Code
|
|
|
|
red := dbhelper.GetRedisDb()
|
|
|
|
if !conf.ISTEST {
|
|
key := libs.AdminLoginCode(t)
|
|
savecdoe, err := red.Get(key).Result()
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if !strings.EqualFold(strings.ToLower(savecdoe), strings.ToLower(code)) {
|
|
return say.Success(c, 10002, data)
|
|
}
|
|
red.Del(key)
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("agent")
|
|
|
|
user, e := model.GetGameAgentByUserName(col, username)
|
|
|
|
if e != nil {
|
|
return say.Success(c, 10004, data)
|
|
}
|
|
|
|
if user.Disable != 0 {
|
|
return say.Success(c, 10034, data)
|
|
}
|
|
|
|
if user.DelFlag != 0 {
|
|
return say.Success(c, 10035, data)
|
|
}
|
|
|
|
salt := user.Salt
|
|
pwd := user.PassWord
|
|
uname, err := libs.DecryptWithFixedSalt(password, conf.ObtenationIterations, pwd, salt)
|
|
if err != nil {
|
|
return say.Success(c, 10005, data)
|
|
}
|
|
if uname != username {
|
|
return say.Success(c, 10005, data)
|
|
}
|
|
|
|
//TODO:登录成功修改 登录时间
|
|
ip := echo.ExtractIPFromXFFHeader()(c.Request())
|
|
model.UpdateGameAgent(col, user.ID, ip, time.Now().Format("2006-01-02 15:04:05"))
|
|
|
|
data.User = user
|
|
//TODO:设置jwt
|
|
token := libs.GenString(32)
|
|
k := libs.AdminTokenKey(user.ID)
|
|
red.Set(k, token, 0)
|
|
mykey := fmt.Sprintf("%s-%s", conf.APPNAME, conf.APPVERSION)
|
|
myjwt := libs.JWTEncrypt(user.ID, token, mykey)
|
|
|
|
data.Jwt = myjwt
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetAgentHome(c echo.Context) error {
|
|
body := &validator.AgentHomeBody{}
|
|
err := c.Bind(body)
|
|
data := response.AgentHomeResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
agent_id := body.AgentID
|
|
|
|
if agent_id == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("user")
|
|
|
|
count, err1 := model.GetAgentChildCount(collection, agent_id)
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.UserTotal = count
|
|
|
|
col1 := dbhelper.GetMongoCollection("recharge_order")
|
|
|
|
recharge_total, err2 := model.GetAgentChildRechargeToTal(col1, agent_id)
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.RechargeTotal = int64(recharge_total)
|
|
|
|
col2 := dbhelper.GetMongoCollection("withdraw")
|
|
|
|
withdrawn_total, err3 := model.GetWithdrawToTalByUid(col2, agent_id)
|
|
if err3 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.WithdrawTotal = withdrawn_total
|
|
|
|
col4 := dbhelper.GetMongoCollection("agent")
|
|
|
|
agent, err4 := model.GetAgent(col4, agent_id)
|
|
|
|
if err4 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
data.NotWithdrawTotal = agent.Money
|
|
|
|
this_month_withdraw, last_month_withdraw, err4 := model.CalculateThisMonthAndLastMonthAgentWithdrawPaymentTotal(col2, agent_id)
|
|
if err4 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.ThisMonthWithdraw = this_month_withdraw
|
|
data.LastMonthWithdraw = last_month_withdraw
|
|
|
|
col3 := dbhelper.GetMongoCollection("order_rebate_log")
|
|
|
|
this_month_recharge, last_month_recharge, err4 := model.CalculateThisMonthAndLastMonthAgentChildPaymentTotal(col3, agent_id)
|
|
if err4 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.ThisMonthRecharge = this_month_recharge
|
|
data.LastMonthRecharge = last_month_recharge
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetAgentShareUrl(c echo.Context) error {
|
|
body := &validator.AgentHomeBody{}
|
|
err := c.Bind(body)
|
|
data := response.AgentUrlResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
agent_id := body.AgentID
|
|
if agent_id == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("agent_url")
|
|
|
|
res, err1 := model.GetAgentUrlByAgengId(collection, agent_id)
|
|
color.Yellow("res = %+v", res)
|
|
// color.Yellow("err1 = ", err1)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
id := res.ID
|
|
if res.ID != "" {
|
|
ex := res.ExpireTime
|
|
timestamp := time.Now().Unix()
|
|
if ex > int(timestamp) {
|
|
url := res.Url
|
|
data.Url = url
|
|
}
|
|
}
|
|
|
|
red := dbhelper.GetRedisDb()
|
|
|
|
k := libs.GetAccessTokenKey()
|
|
|
|
token, _ := red.Get(k).Result()
|
|
// color.Yellow("red token = %s", token)
|
|
if token == "" {
|
|
access_token, err1 := api.GetAccessToken("wx1b9547fef3f6f477", "a4f794bf4177b6abc573ed692dc249b7")
|
|
// color.Yellow("access_token = %s", access_token)
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
err2 := red.Set(k, access_token, 3600*time.Second).Err()
|
|
// color.Yellow("GetAccessToken err2 = ", err2)
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
token = access_token
|
|
}
|
|
reqBody := api.Req{
|
|
Path: "",
|
|
Query: fmt.Sprintf("parent_id=%s", agent_id),
|
|
ExpireType: 1,
|
|
ExpireInterval: 30,
|
|
EnvVersion: "release",
|
|
}
|
|
|
|
// color.Yellow("GetAccessToken reqBody = %+v", reqBody)
|
|
// color.Yellow("token = %s", token)
|
|
// color.Yellow("reqBody = %+v", reqBody)
|
|
result, err3 := api.GetShareUrl(token, reqBody)
|
|
// color.Yellow("GetAccessToken err3 = ", err3)
|
|
if err3 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
color.Blue("result = %+v", result)
|
|
|
|
if result.Errcode != 0 {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
url := result.URLLink
|
|
|
|
if id == "" {
|
|
id = libs.GenId()
|
|
}
|
|
|
|
timestamp := time.Now().Unix()
|
|
ex := timestamp + 30*86400
|
|
err4 := model.UpdateAgentUrl(collection, id, agent_id, url, int(ex))
|
|
if err4 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
data.Url = url
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func List(c echo.Context) error {
|
|
body := &validator.MemberListBody{}
|
|
err := c.Bind(body)
|
|
data := response.GameUserListResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page == 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit == 0 {
|
|
limit = 20
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("user")
|
|
|
|
offset := (page - 1) * limit
|
|
|
|
members, count, err := model.GetGameUserList(collection, body.UID, offset, limit)
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
red := dbhelper.GetRedisDb()
|
|
|
|
mymap := make(map[int]int)
|
|
|
|
for _, v := range members {
|
|
k := fmt.Sprintf("%s:invite:num:%d", conf.APPNAME, v.UID)
|
|
num, _ := red.Get(k).Result()
|
|
c, _ := strconv.Atoi(num)
|
|
mymap[v.UID] = c
|
|
}
|
|
|
|
data.Page = page
|
|
data.Limit = limit
|
|
data.List = members
|
|
data.Referrer = mymap
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetAgentList(c echo.Context) error {
|
|
body := &validator.ReqAgentListBody{}
|
|
err := c.Bind(body)
|
|
data := response.GameAgentListResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page == 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit == 0 {
|
|
limit = 20
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("agent")
|
|
|
|
offset := (page - 1) * limit
|
|
|
|
members, count, err := model.GetGameAgentList(collection, body.ID, body.UserName, offset, limit)
|
|
color.Red(" GetGameAgentList err = %v ", err)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
data.Page = page
|
|
data.Limit = limit
|
|
data.List = members
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func CheckAgentUserName(c echo.Context) error {
|
|
data := response.NoneResponse{}
|
|
body := &validator.CheckUserNameBody{}
|
|
err := c.Bind(body)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
id := c.QueryParam("id")
|
|
if id == "" || body.UserName == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
username := body.UserName
|
|
collection := dbhelper.GetMongoCollection("agent")
|
|
user, err := model.GetGameAgentByUserName(collection, username)
|
|
if err != nil || user.ID != "" {
|
|
return say.Success(c, 10013, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func AddAgent(c echo.Context) error {
|
|
body := &validator.SetAgentBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.UserName == "" || body.PassWord == "" || body.SecondPassWord == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
username := body.UserName
|
|
|
|
password := body.PassWord
|
|
|
|
collection := dbhelper.GetMongoCollection("agent")
|
|
agent, err1 := model.GetGameAgentByUserName(collection, username)
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if agent.ID != "" {
|
|
return say.Success(c, 10013, data)
|
|
}
|
|
|
|
salt := libs.GenString(8)
|
|
|
|
pwd, err := libs.EncryptWithFixedSalt(password, conf.ObtenationIterations, username, salt)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
a_doc := model.GameAgent{
|
|
ID: libs.GenId(),
|
|
UserName: username,
|
|
Money: 0,
|
|
PassWord: pwd,
|
|
Salt: salt,
|
|
RealName: body.RealName,
|
|
LoginTime: "",
|
|
LoginIp: "",
|
|
Disable: 0,
|
|
DelFlag: 0,
|
|
Created_at: time.Now().Format("2006-01-02 15:04:05"),
|
|
Updated_at: "",
|
|
Deleted_at: "",
|
|
}
|
|
err2 := model.AddGameAgent(collection, a_doc)
|
|
if err2 != nil {
|
|
return say.Success(c, 10027, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func UpdateAgent(c echo.Context) error {
|
|
body := &validator.UpdateAgentBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.AgentID == "" || body.UserName == "" || body.PassWord == "" || body.SecondPassWord == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
agent_id := body.AgentID
|
|
|
|
username := body.UserName
|
|
|
|
password := body.PassWord
|
|
|
|
collection := dbhelper.GetMongoCollection("agent")
|
|
agent, err1 := model.GetAgent(collection, agent_id)
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if agent.ID == "" {
|
|
return say.Success(c, 10030, data)
|
|
}
|
|
|
|
salt := libs.GenString(8)
|
|
|
|
pwd, err := libs.EncryptWithFixedSalt(password, conf.ObtenationIterations, username, salt)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
err2 := model.UpdatePwdGameAgent(collection, agent_id, pwd, salt, time.Now().Format("2006-01-02 15:04:05"))
|
|
if err2 != nil {
|
|
return say.Success(c, 10023, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
//删除代理
|
|
func DelAgent(c echo.Context) error {
|
|
body := &validator.DelAgentBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.AgentID == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("agent")
|
|
|
|
agent, err := model.GetAgent(collection, body.AgentID)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if agent.ID == "" {
|
|
return say.Success(c, 10028, data)
|
|
}
|
|
|
|
err1 := model.DelGameAgent(collection, agent.ID, time.Now().Format("2006-01-02 15:04:05"))
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetAgentInfo(c echo.Context) error {
|
|
body := &validator.GetAgentByAdminIDBody{}
|
|
err := c.Bind(body)
|
|
data := response.AdminAgentResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
db := dbhelper.GetMySqlDB()
|
|
agent, err := model.GetAgentByAdminId(db, body.AdminId)
|
|
if err != nil {
|
|
return say.Success(c, 10030, data)
|
|
}
|
|
data.Agent = agent
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func Freeze(c echo.Context) error {
|
|
body := &validator.ReqFreezeBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.UID <= 0 || body.FreezeReason == "" || body.FreezeDate == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("user")
|
|
|
|
err1 := model.SetAccountStatus(collection, body.UID, 1, body.FreezeReason, body.FreezeDate)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func UnFreeze(c echo.Context) error {
|
|
body := &validator.UidBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.UID <= 0 {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("user")
|
|
|
|
err1 := model.SetAccountStatus(collection, body.UID, 0, "", "")
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func FreezeAgent(c echo.Context) error {
|
|
body := &validator.ReqFreezeAgentBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.AgentID == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("agent")
|
|
|
|
err1 := model.SetAgentFreezeStatus(collection, body.AgentID, 1)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func UnFreezeAgent(c echo.Context) error {
|
|
body := &validator.ReqFreezeAgentBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.AgentID == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("agent")
|
|
|
|
err1 := model.SetAgentFreezeStatus(collection, body.AgentID, 0)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetCodeList(c echo.Context) error {
|
|
id := c.QueryParam("id")
|
|
|
|
data := response.GameCodeListResponse{}
|
|
if id == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
body := &validator.PageLimitBody{}
|
|
err := c.Bind(body)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
page := body.Page
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit <= 0 {
|
|
limit = 10
|
|
}
|
|
collection := dbhelper.GetMongoCollection("game_code")
|
|
|
|
offset := (page - 1) * limit
|
|
|
|
codes, total, err := model.GetGameCodeList(collection, offset, limit)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.Total = total
|
|
data.List = codes
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func AddCode(c echo.Context) error {
|
|
|
|
data := response.NoneResponse{}
|
|
body := &validator.GameCodeBody{}
|
|
err := c.Bind(body)
|
|
color.Red("bind err = %v", err)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.Code == "" || len(body.Items) <= 0 {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if body.ExpireType == "2" {
|
|
if body.StartExpire == "" || body.EndExpire == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
}
|
|
expire_type, _ := strconv.Atoi(body.ExpireType)
|
|
doc := model.GameCode{
|
|
Code: body.Code,
|
|
Total: body.Total,
|
|
Num: 0,
|
|
Vip: body.Vip,
|
|
Items: body.Items,
|
|
ExpireType: expire_type,
|
|
StartExpire: body.StartExpire,
|
|
EndExpire: body.EndExpire,
|
|
Status: body.Status,
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("game_code")
|
|
|
|
err1 := model.AddGameCode(collection, doc)
|
|
color.Red("bind err1 = %v", err1)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func UpdateCode(c echo.Context) error {
|
|
data := response.NoneResponse{}
|
|
body := &validator.GameCodeBody{}
|
|
err := c.Bind(body)
|
|
color.Red("bind err = %v", err)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.Code == "" || len(body.Items) <= 0 {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if body.ExpireType == "2" {
|
|
if body.StartExpire == "" || body.EndExpire == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
}
|
|
expire_type, _ := strconv.Atoi(body.ExpireType)
|
|
doc := model.GameCode{
|
|
Code: body.Code,
|
|
Total: body.Total,
|
|
Num: 0,
|
|
Vip: body.Vip,
|
|
Items: body.Items,
|
|
ExpireType: expire_type,
|
|
StartExpire: body.StartExpire,
|
|
EndExpire: body.EndExpire,
|
|
Status: body.Status,
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("game_code")
|
|
|
|
err1 := model.UpdateGameCode(collection, doc)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func ChangeStatus(c echo.Context) error {
|
|
data := response.NoneResponse{}
|
|
body := &validator.ChangeStatusBody{}
|
|
err := c.Bind(body)
|
|
color.Red("bind err = %v", err)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.Code == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
collection := dbhelper.GetMongoCollection("game_code")
|
|
|
|
err1 := model.UpdateGameCodeStatus(collection, body.Code, body.Status)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func DelCode(c echo.Context) error {
|
|
data := response.NoneResponse{}
|
|
body := &validator.ChangeStatusBody{}
|
|
err := c.Bind(body)
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.Code == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
collection := dbhelper.GetMongoCollection("game_code")
|
|
|
|
err1 := model.DelGameCode(collection, body.Code)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetServerList(c echo.Context) error {
|
|
|
|
data := response.GameServerListResponse{}
|
|
body := &validator.GetServerListBody{}
|
|
err := c.Bind(body)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
page := body.Page
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit <= 0 {
|
|
limit = 10
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("game_server")
|
|
|
|
offset := (page - 1) * limit
|
|
|
|
servers, total, err := model.GetGameServerList(col, offset, limit)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
ids := []int{}
|
|
for _, v := range servers {
|
|
ids = append(ids, int(v.ID))
|
|
}
|
|
|
|
col1 := dbhelper.GetMongoCollection("user")
|
|
|
|
result, err1 := model.CountGameUsersByRegionIDsAndTimeRange(col1, ids, body.StartTime, body.EndTime)
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
result2, err2 := model.CountGameOnlineUsersByRegionIDs(col1, ids)
|
|
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
resp := []model.RespGameServer{}
|
|
|
|
for _, v := range servers {
|
|
res := model.RespGameServer{
|
|
ID: v.ID,
|
|
ServerName: v.ServerName,
|
|
Status: v.Status,
|
|
UserCount: int64(result[int(v.ID)]),
|
|
OnlineCount: int64(result2[int(v.ID)]),
|
|
}
|
|
resp = append(resp, res)
|
|
}
|
|
|
|
data.List = resp
|
|
data.Total = total
|
|
data.Page = page
|
|
data.Limit = limit
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func AddServer(c echo.Context) error {
|
|
|
|
data := response.NoneResponse{}
|
|
body := &validator.AddServerBody{}
|
|
err := c.Bind(body)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.ServerName == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
col1 := dbhelper.GetMongoCollection("inc_id")
|
|
id, err := model.GetId(col1, "server", 1)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
doc := model.GameServer{
|
|
ID: id,
|
|
ServerName: body.ServerName,
|
|
Status: 0,
|
|
}
|
|
|
|
col2 := dbhelper.GetMongoCollection("game_server")
|
|
|
|
err1 := model.AddGameServer(col2, doc)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetServerItemList(c echo.Context) error {
|
|
|
|
data := response.ServerItemListResponse{}
|
|
body := &validator.ServerItemPageLimitBody{}
|
|
err := c.Bind(body)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.ServerId == 0 {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit <= 0 {
|
|
limit = 10
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("server_item")
|
|
|
|
offset := (page - 1) * limit
|
|
|
|
servers, total, err := model.GetServerItemList(col, body.ServerId, offset, limit)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
col1 := dbhelper.GetMongoCollection("user")
|
|
|
|
ids := []int{}
|
|
for _, v := range servers {
|
|
ids = append(ids, int(v.ID))
|
|
}
|
|
|
|
result1, err1 := model.CountGameUsersByServerIDsAndTimeRange(col1, ids, body.StartTime, body.EndTime)
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
result2, err2 := model.CountGameOnlineUsersByServerIDs(col1, ids)
|
|
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
resp := []model.RespServerItem{}
|
|
|
|
for _, v := range servers {
|
|
res := model.RespServerItem{
|
|
ID: v.ID,
|
|
ServerId: v.ServerId,
|
|
Status: v.Status,
|
|
UserCount: int64(result1[int(v.ID)]),
|
|
OnlineCount: int64(result2[int(v.ID)]),
|
|
ActivityId: v.ActivityId,
|
|
ActivityEndTime: v.ActivityEndTime,
|
|
CreatedAt: v.CreatedAt,
|
|
}
|
|
resp = append(resp, res)
|
|
}
|
|
|
|
data.List = resp
|
|
data.Total = total
|
|
data.Page = page
|
|
data.Limit = limit
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func OpenServer(c echo.Context) error {
|
|
data := response.NoneResponse{}
|
|
body := &validator.OpenServerBody{}
|
|
err := c.Bind(body)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
if body.ServerId == 0 || body.ServerNum == 0 {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("server_item")
|
|
|
|
total, err := model.GetServerItemCount(col, int64(body.ServerId))
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if total+int64(body.ServerNum) > 100 {
|
|
|
|
return say.Success(c, 10001, data)
|
|
|
|
}
|
|
|
|
err1 := model.UpdateServer(col)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
now := time.Now()
|
|
created_at := now.Format("2006-01-02 15:04:05")
|
|
|
|
col1 := dbhelper.GetMongoCollection("inc_id")
|
|
var docs []interface{}
|
|
for i := 0; i < body.ServerNum; i++ {
|
|
id, err := model.GetId(col1, "server_id", 1)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
docs = append(docs, model.ServerItem{ID: id, ServerId: int64(body.ServerId), Status: 1, ActivityId: int64(body.ActivityId), ActivityEndTime: body.ActivityEndTime, CreatedAt: created_at})
|
|
}
|
|
|
|
err2 := model.AddServer(col, docs)
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func OnlineUser(c echo.Context) error {
|
|
data := response.OnlineUsersResponse{}
|
|
|
|
collection := dbhelper.GetMongoCollection("user")
|
|
|
|
count, err := model.GetOnlineUserCount(collection)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
data.Count = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetAgentChild(c echo.Context) error {
|
|
body := &validator.AgentChildListBody{}
|
|
err := c.Bind(body)
|
|
data := response.GameUserListResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.AgentID == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page == 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit == 0 {
|
|
limit = 20
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("user")
|
|
|
|
offset := (page - 1) * limit
|
|
members, count, err := model.GetAgentChildList(collection, body.AgentID, offset, limit)
|
|
color.Yellow("member %v=", members)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
data.Page = page
|
|
data.Limit = limit
|
|
data.List = members
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetRebateLog(c echo.Context) error {
|
|
body := &validator.GetRebateBody{}
|
|
err := c.Bind(body)
|
|
data := response.AgentRebateLogResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.AgentID == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page == 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit == 0 {
|
|
limit = 20
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("order_rebate_log")
|
|
|
|
offset := (page - 1) * limit
|
|
logs, count, err := model.GetRebateLogList(collection, body.AgentID, body.UID, body.OrderNo, body.CreatedAtStart, body.CreatedAtEnd, offset, limit)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
data.Page = page
|
|
data.Limit = limit
|
|
data.List = logs
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetWithdrawLog(c echo.Context) error {
|
|
body := &validator.AgentChildListBody{}
|
|
err := c.Bind(body)
|
|
data := response.AgentWithdrawLogResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page == 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit == 0 {
|
|
limit = 20
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("withdraw")
|
|
|
|
offset := (page - 1) * limit
|
|
logs, count, err := model.GetWithdrawLogList(collection, body.AgentID, offset, limit)
|
|
color.Red("GetWithdrawLogList err = %v", err)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
data.Page = page
|
|
data.Limit = limit
|
|
data.List = logs
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
//提现
|
|
func DoWithdraw(c echo.Context) error {
|
|
body := &validator.AgentWithdrawBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.AgentID == "" || body.Money <= 0 || body.Content == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
col := dbhelper.GetMongoCollection("agent")
|
|
|
|
user, err := model.GetAgent(col, body.AgentID)
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if user.Type == 0 || user.Account == "" {
|
|
return say.Success(c, 10037, data)
|
|
}
|
|
|
|
if user.Money < body.Money {
|
|
|
|
return say.Success(c, 10031, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("withdraw")
|
|
|
|
doc := model.Withdraw{
|
|
ID: primitive.NewObjectID(),
|
|
Money: body.Money,
|
|
Uid: body.AgentID,
|
|
Status: 0,
|
|
Content: body.Content,
|
|
Type: user.Type,
|
|
Account: user.Account,
|
|
CreatedAt: time.Now().Format("2006-01-02 15:04:05"),
|
|
}
|
|
|
|
err1 := model.DoWithdraw(collection, doc)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
err2 := model.DecrMoney(col, body.AgentID, -body.Money)
|
|
|
|
// color.Red("err2 = %v", err2)
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func DoWithdrawStatus(c echo.Context) error {
|
|
body := &validator.WithdrawStatusBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.ID == "" || body.Status <= 0 || body.Taxes == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
id, err := primitive.ObjectIDFromHex(body.ID)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
collection := dbhelper.GetMongoCollection("withdraw")
|
|
|
|
result, e1 := model.GetWithdrawById(collection, id)
|
|
|
|
if e1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if result.ID.String() == "" {
|
|
return say.Success(c, 10032, data)
|
|
}
|
|
|
|
if result.Status > 0 {
|
|
return say.Success(c, 10033, data)
|
|
}
|
|
|
|
if body.Status == 1 {
|
|
|
|
} else {
|
|
col := dbhelper.GetMongoCollection("agent")
|
|
err1 := model.DecrMoney(col, result.Uid, result.Money)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
}
|
|
err1 := model.DoWithdrawStatus(collection, id, body.Status, body.Taxes)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetRechargeList(c echo.Context) error {
|
|
body := &validator.RechargeListBody{}
|
|
err := c.Bind(body)
|
|
data := response.RechargeListResponse{}
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page == 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit == 0 {
|
|
limit = 20
|
|
}
|
|
|
|
offset := (page - 1) * limit
|
|
|
|
col := dbhelper.GetMongoCollection("recharge_order")
|
|
lists, count, err := model.GetRechargeList(col, limit, offset, body.OrderNo, body.UID, body.RegionId, body.ServerId, body.PayStatus, body.PayAtStart, body.PayAtEnd, body.CreatedAtStart, body.CreatedAtEnd)
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.Page = page
|
|
data.Limit = limit
|
|
data.List = lists
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetActivityList(c echo.Context) error {
|
|
data := response.ActivityListResponse{}
|
|
col := dbhelper.GetMongoCollection("activity_config")
|
|
lists, err := model.GetActivityList(col)
|
|
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.List = lists
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func UpdateActivity(c echo.Context) error {
|
|
body := &validator.ActivityReqBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
color.Red("err = %v", err)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("activity_config")
|
|
err1 := model.UpdateActivity(col, body.ID, body.Status, body.StartTime, body.EndTime)
|
|
color.Red("err1 = %v", err1)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetMailList(c echo.Context) error {
|
|
body := &validator.PageLimitBody{}
|
|
err := c.Bind(body)
|
|
data := response.MailListResponse{}
|
|
color.Red("err = %v", err)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
page := body.Page
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
limit := body.Limit
|
|
|
|
if limit <= 0 {
|
|
limit = 10
|
|
}
|
|
|
|
offset := (page - 1) * limit
|
|
col := dbhelper.GetMongoCollection("mail")
|
|
result, count, err1 := model.GetMailList(col, offset, limit)
|
|
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.Limit = limit
|
|
data.Page = page
|
|
data.List = result
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func SendMail(c echo.Context) error {
|
|
body := &validator.SendMailReqBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
libs.PutQueue(map[string]interface{}{"type": "admin", "data": body})
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func SaveBili(c echo.Context) error {
|
|
body := &validator.ReqSaveBiliBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
red := dbhelper.GetRedisDb()
|
|
k := libs.GetAgentBiliKey()
|
|
red.Set(k, body.Bili, 0)
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetBili(c echo.Context) error {
|
|
data := response.GetBiliResponse{}
|
|
|
|
red := dbhelper.GetRedisDb()
|
|
k := libs.GetAgentBiliKey()
|
|
bili, err := red.Get(k).Result()
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
bl, err := strconv.ParseFloat(bili, 64)
|
|
if err != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
data.Bili = bl
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetMyTiXianList(c echo.Context) error {
|
|
body := &validator.GetTiXianListBody{}
|
|
err := c.Bind(body)
|
|
data := response.GameTixianListResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
// if body.AgentID == "" {
|
|
// return say.Success(c, 10001, data)
|
|
// }
|
|
col := dbhelper.GetMongoCollection("game_tixian")
|
|
result, count, err := model.GetGameTiXianList(col, body.AgentID)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
data.List = result
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func GetAllTiXianList(c echo.Context) error {
|
|
body := &validator.GetTiXianListBody{}
|
|
err := c.Bind(body)
|
|
data := response.GameTixianListResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("game_tixian")
|
|
result, count, err := model.GetGameTiXianList(col, body.AgentID)
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
data.List = result
|
|
data.Total = count
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func ApplyTixian(c echo.Context) error {
|
|
body := &validator.ApplyTiXianListBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if body.AgentID == "" || body.Type <= 0 || body.Account == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("game_tixian")
|
|
|
|
doc := model.GameTiXian{
|
|
ID: libs.GenId(),
|
|
AgentID: body.AgentID,
|
|
Type: body.Type,
|
|
Account: body.Account,
|
|
Status: 0,
|
|
Created_at: time.Now().Format("2006-01-02 15:04:05"),
|
|
}
|
|
|
|
err1 := model.AddGameTixian(col, doc)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func UpdateApplyTixian(c echo.Context) error {
|
|
body := &validator.UpdateApplyTiXianListBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if body.ID == "" || body.AgentID == "" || body.Type <= 0 || body.Account == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("game_tixian")
|
|
|
|
doc := model.GameTiXian{
|
|
Type: body.Type,
|
|
Account: body.Account,
|
|
Status: 0,
|
|
Updated_at: time.Now().Format("2006-01-02 15:04:05"),
|
|
}
|
|
|
|
err1 := model.UpdateGameTixian(col, body.ID, doc)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|
|
|
|
func AgreeTixian(c echo.Context) error {
|
|
body := &validator.AgreeTiXianListBody{}
|
|
err := c.Bind(body)
|
|
data := response.NoneResponse{}
|
|
if err != nil {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if body.ID == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
col := dbhelper.GetMongoCollection("game_tixian")
|
|
|
|
result, err1 := model.GetGameTixianByID(col, body.ID)
|
|
if err1 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
// color.Blue("result = %+v", result)
|
|
if result.ID == "" {
|
|
return say.Success(c, 10001, data)
|
|
}
|
|
|
|
if result.Status > 0 {
|
|
return say.Success(c, 10036, data)
|
|
}
|
|
|
|
err2 := model.AgreeGameTixian(col, result.ID, body.Status, time.Now().Format("2006-01-02 15:04:05"))
|
|
if err2 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
|
|
if body.Status == 1 {
|
|
col1 := dbhelper.GetMongoCollection("agent")
|
|
|
|
err3 := model.UpdateAccount(col1, result.AgentID, int(result.Type), result.Account)
|
|
if err3 != nil {
|
|
return say.Success(c, 10000, data)
|
|
}
|
|
}
|
|
|
|
return say.Success(c, 0, data)
|
|
}
|