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"
	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
}