tyj_admin/internal/serviceGame/order.go

package serviceGame

import (
	"context"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"go.mongodb.org/mongo-driver/bson"
	"math/rand"
	"time"
	"tyj_admin/api/v1/game"
	"tyj_admin/internal/model/entity"
	"tyj_admin/internal/serviceGame/internal"
)

type IGameOrder interface {
	GetOrders(ctx context.Context, req *game.OrderSearchReq) (res *game.OrderSearchRes, err error)
	GetOrderCount(ctx context.Context, req *game.OrderCountReq) (res *game.OrderCountRes, err error)
	ChangeCoin(ctx context.Context, req *game.AddCoinReq) (res *game.AddCoinRes, err error)
	AndroidDeposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error)
	IosDeposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error)
}

type gameOrderImpl struct {
}

var gameOrderService = gameOrderImpl{}

func GameOrder() IGameOrder {
	return &gameOrderService
}

func (o gameOrderImpl) ChangeCoin(ctx context.Context, req *game.AddCoinReq) (res *game.AddCoinRes, err error) {
	res = new(game.AddCoinRes)
	mqttMoney := internal.MqttChangeMoney{}
	mqttMoney.Body.Money = req.Amount
	mqttMoney.Body.Uids = req.Uid
	mqttMoney.Body.Type = req.AmountType
	mqttMoney.Body.ModuleType = "changeMoney"
	mqttMoney.ModuleId = "webadmin"
	mqttMoney.ReqId = 1
	js, err := json.Marshal(mqttMoney)
	connectCh := make(chan bool)
	server := "192.168.2.100:3005"
	internal.SendMqttMoney(js, connectCh, server)
	defer close(connectCh)
	var result bool
	for {
		select {
		case result = <-connectCh:
			if result == false {
				err = gerror.New("失败")
				return
			} else {
				return
			}
		}
	}

}

type AndroIdRecharge struct {
	Server     int32  `json:"server"`
	RechargeId int32  `json:"rechargeId"`
	CpOrderId  string `json:"cpOrderId"`
	OrderId    string `json:"orderId"`
	Timestamp  int64  `json:"timestamp"`
	Account    string `json:"account"`
	Channel    int32  `json:"channel"`
	Amount     int32  `json:"amount"`
}

type IosRecharge struct {
	OrderId   string `json:"orderId"`
	Account   string `json:"uid"`
	Receipt   string `json:"receipt"`
	Server    int32  `json:"server"`
	TimeStamp int64  `json:"timeStamp"`
	ItemId    int32  `json:"itemId"`
	Gm        string `json:"gm"`
	Token     string `json:"token"`
}

type DepositResult struct {
	Status int         `json:"status"`
	Code   interface{} `json:"code"`
	Msg    string      `json:"msg"`
}

func (o gameOrderImpl) AndroidDeposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error) {
	orderId := fmt.Sprintf("GM%v%v%v", req.Account, time.Now().UnixMilli(), rand.Int())
	recharge := AndroIdRecharge{}
	recharge.Server = req.ServerId
	recharge.RechargeId = req.DepositId
	recharge.CpOrderId = orderId
	recharge.OrderId = orderId
	recharge.Timestamp = time.Now().Unix()
	recharge.Account = req.Account
	if req.DepositId == 1001 {
		recharge.Amount = 6
	} else if req.DepositId == 1002 {
		recharge.Amount = 30
	} else if req.DepositId == 1003 {
		recharge.Amount = 68
	}
	js, err := json.Marshal(recharge)
	ip := internal.ServerConfig[0]["topServer"].(string)
	rs, err := g.Client().Post(ctx, ip+"/recharge", js)
	result := DepositResult{}
	err = json.Unmarshal(rs.ReadAll(), &result)
	if result.Status == 2 {
		err = nil
		return
	}
	err = gerror.New(result.Msg)
	return
}

