Unverified Commit 5ae35060 authored by 4726's avatar 4726 Committed by GitHub
Browse files

Add 5 group management functions for runtime. (#498)

parent 73843d45

server/runtime_go_nakama.go

+111 −0
Original line number Diff line number Diff line
@@ -1984,6 +1984,67 @@ func (n *RuntimeGoNakamaModule) GroupDelete(ctx context.Context, id string) erro 
	return DeleteGroup(ctx, n.logger, n.db, groupID, uuid.Nil)

}



func (n *RuntimeGoNakamaModule) GroupUserJoin(ctx context.Context, groupID, userID, username string) error {

	group, err := uuid.FromString(groupID)

	if err != nil {

		return errors.New("expects group ID to be a valid identifier")

	}



	user, err := uuid.FromString(userID)

	if err != nil {

		return errors.New("expects user ID to be a valid identifier")

	}



	if username == "" {

		return errors.New("expects a username string")

	}



	return JoinGroup(ctx, n.logger, n.db, n.router, group, user, username)

}



func (n *RuntimeGoNakamaModule) GroupUserLeave(ctx context.Context, groupID, userID, username string) error {

	group, err := uuid.FromString(groupID)

	if err != nil {

		return errors.New("expects group ID to be a valid identifier")

	}



	user, err := uuid.FromString(userID)

	if err != nil {

		return errors.New("expects user ID to be a valid identifier")

	}



	if username == "" {

		return errors.New("expects a username string")

	}



	return LeaveGroup(ctx, n.logger, n.db, n.router, group, user, username)

}



func (n *RuntimeGoNakamaModule) GroupUsersAdd(ctx context.Context, groupID string, userIDs []string) error {

	group, err := uuid.FromString(groupID)

	if err != nil {

		return errors.New("expects group ID to be a valid identifier")

	}



	if len(userIDs) == 0 {

		return nil

	}



	users := make([]uuid.UUID, 0, len(userIDs))

	for _, userID := range userIDs {

		uid, err := uuid.FromString(userID)

		if err != nil {

			return errors.New("expects each user ID to be a valid identifier")

		}

		if uid == uuid.Nil {

			return errors.New("cannot add the root user")

		}

		users = append(users, uid)

	}



	return AddGroupUsers(ctx, n.logger, n.db, n.router, uuid.Nil, group, users)

}



