264 lines
7.2 KiB
Go
264 lines
7.2 KiB
Go
package svc
|
||
|
||
import (
|
||
"errors"
|
||
"net/rpc"
|
||
|
||
"github.com/globalsign/mgo"
|
||
"github.com/globalsign/mgo/bson"
|
||
|
||
"mongo.games.com/game/common"
|
||
"mongo.games.com/game/dbproxy/mongo"
|
||
"mongo.games.com/game/model"
|
||
"mongo.games.com/goserver/core/logger"
|
||
)
|
||
|
||
func ItemLogsCollection(plt string) *mongo.Collection {
|
||
s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, model.ItemLogDBName)
|
||
if s != nil {
|
||
c_itemlog, first := s.DB().C(model.ItemLogCollName)
|
||
if first {
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"logtype"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"itemid"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"createts"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"-createts"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"typeid"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"gameid"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"gamefreeid"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"snid", "logtype", "itemid", "typeid"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"roomconfigid"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"typeid", "roomconfigid"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
|
||
c_itemlog.EnsureIndex(mgo.Index{Key: []string{"-ts"}, Background: true, Sparse: true})
|
||
}
|
||
return c_itemlog
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type ItemLogSvc struct {
|
||
}
|
||
|
||
func (svc *ItemLogSvc) InsertItemLog(log *model.ItemLog, ret *bool) (err error) {
|
||
clog := ItemLogsCollection(log.Platform)
|
||
if clog == nil {
|
||
return
|
||
}
|
||
err = clog.Insert(log)
|
||
if err != nil {
|
||
logger.Logger.Warn("InsertItemLog error:", err)
|
||
return
|
||
}
|
||
*ret = true
|
||
return
|
||
}
|
||
|
||
// GetItemCount 获取v卡兑换消耗数量
|
||
func GetItemCount(platform string, snid, id int32, tp int) (count int64) {
|
||
c := ItemLogsCollection(platform)
|
||
if c == nil {
|
||
return 0
|
||
}
|
||
var err error
|
||
var swapN int64
|
||
var costN int64
|
||
type m struct {
|
||
Count int64 `bson:"count"`
|
||
}
|
||
tc := new(m)
|
||
// 兑换返还
|
||
err = c.Pipe([]bson.M{
|
||
{"$match": bson.M{"snid": snid, "logtype": 0, "itemid": id, "typeid": common.GainWay_Exchange}},
|
||
{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": "$count"}}},
|
||
}).AllowDiskUse().One(tc)
|
||
if err != nil && !errors.Is(err, mgo.ErrNotFound) {
|
||
logger.Logger.Warn("GetItemCount swapN error:", err)
|
||
return 0
|
||
}
|
||
swapN = tc.Count
|
||
|
||
// 消耗总数量
|
||
tc = new(m)
|
||
err = c.Pipe([]bson.M{
|
||
{"$match": bson.M{"snid": snid, "logtype": 1, "itemid": id, "typeid": common.GainWay_Exchange}},
|
||
{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": "$count"}}},
|
||
}).AllowDiskUse().One(tc)
|
||
if err != nil && !errors.Is(err, mgo.ErrNotFound) {
|
||
logger.Logger.Warn("GetItemCount costN error:", err)
|
||
return 0
|
||
}
|
||
costN = tc.Count
|
||
|
||
if tp == 0 {
|
||
// 获得数量 = 获得总数量 - 兑换返还 - 比赛返回
|
||
} else {
|
||
// 消耗数量 = 消耗总数量 - 兑换返还
|
||
count = costN - swapN
|
||
}
|
||
if count < 0 {
|
||
count = 0
|
||
}
|
||
return count
|
||
}
|
||
|
||
func (svc *ItemLogSvc) GetItemCount(req *model.ItemCountParam, count *int64) error {
|
||
*count = GetItemCount(req.Platform, req.Snid, req.Id, req.Tp)
|
||
return nil
|
||
}
|
||
|
||
func (svc *ItemLogSvc) UpdateState(req *model.UpdateParam, res *model.UpdateRes) error {
|
||
c := ItemLogsCollection(req.Platform)
|
||
if c == nil {
|
||
return nil
|
||
}
|
||
err := c.UpdateId(req.LogId, bson.M{"$set": bson.M{"status": req.State}})
|
||
return err
|
||
}
|
||
|
||
func (svc *ItemLogSvc) GetClawdollItemLog(args *model.ClawdollItemLogReq, ret *model.GetClawdollItemLogRet) (err error) {
|
||
var sql []bson.M
|
||
|
||
var Logs []model.RetClawdollItemLog
|
||
for _, typeId := range args.TypeIds {
|
||
var SubLogs []model.RetClawdollItemLog
|
||
sql = append(sql, bson.M{"snid": args.Snid, "typeid": typeId})
|
||
|
||
switch typeId {
|
||
case common.GainWay_ShopBuy: // 充值记录
|
||
sql = append(sql, bson.M{"itemid": common.ItemIDClawdoll})
|
||
case common.GainWayItemShopChangeDoll: // 积分支出
|
||
sql = append(sql, bson.M{"itemid": common.ItemDollCard})
|
||
case common.GainWayItemFenGain: // 积分获取
|
||
sql = append(sql, bson.M{"itemid": common.ItemDollCard})
|
||
}
|
||
|
||
c := ItemLogsCollection(args.Platform)
|
||
if c == nil {
|
||
return
|
||
}
|
||
|
||
err = c.Find(bson.M{"$and": sql}).Select(bson.M{"itemid": 1, "createts": 1, "typeid": 1, "count": 1, "logtype": 1}).All(&SubLogs)
|
||
|
||
Logs = append(Logs, SubLogs...)
|
||
}
|
||
|
||
ret.Logs = Logs
|
||
return
|
||
}
|
||
|
||
func (svc *ItemLogSvc) GetClawdollSuccessItemLog(args *model.ClawdollSuccessItemLogReq, ret *model.GetClawdollSuccessItemLogRet) (err error) {
|
||
itemTypeIds := []int32{common.GainWayClawdollCatch}
|
||
cond := bson.M{"typeid": bson.M{"$in": itemTypeIds}}
|
||
|
||
c := ItemLogsCollection(args.Platform)
|
||
if c == nil {
|
||
return
|
||
}
|
||
|
||
var datas []model.ItemLog
|
||
err = c.Find(cond).All(&datas)
|
||
if err != nil {
|
||
logger.Logger.Error("GetClawdollSuccessItemLog error: ", err)
|
||
return err
|
||
}
|
||
|
||
if datas == nil {
|
||
logger.Logger.Error("GetClawdollSuccessItemLog datas == nil error")
|
||
return nil
|
||
}
|
||
|
||
if len(datas) > 0 {
|
||
type PInfo struct {
|
||
SnId int32
|
||
Name string // 昵称
|
||
Roles *model.ModInfo
|
||
}
|
||
|
||
var retPlayerList []PInfo
|
||
cplayerdata := PlayerDataCollection(args.Platform)
|
||
if cplayerdata == nil {
|
||
return err
|
||
}
|
||
|
||
var conds []int32
|
||
tempMap := map[int32]byte{} // 存放不重复主键
|
||
for i := 0; i < len(datas); i++ {
|
||
l := len(tempMap)
|
||
tempMap[datas[i].SnId] = 0
|
||
if len(tempMap) != l { // 加入map后，map长度变化，则元素不重复
|
||
conds = append(conds, datas[i].SnId)
|
||
}
|
||
}
|
||
|
||
selecter := bson.M{"snid": bson.M{"$in": conds}}
|
||
err = cplayerdata.Find(selecter).Select(bson.M{"snid": 1, "name": 1, "roles": 1}).All(&retPlayerList)
|
||
if err != nil {
|
||
logger.Logger.Error("GetClawdollSuccessItemLog find player is error", err)
|
||
return err
|
||
}
|
||
|
||
for _, data := range datas {
|
||
log := model.ClawdollSuccessItemLog{
|
||
SnId: data.SnId,
|
||
Time: data.CreateTs,
|
||
}
|
||
|
||
for _, playerData := range retPlayerList {
|
||
if playerData.SnId == data.SnId {
|
||
log.Name = playerData.Name
|
||
// 头像模型ID
|
||
roleId := common.DefaultRoleId
|
||
if playerData.Roles != nil {
|
||
roleId = int(playerData.Roles.ModId)
|
||
}
|
||
log.ModId = int32(roleId)
|
||
|
||
ret.Logs = append(ret.Logs, log)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (svc *ItemLogSvc) GetItemLog(req *model.GetItemLogParam, res *model.GetItemLogRes) error {
|
||
c := ItemLogsCollection(req.Plt)
|
||
if c == nil {
|
||
return nil
|
||
}
|
||
|
||
err := c.Find(bson.M{"snid": req.SnId, "ts": bson.M{"$gt": req.Ts}}).All(&res.Logs)
|
||
if err != nil && !errors.Is(err, mgo.ErrNotFound) {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (svc *ItemLogSvc) Insert(req *model.InsertItemLogReq, res *bool) error {
|
||
if len(req.Logs) == 0 {
|
||
return nil
|
||
}
|
||
|
||
clog := ItemLogsCollection(req.Logs[0].Platform)
|
||
if clog == nil {
|
||
logger.Logger.Errorf("ItemLogSvc.Insert collection not found Platform:%v", req.Logs[0].Platform)
|
||
return nil
|
||
}
|
||
var docs []interface{}
|
||
for _, v := range req.Logs {
|
||
docs = append(docs, v)
|
||
}
|
||
if err := clog.Insert(docs...); err != nil {
|
||
logger.Logger.Warn("ItemLogSvc.Insert error:", err)
|
||
return err
|
||
}
|
||
*res = true
|
||
return nil
|
||
}
|
||
|
||
func init() {
|
||
rpc.Register(new(ItemLogSvc))
|
||
}
|