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.
371 lines
13 KiB
371 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) |
|
LogAccount(ctx context.Context, req *game.LogAccountReq) (res *game.LogAccountRes, 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" |
|
deadFilename := "DeadVillagerManagerComponent" + fmt.Sprint(req.SrcName) + ".json" |
|
decorationFilename := "DecorationManagerComponent" + fmt.Sprint(req.SrcName) + ".json" |
|
g.Try(ctx, func(ctx context.Context) { |
|
mongoexportCommand(ctx, filename, "Unit", int64(req.SrcName), mongoConfig, 1) |
|
mongoexportCommand(ctx, storeFilename, "StoreComponent", unit.Uid, mongoConfig, 2) |
|
mongoexportCommand(ctx, deadFilename, "DeadVillagerManagerComponent", unit.Uid, mongoConfig, 2) |
|
mongoexportCommand(ctx, decorationFilename, "DecorationManagerComponent", unit.Uid, mongoConfig, 2) |
|
|
|
res.Filename = filename |
|
res.StoreFilename = storeFilename |
|
res.DeadFilename = deadFilename |
|
res.DecorationFilename = decorationFilename |
|
}) |
|
fmt.Println("CopyUnit GetRoleDelta", gjson.MustEncodeString(res)) |
|
return |
|
} |
|
|
|
func mongoexportCommand(ctx context.Context, filename string, collection string, uid int64, mongoConfig internal.MongoType, qType int) { |
|
g.Try(ctx, func(ctx context.Context) { |
|
args := []string{} |
|
dir := "./download/" + filename |
|
args = append(args, fmt.Sprintf("--uri=\"%s\"", mongoConfig.Link1)) |
|
args = append(args, fmt.Sprintf("--authenticationDatabase=%s", mongoConfig.Auth)) |
|
args = append(args, fmt.Sprintf("--collection=%s", collection)) |
|
args = append(args, "--jsonArray") |
|
args = append(args, fmt.Sprintf("--out=\"%s\"", dir)) |
|
if qType == 1 { |
|
args = append(args, fmt.Sprintf("--query=\"{\\\"UniqueId\\\":%d}\"", uid)) |
|
} else { |
|
args = append(args, fmt.Sprintf("--query=\"{\\\"_id\\\":%d}\"", uid)) |
|
} |
|
|
|
args = append(args, "--jsonFormat=canonical") |
|
args = append(args, "--type=json") |
|
err := utils.CmdCommand(ctx, "mongoexport", args...) |
|
if err != nil { |
|
log.Printf(" %s cmd.Run() args failed with %s\n", dir, err) |
|
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 { |
|
err = err1 |
|
return |
|
} |
|
userDir := "./download/Unit" + fmt.Sprint(req.DestName) + fmt.Sprint(time.Now().Unix()) + ".json" |
|
srcId, err1 := writeFile1(destId, userDir, req.Filename, req.DestName) |
|
if err1 != nil { |
|
err = err1 |
|
return |
|
} |
|
log.Printf("copyUnit srcid: %s, destid: %d, DestName: %d", srcId, destId, req.DestName) |
|
userStoreDir := "./download/StoreComponent" + fmt.Sprint(req.DestName) + fmt.Sprint(time.Now().Unix()) + ".json" |
|
err = writeFile(destId, srcId, userStoreDir, req.StoreFilename) |
|
if err != nil { |
|
return |
|
} |
|
userDeadDir := "./download/DeadVillagerManagerComponent" + fmt.Sprint(req.DestName) + fmt.Sprint(time.Now().Unix()) + ".json" |
|
err = writeFile(destId, srcId, userDeadDir, req.DeadFilename) |
|
if err != nil { |
|
return |
|
} |
|
userDecorationDir := "./download/DecorationManagerComponent" + fmt.Sprint(req.DestName) + fmt.Sprint(time.Now().Unix()) + ".json" |
|
err = writeFile(destId, srcId, userDecorationDir, req.DecorationFilename) |
|
if err != nil { |
|
return |
|
} |
|
g.Try(ctx, func(ctx context.Context) { |
|
mongoimportCommand(ctx, "Unit", userDir, mongoConfig) |
|
mongoimportCommand(ctx, "StoreComponent", userStoreDir, mongoConfig) |
|
mongoimportCommand(ctx, "DeadVillagerManagerComponent", userDeadDir, mongoConfig) |
|
mongoimportCommand(ctx, "DecorationManagerComponent", userDecorationDir, mongoConfig) |
|
}) |
|
return |
|
} |
|
|
|
func writeFile1(destId int64, userDir string, fileName string, destName int) (srcId string, err error) { |
|
srcUserDir := "./download/" + fileName |
|
writeByte, err1 := os.ReadFile(srcUserDir) |
|
if err1 != nil { |
|
return "", err1 |
|
} |
|
|
|
srcUid := "" |
|
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"]) |
|
} |
|
|
|
log.Printf("copyUnit srcid: %s, uid: %s, destId: %d, destName: %d", srcId, srcUid, destId, destName) |
|
if srcId == "" || srcUid == "" { |
|
return |
|
} |
|
writeUnitString := strings.ReplaceAll(gjson.MustEncodeString(v1), srcId, fmt.Sprint(destId)) |
|
writeUnitString = internal.ReplaceLastOccurrence(writeUnitString, srcUid, fmt.Sprint(destName)) |
|
if err = os.WriteFile(userDir, []byte(writeUnitString), 0666); err != nil { |
|
log.Println(err) |
|
return |
|
} |
|
|
|
return |
|
} |
|
|
|
func writeFile(destId int64, srcId string, userDir string, fileName string) (err error) { |
|
srcDir := "./download/" + fileName |
|
writeByte, err1 := os.ReadFile(srcDir) |
|
if err1 != nil { |
|
return err1 |
|
} |
|
|
|
var v map[string]interface{} |
|
if strings.HasPrefix(string(writeByte), "[") { |
|
user := []interface{}{} |
|
json.Unmarshal(writeByte, &user) |
|
if len(user) != 0 { |
|
v = user[0].(map[string]interface{}) |
|
} |
|
} else { |
|
json.Unmarshal(writeByte, &v) |
|
} |
|
if len(v) != 0 { |
|
writeString := strings.ReplaceAll(gjson.MustEncodeString(v), srcId, fmt.Sprint(destId)) |
|
if err = os.WriteFile(userDir, []byte(writeString), 0666); err != nil { |
|
log.Println(err) |
|
return |
|
} |
|
} |
|
|
|
return |
|
} |
|
|
|
func mongoimportCommand(ctx context.Context, collection, dir string, mongoConfig internal.MongoType) { |
|
args := []string{} |
|
args = append(args, fmt.Sprintf("--uri=\"%s\"", mongoConfig.Link1)) |
|
args = append(args, fmt.Sprintf("--authenticationDatabase=%s", mongoConfig.Auth)) |
|
args = append(args, fmt.Sprintf("--collection=%s", collection)) |
|
args = append(args, fmt.Sprintf("--file=\"%s\"", dir)) |
|
args = append(args, "--type=json") |
|
args = append(args, "--mode=upsert") |
|
|
|
err := utils.CmdCommand(ctx, "mongoimport", args...) |
|
if err != nil { |
|
log.Printf("%s cmd.Run() failed with %s\n", dir, err) |
|
return |
|
} |
|
|
|
err = os.Remove(dir) |
|
if err != nil { |
|
log.Printf("%s os.Remove failed with %s\n", dir, err) |
|
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 |
|
} |
|
|
|
func (ga *gameManageImpl) LogAccount(ctx context.Context, req *game.LogAccountReq) (res *game.LogAccountRes, err error) { |
|
res, err = internal.LogAccount(ctx, req) |
|
return |
|
}
|
|
|