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.
360 lines
13 KiB
360 lines
13 KiB
package serviceGame |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"errors" |
|
"fmt" |
|
"github.com/gogf/gf/v2/encoding/gjson" |
|
"github.com/gogf/gf/v2/frame/g" |
|
"log" |
|
"os" |
|
"strings" |
|
"time" |
|
"tyj_admin/api/v1/game" |
|
"tyj_admin/internal/model/entity" |
|
"tyj_admin/internal/service" |
|
"tyj_admin/internal/serviceGame/internal" |
|
"tyj_admin/library/libUtils" |
|
"tyj_admin/utils" |
|
) |
|
|
|
type IGameManage interface { |
|
ChangeGm(ctx context.Context, req *game.ChangeGmReq) (res *game.ChangeGmRes, err error) |
|
ChangePwd(ctx context.Context, req *game.ResetPwdReq) (res *game.ResetPwdRes, err error) |
|
SearchGm(ctx context.Context, req *game.SearchGmReq) (res *game.SearchGmRes, err error) |
|
SetGmToClient(ctx context.Context, req *game.SetGmToClientReq) (res *game.SetGmToClientRes, err error) |
|
CopyUnit(ctx context.Context, req *game.CopyUnitReq) (res *game.CopyUnitRes, err error) |
|
UpdateUnit(ctx context.Context, req *game.UpdateUnitReq) (res *game.UpdateUnitRes, err error) |
|
DelAccount(ctx context.Context, req *game.DelAccountReq) (res *game.DelAccountRes, err error) |
|
SearchAccount(ctx context.Context, req *game.SearchAccountReq) (res *game.SearchAccountRes, err error) |
|
GetKeepAlive(ctx context.Context, req *game.GetKeepAliveReq) (res *game.GetKeepAliveRes, err error) |
|
GetLive(ctx context.Context, req *game.GetLiveReq) (res *game.GetLiveRes, err error) |
|
RegisterCount(ctx context.Context, req *game.RegisterCountReq) (res *game.RegisterCountRes, err error) |
|
GetShopItemLog(ctx context.Context, req *game.GetShopItemLogReq) (res *game.GetShopItemLogRes, err error) |
|
GetShopItemList(ctx context.Context, req *game.GetShopItemListReq) (res *game.GetShopItemListRes, err error) |
|
GetOperLog(ctx context.Context, req *game.GetOperLogReq) (res *game.GetOperLogRes, err error) |
|
} |
|
|
|
type gameManageImpl struct { |
|
} |
|
|
|
var gameManageService = gameManageImpl{} |
|
|
|
func GameManage() IGameManage { |
|
return &gameManageService |
|
} |
|
|
|
func (ga *gameManageImpl) ChangePwd(ctx context.Context, req *game.ResetPwdReq) (res *game.ResetPwdRes, err error) { |
|
//pwd := gmd5.MustEncryptString(req.Pwd + "sdsd") |
|
res, err = internal.ChangePwd(ctx, req.Account, req.Pwd, fmt.Sprint(req.ServerId)) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) SearchGm(ctx context.Context, req *game.SearchGmReq) (res *game.SearchGmRes, err error) { |
|
res = new(game.SearchGmRes) |
|
res.Gm, err = internal.SearchGm(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) SetGmToClient(ctx context.Context, req *game.SetGmToClientReq) (res *game.SetGmToClientRes, err error) { |
|
res = new(game.SetGmToClientRes) |
|
res, err = internal.SetGmToClient(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) ChangeGm(ctx context.Context, req *game.ChangeGmReq) (res *game.ChangeGmRes, err error) { |
|
res = new(game.ChangeGmRes) |
|
res, err = internal.ChangeGm(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) CopyUnit(ctx context.Context, req *game.CopyUnitReq) (res *game.CopyUnitRes, err error) { |
|
res = new(game.CopyUnitRes) |
|
unit, err := internal.GetUnitByUid(ctx, int64(req.SrcName), req.SrcServer) |
|
if err != nil { |
|
fmt.Println("GetAccount:", err) |
|
return |
|
} |
|
if req.SrcServer != unit.Server { |
|
var serverInfo entity.GameLoginUrl |
|
for _, v := range internal.ServerList { |
|
if v.Id == unit.Server { |
|
serverInfo = v |
|
break |
|
} |
|
} |
|
return nil, errors.New("区服选择错误！当前区服在<" + fmt.Sprint(serverInfo.Id) + "><" + serverInfo.Name + ">区") |
|
} |
|
mongoConfig := internal.MongoConfigs[fmt.Sprint(unit.Server)] |
|
if mongoConfig.Id == "" { |
|
return res, errors.New("区服不存在！") |
|
} |
|
filename := "Unit" + fmt.Sprint(req.SrcName) + ".json" |
|
storeFilename := "storeComponent" + fmt.Sprint(req.SrcName) + ".json" |
|
userDir := "./download/" + filename |
|
storeDir := "./download/" + storeFilename |
|
|
|
g.Try(ctx, func(ctx context.Context) { |
|
name := "mongoexport" |
|
args := []string{} |
|
args1 := []string{} |
|
|
|
args = append(args, fmt.Sprintf("--uri=\"%s\"", mongoConfig.Link1)) |
|
args = append(args, fmt.Sprintf("--authenticationDatabase=%s", mongoConfig.Auth)) |
|
args1 = append(args1, fmt.Sprintf("--uri=\"%s\"", mongoConfig.Link1)) |
|
args1 = append(args1, fmt.Sprintf("--authenticationDatabase=%s", mongoConfig.Auth)) |
|
args = append(args, "--collection=Unit") |
|
args = append(args, "--jsonArray") |
|
args = append(args, fmt.Sprintf("--out=\"%s\"", userDir)) |
|
args = append(args, fmt.Sprintf("--query=\"{\\\"UniqueId\\\":%d}\"", req.SrcName)) |
|
args = append(args, "--jsonFormat=canonical") |
|
args = append(args, "--type=json") |
|
args1 = append(args1, "--collection=StoreComponent") |
|
args1 = append(args1, "--jsonArray") |
|
args1 = append(args1, fmt.Sprintf("--out=\"%s\"", storeDir)) |
|
args1 = append(args1, fmt.Sprintf("--query=\"{\\\"_id\\\":%d}\"", unit.Uid)) |
|
args1 = append(args1, "--jsonFormat=canonical") |
|
args1 = append(args1, "--type=json") |
|
|
|
err = utils.CmdCommand(ctx, name, args...) |
|
if err != nil { |
|
log.Printf("cmd.Run() args failed with %s\n", err) |
|
return |
|
} |
|
err = utils.CmdCommand(ctx, name, args1...) |
|
if err != nil { |
|
log.Printf("cmd.Run() args1 failed with %s\n", err) |
|
return |
|
} |
|
|
|
wireteString := fmt.Sprintf("mongoexport --uri=\"%s\" --authenticationDatabase=%s --collection=Unit --out=\"%s\" --query=\"{\\\"UniqueId\\\":%d}\" --jsonArray --jsonFormat=canonical --type=json", |
|
mongoConfig.Link1, mongoConfig.Auth, userDir, req.SrcName) |
|
writeString := fmt.Sprintf("mongoexport --uri=\"%s\" --authenticationDatabase=%s --collection=StoreComponent --out=\"%s\" --query=\"{\\\"_id\\\":%d}\" --jsonArray --jsonFormat=canonical --type=json", |
|
mongoConfig.Link1, mongoConfig.Auth, storeDir, unit.Uid) |
|
log.Println(wireteString) |
|
log.Println(writeString) |
|
|
|
res.Filename = filename |
|
res.StoreFilename = storeFilename |
|
}) |
|
fmt.Println("CopyUnit GetRoleDelta", res.Filename) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) UpdateUnit(ctx context.Context, req *game.UpdateUnitReq) (res *game.UpdateUnitRes, err error) { |
|
res = new(game.UpdateUnitRes) |
|
unit, err := internal.GetUnitByUid(ctx, int64(req.DestName), req.DestServer) |
|
if err != nil { |
|
fmt.Println("GetAccount:", err) |
|
return |
|
} |
|
if req.DestServer != unit.Server { |
|
var serverInfo entity.GameLoginUrl |
|
for _, v := range internal.ServerList { |
|
if v.Id == unit.Server { |
|
serverInfo = v |
|
break |
|
} |
|
} |
|
return nil, errors.New("区服选择错误！当前id在<" + fmt.Sprint(serverInfo.Id) + "><" + serverInfo.Name + ">区") |
|
} |
|
mongoConfig := internal.MongoConfigs[fmt.Sprint(unit.Server)] |
|
if mongoConfig.Id == "" { |
|
return res, errors.New("区服不存在！") |
|
} |
|
|
|
destId, err1 := internal.GetIdToUid(ctx, int64(req.DestName)) |
|
if err1 != nil { |
|
return res, err1 |
|
} |
|
userDir := "./download/Unit" + fmt.Sprint(req.DestName) + fmt.Sprint(time.Now().Unix()) + ".json" |
|
srcUserDir := "./download/" + req.Filename |
|
writeByte, err1 := os.ReadFile(srcUserDir) |
|
if err1 != nil { |
|
return res, err1 |
|
} |
|
|
|
srcUid := "" |
|
srcId := "" |
|
var v1 map[string]interface{} |
|
if strings.HasPrefix(string(writeByte), "[") { |
|
user := []interface{}{} |
|
json.Unmarshal(writeByte, &user) |
|
v1 = user[0].(map[string]interface{}) |
|
} else { |
|
json.Unmarshal(writeByte, &v1) |
|
} |
|
|
|
if _, ok := v1["UniqueId"]; ok { |
|
UniqueId := v1["UniqueId"].(map[string]interface{}) |
|
srcUid = fmt.Sprint(UniqueId["$numberInt"]) |
|
} |
|
if _, ok := v1["_id"]; ok { |
|
UniqueId := v1["_id"].(map[string]interface{}) |
|
srcId = fmt.Sprint(UniqueId["$numberLong"]) |
|
} |
|
|
|
userStoreDir := "./download/storeComponent" + fmt.Sprint(req.DestName) + fmt.Sprint(time.Now().Unix()) + ".json" |
|
srcStoreDir := "./download/" + req.StoreFilename |
|
writeStoreByte, err1 := os.ReadFile(srcStoreDir) |
|
if err1 != nil { |
|
return res, err1 |
|
} |
|
|
|
var v2 map[string]interface{} |
|
if strings.HasPrefix(string(writeStoreByte), "[") { |
|
user := []interface{}{} |
|
json.Unmarshal(writeStoreByte, &user) |
|
v2 = user[0].(map[string]interface{}) |
|
} else { |
|
json.Unmarshal(writeStoreByte, &v2) |
|
} |
|
|
|
log.Printf("copyUnit srcid: %s, uid: %s, destid: %d, uid: %d", srcId, srcUid, destId, req.DestName) |
|
if srcId == "" || srcUid == "" { |
|
return |
|
} |
|
writeUnitString := strings.ReplaceAll(gjson.MustEncodeString(v1), srcId, fmt.Sprint(destId)) |
|
writeStoreString := strings.ReplaceAll(gjson.MustEncodeString(v2), srcId, fmt.Sprint(destId)) |
|
writeUnitString = internal.ReplaceLastOccurrence(writeUnitString, srcUid, fmt.Sprint(req.DestName)) |
|
if err = os.WriteFile(userDir, []byte(writeUnitString), 0666); err != nil { |
|
log.Println(err) |
|
return |
|
} |
|
|
|
if err = os.WriteFile(userStoreDir, []byte(writeStoreString), 0666); err != nil { |
|
log.Println(err) |
|
return |
|
} |
|
|
|
writeUnitCmd := fmt.Sprintf("mongoimport --uri=\"%s\" --authenticationDatabase=%s --collection=Unit --file=\"%s\" --type=json --mode=upsert", |
|
mongoConfig.Link1, mongoConfig.Auth, userDir) |
|
writeStoreCmd := fmt.Sprintf("mongoimport --uri=\"%s\" --authenticationDatabase=%s --collection=StoreComponent --file=\"%s\" --type=json --mode=upsert", |
|
mongoConfig.Link1, mongoConfig.Auth, userStoreDir) |
|
log.Println("sh Unit: ", writeUnitCmd) |
|
log.Println("sh StoreComponent: ", writeStoreCmd) |
|
g.Try(ctx, func(ctx context.Context) { |
|
name := "mongoimport" |
|
args := []string{} |
|
args1 := []string{} |
|
args = append(args, fmt.Sprintf("--uri=\"%s\"", mongoConfig.Link1)) |
|
args = append(args, fmt.Sprintf("--authenticationDatabase=%s", mongoConfig.Auth)) |
|
args1 = append(args1, fmt.Sprintf("--uri=\"%s\"", mongoConfig.Link1)) |
|
args1 = append(args1, fmt.Sprintf("--authenticationDatabase=%s", mongoConfig.Auth)) |
|
args = append(args, "--collection=Unit") |
|
args = append(args, fmt.Sprintf("--file=\"%s\"", userDir)) |
|
args = append(args, "--type=json") |
|
args = append(args, "--mode=upsert") |
|
args1 = append(args1, "--collection=StoreComponent") |
|
args1 = append(args1, fmt.Sprintf("--file=\"%s\"", userStoreDir)) |
|
args1 = append(args1, "--type=json") |
|
args1 = append(args1, "--mode=upsert") |
|
|
|
err = utils.CmdCommand(ctx, name, args...) |
|
if err != nil { |
|
log.Printf("cmd.Run() failed with %s\n", err) |
|
return |
|
} |
|
err = utils.CmdCommand(ctx, name, args1...) |
|
if err != nil { |
|
log.Printf("cmd.Run() failed with %s\n", err) |
|
return |
|
} |
|
err = os.Remove(userDir) |
|
if err != nil { |
|
log.Printf("os.Remove failed with %s\n", err) |
|
return |
|
} |
|
err = os.Remove(userStoreDir) |
|
if err != nil { |
|
log.Printf("os.Remove failed with %s\n", err) |
|
return |
|
} |
|
|
|
}) |
|
fmt.Println("UpdateUnit GetRoleDelta", req.DestName) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) DelAccount(ctx context.Context, req *game.DelAccountReq) (res *game.DelAccountRes, err error) { |
|
user := service.Context().GetLoginUser(ctx) |
|
fulluser, err1 := service.User().GetUserByUsername(ctx, user.UserName) |
|
if err1 != nil { |
|
return nil, err1 |
|
} |
|
password := libUtils.EncryptPassword(req.Password, fulluser.UserSalt) |
|
if fulluser.UserPassword != password { |
|
log.Printf("密码错误! fulluser: %v, pwd: %s", gjson.MustEncodeString(fulluser), password) |
|
return nil, errors.New("密码错误!") |
|
} |
|
|
|
uid, err := internal.GetAccountUid2(ctx, req.SrcName, fmt.Sprint(req.ServerId)) |
|
if err != nil { |
|
fmt.Println("DelAccount GetAccount err", err) |
|
return nil, err |
|
} |
|
fmt.Printf("DelAccount uid: %d, server: %d", uid, req.ServerId) |
|
//_, err2 := internal.DelRole(ctx, uid, fmt.Sprint(req.ServerId)) |
|
//if err2 != nil { |
|
// fmt.Println("DelAccount err2: ", err2) |
|
// return nil, err2 |
|
//} |
|
_, err3 := internal.DelAccount(ctx, uid, fmt.Sprint(req.ServerId)) |
|
if err3 != nil { |
|
fmt.Println("DelAccount err3: ", err3) |
|
return nil, err3 |
|
} |
|
//_, err4 := internal.DelBaseInfo(ctx, uid, fmt.Sprint(req.ServerId)) |
|
//fmt.Println("DelAccount err4: ", err4) |
|
//_, err6 := internal.DelBazaar(ctx, uid, fmt.Sprint(req.ServerId)) |
|
//fmt.Println("DelAccount err6: ", err6) |
|
//_, err5 := internal.DelFriendUnit(ctx, uid, fmt.Sprint(req.ServerId)) |
|
//fmt.Println("DelAccount err5: ", err5) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) SearchAccount(ctx context.Context, req *game.SearchAccountReq) (res *game.SearchAccountRes, err error) { |
|
res, err = internal.SearchAccount(ctx, req) |
|
if err != nil { |
|
fmt.Println("err3: ", err) |
|
return nil, err |
|
} |
|
|
|
return res, err |
|
} |
|
|
|
/* * |
|
** |
|
** 留存 |
|
** |
|
* */ |
|
func (ga *gameManageImpl) GetKeepAlive(ctx context.Context, req *game.GetKeepAliveReq) (res *game.GetKeepAliveRes, err error) { |
|
res, err = internal.GetKeepAlive(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) GetLive(ctx context.Context, req *game.GetLiveReq) (res *game.GetLiveRes, err error) { |
|
res, err = internal.GetLive(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) RegisterCount(ctx context.Context, req *game.RegisterCountReq) (res *game.RegisterCountRes, err error) { |
|
res, err = internal.RegisterNum(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) GetShopItemLog(ctx context.Context, req *game.GetShopItemLogReq) (res *game.GetShopItemLogRes, err error) { |
|
res, err = internal.GetShopItemLog(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) GetShopItemList(ctx context.Context, req *game.GetShopItemListReq) (res *game.GetShopItemListRes, err error) { |
|
res, err = internal.GetShopItemList(ctx, req) |
|
return |
|
} |
|
|
|
func (ga *gameManageImpl) GetOperLog(ctx context.Context, req *game.GetOperLogReq) (res *game.GetOperLogRes, err error) { |
|
res, err = internal.GetOperLog(ctx, req) |
|
return |
|
}
|
|
|