tyj_admin/internal/serviceGame/manage.go

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
}