func (o gameOrderImpl) IosDeposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error) {
	//orderId := "GM" + req.Account + time.Now().String() + strconv.Itoa(rand.Int())
	orderId := fmt.Sprintf("GM%v%v%v", req.Account, time.Now().UnixMilli(), rand.Int())
	recharge := IosRecharge{}
	recharge.OrderId = orderId
	recharge.Account = req.Account
	recharge.Receipt = "receipt"
	recharge.Server = req.ServerId
	recharge.TimeStamp = time.Now().Unix()
	recharge.ItemId = req.DepositId
	recharge.Gm = "3EAB9E4B6F9CB7255A27D2084D78C2FB"
	buf := fmt.Sprintf("%v%v%v%v%v%vdadf31fd9b66bd847609247800433e6c", recharge.OrderId, recharge.ItemId, recharge.Receipt, recharge.Server, recharge.TimeStamp, recharge.Account)
	m := md5.New()
	m.Write([]byte(buf))
	recharge.Token = hex.EncodeToString(m.Sum(nil))
	js, err := json.Marshal(recharge)
	ip := internal.ServerConfig[0]["topServer"].(string)
	rs, err := g.Client().Post(ctx, ip+"/recharge", js)
	result := DepositResult{}
	err = json.Unmarshal(rs.ReadAll(), &result)
	if result.Status == 2 {
		err = nil
		return
	}
	err = gerror.New(result.Msg)
	return
}

func (o gameOrderImpl) GetOrders(ctx context.Context, req *game.OrderSearchReq) (res *game.OrderSearchRes, err error) {
	account := req.Account
	role := new(entity.RoleDetail)
	res = new(game.OrderSearchRes)
	if req.SearchType == 1 { //账号+渠道查询
		if len(req.Channel) > 0 {
			account = req.Channel + "_" + account
		}
		g.Try(ctx, func(ctx context.Context) {
			res.Orders, err = internal.GetOrdersByAccount(ctx, account)
		})
	} else if req.SearchType == 2 { //角色UID+区服
		role, err = internal.GetRoleDetail(ctx, req.Uid, req.ServerId)
		if err != nil {
			return
		}
		account = role.Account
		g.Try(ctx, func(ctx context.Context) {
			res.Orders, err = internal.GetOrdersByAccount(ctx, account)
		})
	} else if req.SearchType == 3 { //时间段查询
		g.Try(ctx, func(ctx context.Context) {
			res.Orders, err = internal.GetOrdersByTime(ctx, req.LowTime, req.UpTime)
		})
	} else if req.SearchType == 4 { //时间段查询
		g.Try(ctx, func(ctx context.Context) {
			res.Orders, err = internal.GetOrdersByOrderId(ctx, req.OrderId)
		})
	}

	return
}

func (o gameOrderImpl) GetOrderCount(ctx context.Context, req *game.OrderCountReq) (res *game.OrderCountRes, err error) {
	filter := bson.M{}

	if req.Amount > 0 {
		switch req.CompareType {
		case 1:
			filter["money"] = req.Amount
		case 2:
			filter["money"] = bson.M{"$lte": req.Amount}
		case 3:
			filter["money"] = bson.M{"$lt": req.Amount}
		case 4:
			filter["money"] = bson.M{"$gt": req.Amount}
		case 5:
			filter["money"] = bson.M{"$gte": req.Amount}
		}
	}
	if req.Gender > 0 {
		filter["gender"] = req.Gender
	}
	if req.LowAge >= 0 && req.UpAge > 0 {
		low := (time.Now().AddDate(-req.UpAge, 0, 0)).Unix()
		up := (time.Now().AddDate(-req.LowAge, 0, 0)).Unix()
		filter["bearTime"] = bson.M{"$gte": low, "$lte": up}
	}

	g.Try(ctx, func(ctx context.Context) {
		res.Orders, err = internal.GetOrderCount(ctx, filter, req.ServerId)
	})

	return
}