func (n *RuntimeGoNakamaModule) GroupUsersKick(ctx context.Context, groupID string, userIDs []string) error {

	group, err := uuid.FromString(groupID)

	if err != nil {
@@ -2009,6 +2070,56 @@ func (n *RuntimeGoNakamaModule) GroupUsersKick(ctx context.Context, groupID stri 
	return KickGroupUsers(ctx, n.logger, n.db, n.router, uuid.Nil, group, users)

}



func (n *RuntimeGoNakamaModule) GroupUsersPromote(ctx context.Context, groupID string, userIDs []string) error {

	group, err := uuid.FromString(groupID)

	if err != nil {

		return errors.New("expects group ID to be a valid identifier")

	}



	if len(userIDs) == 0 {

		return nil

	}



	users := make([]uuid.UUID, 0, len(userIDs))

	for _, userID := range userIDs {

		uid, err := uuid.FromString(userID)

		if err != nil {

			return errors.New("expects each user ID to be a valid identifier")

		}

		if uid == uuid.Nil {

			return errors.New("cannot promote the root user")

		}

		users = append(users, uid)

	}



	return PromoteGroupUsers(ctx, n.logger, n.db, n.router, uuid.Nil, group, users)

}



func (n *RuntimeGoNakamaModule) GroupUsersDemote(ctx context.Context, groupID string, userIDs []string) error {

	group, err := uuid.FromString(groupID)

	if err != nil {

		return errors.New("expects group ID to be a valid identifier")

	}



	if len(userIDs) == 0 {

		return nil

	}



	users := make([]uuid.UUID, 0, len(userIDs))

	for _, userID := range userIDs {

		uid, err := uuid.FromString(userID)

		if err != nil {

			return errors.New("expects each user ID to be a valid identifier")

		}

		if uid == uuid.Nil {

			return errors.New("cannot demote the root user")

		}

		users = append(users, uid)

	}



	return DemoteGroupUsers(ctx, n.logger, n.db, n.router, uuid.Nil, group, users)

}



func (n *RuntimeGoNakamaModule) GroupUsersList(ctx context.Context, id string, limit int, state *int, cursor string) ([]*api.GroupUserList_GroupUser, string, error) {

	groupID, err := uuid.FromString(id)

	if err != nil {

server/runtime_lua_nakama.go

+202 −1
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ import ( 
	"github.com/heroiclabs/nakama-common/api"

	"github.com/heroiclabs/nakama-common/rtapi"

	"github.com/heroiclabs/nakama/v2/internal/cronexpr"

	"github.com/heroiclabs/nakama/v2/internal/gopher-lua"

	lua "github.com/heroiclabs/nakama/v2/internal/gopher-lua"

	"github.com/heroiclabs/nakama/v2/social"

	"go.uber.org/zap"

	"golang.org/x/crypto/bcrypt"
@@ -238,11 +238,17 @@ func (n *RuntimeLuaNakamaModule) Loader(l *lua.LState) int { 
		"group_create":                       n.groupCreate,

		"group_update":                       n.groupUpdate,

		"group_delete":                       n.groupDelete,

		"group_user_join":                    n.groupUserJoin,

		"group_user_leave":                   n.groupUserLeave,

		"group_users_add":                    n.groupUsersAdd,

		"group_users_promote":                n.groupUsersPromote,

		"group_users_demote":                 n.groupUsersDemote,

		"group_users_list":                   n.groupUsersList,

		"group_users_kick":                   n.groupUsersKick,

		"user_groups_list":                   n.userGroupsList,

		"friends_list":                       n.friendsList,

	}



	mod := l.SetFuncs(l.CreateTable(0, len(functions)), functions)



	l.Push(mod)
@@ -6347,6 +6353,201 @@ func (n *RuntimeLuaNakamaModule) groupDelete(l *lua.LState) int { 
	return 0

}



func (n *RuntimeLuaNakamaModule) groupUserJoin(l *lua.LState) int {

	groupID, err := uuid.FromString(l.CheckString(1))

	if err != nil {

		l.ArgError(1, "expects group ID to be a valid identifier")

		return 0

	}



	userID, err := uuid.FromString(l.CheckString(2))

	if err != nil {

		l.ArgError(2, "expects user ID to be a valid identifier")

		return 0

	}



	username := l.CheckString(3)

	if username == "" {

		l.ArgError(3, "expects username string")

		return 0

	}



	if err := JoinGroup(l.Context(), n.logger, n.db, n.router, groupID, userID, username); err != nil {

		l.RaiseError("error while trying to join a group: %v", err.Error())

		return 0

	}

	return 0

}



func (n *RuntimeLuaNakamaModule) groupUserLeave(l *lua.LState) int {

	groupID, err := uuid.FromString(l.CheckString(1))

	if err != nil {

		l.ArgError(1, "expects group ID to be a valid identifier")

		return 0

	}



	userID, err := uuid.FromString(l.CheckString(2))

	if err != nil {

		l.ArgError(2, "expects user ID to be a valid identifier")

		return 0

	}



	username := l.CheckString(3)

	if username == "" {

		l.ArgError(3, "expects username string")

		return 0

	}



	if err := LeaveGroup(l.Context(), n.logger, n.db, n.router, groupID, userID, username); err != nil {

		l.RaiseError("error while trying to leave a group: %v", err.Error())

	}

	return 0

}



func (n *RuntimeLuaNakamaModule) groupUsersAdd(l *lua.LState) int {

	groupID, err := uuid.FromString(l.CheckString(1))

	if err != nil {

		l.ArgError(1, "expects group ID to be a valid identifier")

		return 0

	}



	users := l.CheckTable(2)

	if users == nil {

		l.ArgError(2, "expects user IDs to be a table")

		return 0

	}



	userIDs := make([]uuid.UUID, 0, users.Len())

	conversionError := false

	users.ForEach(func(k lua.LValue, v lua.LValue) {

		if v.Type() != lua.LTString {

			l.ArgError(2, "expects each user ID to be a string")

			conversionError = true

			return

		}

		userID, err := uuid.FromString(v.String())

		if err != nil {

			l.ArgError(2, "expects each user ID to be a valid identifier")

			conversionError = true

			return

		}

		if userID == uuid.Nil {

			l.ArgError(2, "cannot add the root user")

			conversionError = true

			return

		}

		userIDs = append(userIDs, userID)

	})

	if conversionError {

		return 0

	}



	if len(userIDs) == 0 {

		return 0

	}



	if err := AddGroupUsers(l.Context(), n.logger, n.db, n.router, uuid.Nil, groupID, userIDs); err != nil {

		l.RaiseError("error while trying to add users into a group: %v", err.Error())

	}

	return 0

}



func (n *RuntimeLuaNakamaModule) groupUsersPromote(l *lua.LState) int {

	groupID, err := uuid.FromString(l.CheckString(1))

	if err != nil {

		l.ArgError(1, "expects group ID to be a valid identifier")

		return 0

	}



	users := l.CheckTable(2)

	if users == nil {

		l.ArgError(2, "expects user IDs to be a table")

		return 0

	}



	userIDs := make([]uuid.UUID, 0, users.Len())

	conversionError := false

	users.ForEach(func(k lua.LValue, v lua.LValue) {

		if v.Type() != lua.LTString {

			l.ArgError(2, "expects each user ID to be a string")

			conversionError = true

			return

		}

		userID, err := uuid.FromString(v.String())

		if err != nil {

			l.ArgError(2, "expects each user ID to be a valid identifier")

			conversionError = true

			return

		}

		if userID == uuid.Nil {

			l.ArgError(2, "cannot promote the root user")

			conversionError = true

			return

		}

		userIDs = append(userIDs, userID)

	})

	if conversionError {

		return 0

	}



	if len(userIDs) == 0 {

		return 0

	}



	if err := PromoteGroupUsers(l.Context(), n.logger, n.db, n.router, uuid.Nil, groupID, userIDs); err != nil {

		l.RaiseError("error while trying to promote users in a group: %v", err.Error())

	}

	return 0

}



func (n *RuntimeLuaNakamaModule) groupUsersDemote(l *lua.LState) int {

	groupID, err := uuid.FromString(l.CheckString(1))

	if err != nil {

		l.ArgError(1, "expects group ID to be a valid identifier")

		return 0

	}



	users := l.CheckTable(2)

	if users == nil {

		l.ArgError(2, "expects user IDs to be a table")

		return 0

	}



	userIDs := make([]uuid.UUID, 0, users.Len())

	conversionError := false

	users.ForEach(func(k lua.LValue, v lua.LValue) {

		if v.Type() != lua.LTString {

			l.ArgError(2, "expects each user ID to be a string")

			conversionError = true

			return

		}

		userID, err := uuid.FromString(v.String())

		if err != nil {

			l.ArgError(2, "expects each user ID to be a valid identifier")

			conversionError = true

			return

		}

		if userID == uuid.Nil {

			l.ArgError(2, "cannot demote the root user")

			conversionError = true

			return

		}

		userIDs = append(userIDs, userID)

	})

	if conversionError {

		return 0

	}



	if len(userIDs) == 0 {

		return 0

	}



	if err := DemoteGroupUsers(l.Context(), n.logger, n.db, n.router, uuid.Nil, groupID, userIDs); err != nil {

		l.RaiseError("error while trying to demote users in a group: %v", err.Error())

	}

	return 0

}



func (n *RuntimeLuaNakamaModule) groupUsersKick(l *lua.LState) int {

	groupID, err := uuid.FromString(l.CheckString(1))

	if err != nil {

vendor/github.com/heroiclabs/nakama-common/runtime/runtime.go

+6 −0
Original line number Diff line number Diff line
@@ -88,6 +88,7 @@ package runtime 
import (

	"context"

	"database/sql"



	"github.com/heroiclabs/nakama-common/api"

	"github.com/heroiclabs/nakama-common/rtapi"

)
@@ -887,7 +888,12 @@ type NakamaModule interface { 
	GroupCreate(ctx context.Context, userID, name, creatorID, langTag, description, avatarUrl string, open bool, metadata map[string]interface{}, maxCount int) (*api.Group, error)

	GroupUpdate(ctx context.Context, id, name, creatorID, langTag, description, avatarUrl string, open bool, metadata map[string]interface{}, maxCount int) error

	GroupDelete(ctx context.Context, id string) error

	GroupUserJoin(ctx context.Context, groupID, userID, username string) error

	GroupUserLeave(ctx context.Context, groupID, userID, username string) error

	GroupUsersAdd(ctx context.Context, groupID string, userIDs []string) error

	GroupUsersKick(ctx context.Context, groupID string, userIDs []string) error

	GroupUsersPromote(ctx context.Context, groupID string, userIDs []string) error

	GroupUsersDemote(ctx context.Context, groupID string, userIDs []string) error

	GroupUsersList(ctx context.Context, id string, limit int, state *int, cursor string) ([]*api.GroupUserList_GroupUser, string, error)

	UserGroupsList(ctx context.Context, userID string, limit int, state *int, cursor string) ([]*api.UserGroupList_UserGroup, string, error)