AcediaFramework
/
AcediaCore
2
0
Fork 0
Code Issues 9 Pull Requests Releases Wiki Activity
Browse Source

Add new `UserAPI` methods

pull/8/head
Anton Tarasenko 2 years ago
parent
7419c6f907
commit
0cdc77fe09
2 changed files with 1697 additions and 58 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 734
      sources/Users/UserAPI.uc
  2. 1019
      sources/Users/Users_Feature.uc

734
sources/Users/UserAPI.uc
Unescape View File

@ -277,6 +277,29 @@ public final function array<Text> GetAvailableGroups()
return emptyResult;
}
/**
* Returns names of all available groups that users can belong to.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), the returned value is
* a locally cached one. This helps us avoid having to query database each time
* we want to check something about user groups, but it also means we might
* have an outdated information.
*
* @return Array with names of all available groups. All array elements are
* guaranteed to be unique and in lower case.
*/
public final /*unreal*/ function array<string> GetAvailableGroups_S()
{
local array<string> emptyResult;
if (usersFeature != none) {
return usersFeature.GetAvailableGroups_S();
}
return emptyResult;
}
/**
* Adds a new user group.
*
@ -303,6 +326,32 @@ public final function bool AddGroup(BaseText groupName)
return false;
}
/**
* Adds a new user group.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), the returned value is
* a locally cached one. This helps us avoid having to query database each time
* we want to check something about user groups, but it also means we might
* have an outdated information.
* Changes will always persist for the duration of the match, but writing
* them into the (non-config) source might fail, leading to changes being reset
* after the level switch. For non-database (config) sources changes will
* always be saved.
*
* @param groupName Name of the group to add. Case-insensitive.
* @return `true` if group was added and `false` otherwise (including if it
* already existed).
*/
public final /*unreal*/ function bool AddGroup_S(string groupName)
{
if (usersFeature != none) {
return usersFeature.AddGroup_S(groupName);
}
return false;
}
/**
* Removes existing user group.
*
@ -329,6 +378,32 @@ public final function bool RemoveGroup(BaseText groupName)
return false;
}
/**
* Removes existing user group.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), the returned value is
* a locally cached one. This helps us avoid having to query database each time
* we want to check something about user groups, but it also means we might
* have an outdated information.
* Changes will always persist for the duration of the match, but writing
* them into the (non-config) source might fail, leading to changes being reset
* after the level switch. For non-database (config) sources changes will
* always be saved.
*
* @param groupName Name of the group to remove. Case-insensitive.
* @return `true` if group was removed and `false` otherwise (including if it
* didn't exist in the first place).
*/
public final /*unreal*/ function bool RemoveGroup_S(string groupName)
{
if (usersFeature != none) {
return usersFeature.RemoveGroup_S(groupName);
}
return false;
}
/**
* Checks whether group with specified name exists.
*
@ -351,6 +426,28 @@ public final function bool IsGroupExisting(BaseText groupName)
return false;
}
/**
* Checks whether group with specified name exists.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), the returned value is
* a locally cached one. This helps us avoid having to query database each time
* we want to check something about user groups, but it also means we might
* have an outdated information.
*
* @param groupName Name of the group to check existence of.
* Case-insensitive.
* @return `true` if group exists and `false` otherwise.
*/
public final /*unreal*/ function bool IsGroupExisting_S(string groupName)
{
if (usersFeature != none) {
return usersFeature.IsGroupExisting_S(groupName);
}
return false;
}
/**
* Adds user with the given SteamID into the specified group.
*
@ -429,6 +526,32 @@ public final function bool AddUserIDToGroup(
return false;
}
/**
* Adds user (given by the `UserID`) into the specified group.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), changes are guaranteed to
* be made to the locally cached copy that will persist for the duration of
* the game. Method will also attempt to change the database value, but that is
* not guaranteed to succeed, meaning that changes might not be saved for
* later matches.
*
* @param id `UserID` of the user to add to the group.
* @param groupName Name of the group to add user to. Case-insensitive.
* @return `true` if user was added to the group (including if her was already
* added to it) and `false` in any other case.
*/
public final /*unreal*/ function bool AddUserIDToGroup_S(
UserID id,
string groupName)
{
if (usersFeature != none) {
return usersFeature.AddUserIDToGroup_S(id, groupName);
}
return false;
}
/**
* Adds given user into the specified group.
*
@ -453,6 +576,32 @@ public final function bool AddUserToGroup(User user, BaseText groupName)
return false;
}
/**
* Adds given user into the specified group.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), changes are guaranteed to
* be made to the locally cached copy that will persist for the duration of
* the game. Method will also attempt to change the database value, but that is
* not guaranteed to succeed, meaning that changes might not be saved for
* later matches.
*
* @param user User to add to the group.
* @param groupName Name of the group to add user to. Case-insensitive.
* @return `true` if user was added to the group (including if her was already
* added to it) and `false` in any other case.
*/
public final /*unreal*/ function bool AddUserToGroup_S(
User user,
string groupName)
{
if (usersFeature != none) {
return usersFeature.AddUserToGroup_S(user, groupName);
}
return false;
}
/**
* Removes user with the given SteamID from the specified group.
*
@ -531,6 +680,32 @@ public final function bool RemoveUserIDFromGroup(
return false;
}
/**
* Removes user (given by the `UserID`) from the specified group.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), changes are guaranteed to
* be made to the locally cached copy that will persist for the duration of
* the game. Method will also attempt to change the database value, but that is
* not guaranteed to succeed, meaning that changes might not be saved for
* later matches.
*
* @param id `UserID` of the user to remove to the group.
* @param groupName Name of the group to remove user to. Case-insensitive.
* @return `true` if user was removed to the group (including if her was
* already removed to it) and `false` in any other case.
*/
public final /*unreal*/ function bool RemoveUserIDFromGroup_S(
UserID id,
string groupName)
{
if (usersFeature != none) {
return usersFeature.RemoveUserIDFromGroup_S(id, groupName);
}
return false;
}
/**
* Removes user from the specified group.
*
@ -555,6 +730,32 @@ public final function bool RemoveUserFromGroup(User user, BaseText groupName)
return false;
}
/**
* Removes user from the specified group.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is configured to load user
* groups from a database (either local or remote), changes are guaranteed to
* be made to the locally cached copy that will persist for the duration of
* the game. Method will also attempt to change the database value, but that is
* not guaranteed to succeed, meaning that changes might not be saved for
* later matches.
*
* @param user User to remove to the group.
* @param groupName Name of the group to remove user to. Case-insensitive.
* @return `true` if user was removed to the group (including if her was
* already removed to it) and `false` in any other case.
*/
public final /*unreal*/ function bool RemoveUserFromGroup_S(
User user,
string groupName)
{
if (usersFeature != none) {
return usersFeature.RemoveUserFromGroup_S(user, groupName);
}
return false;
}
/**
* Returns names of all groups available for the user given by the SteamID.
*
@ -601,14 +802,13 @@ public final function array<Text> GetGroupsForSteamID(
* @param steamID SteamID of the user.
* Must be specified in a SteamID64 format, e.g. "76561197960287930".
* @return Array with names of the groups of the specified user.
* All array elements are guaranteed to be not-`none`, unique and in
* lower case.
* All array elements are guaranteed to be unique and in lower case.
* If data wasn't yet loaded - returns empty array.
*/
public final /*unreal*/ function array<Text> GetGroupsForSteamID_S(
public final /*unreal*/ function array<string> GetGroupsForSteamID_S(
string steamID)
{
local array<Text> emptyResult;
local array<string> emptyResult;
if (usersFeature != none) {
return usersFeature.GetGroupsForSteamID_S(steamID);
@ -645,6 +845,33 @@ public final function array<Text> GetGroupsForUserID(UserID id)
return emptyResult;
}
/**
* Returns names of all groups available for the user given by the `UserID`.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @see `GetGroupsForSteamID()` / `GetGroupsForUser()`.
*
* @param id ID of the user.
* @return Array with names of the groups of the specified user.
* All array elements are guaranteed to be unique and in lower case.
* If data wasn't yet loaded - returns empty array.
*/
public final /*unreal*/ function array<string> GetGroupsForUserID_S(UserID id)
{
local array<string> emptyResult;
if (usersFeature != none) {
return usersFeature.GetGroupsForUserID_S(id);
}
return emptyResult;
}
/**
* Returns names of all groups available for the user.
*
@ -674,6 +901,34 @@ public final function array<Text> GetGroupsForUser(User user)
return emptyResult;
}
/**
* Returns names of all groups available for the user.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @see `GetGroupsForSteamID()` / `GetGroupsForUserID()`.
*
* @param user Reference to `User` object that represent the user we are to
* find groups for.
* @return Array with names of the groups of the specified user.
* All array elements are guaranteed to be unique and in lower case.
* If data wasn't yet loaded - returns empty array.
*/
public final /*unreal*/ function array<string> GetGroupsForUser_S(User user)
{
local array<string> emptyResult;
if (usersFeature != none) {
return usersFeature.GetGroupsForUser_S(user);
}
return emptyResult;
}
/**
* Returns `UserID`s of all users that belong into the group named `groupName`.
*
@ -708,6 +963,7 @@ public final function array<UserID> GetGroupMembers(BaseText groupName)
* `groupName`. `UserID`s aren't necessarily human-readable (e.g. SteamID)
* and to help organize configs they can be annotated with a `Text` name.
* This method returns `UserID` alongside such annotation, if it exists.
* NOTE: Same user can have different annotations in different groups.
*
* @see For just `UserID`s use `GetGroupMembers()`.
*
@ -723,6 +979,7 @@ public final function array<UserID> GetGroupMembers(BaseText groupName)
* `groupName`. All array elements are guaranteed to be not-`none` and
* correspond to unique players.
* If data wasn't yet loaded - returns empty array.
* WARNING: References in fields of the returned `struct`s must be freed.
*/
public final function array<Users_Feature.AnnotatedUserID> GetAnnotatedGroupMembers(
BaseText groupName)
@ -735,6 +992,417 @@ public final function array<Users_Feature.AnnotatedUserID> GetAnnotatedGroupMemb
return emptyResult;
}
/**
* Returns annotation for user given by SteamID inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method returns these annotations, if they exists.
* NOTE: Same user can have different annotations in different groups.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, in whose annotation we are interested.
* @return Annotation for the specified user inside the specified group.
* `none` if either group doesn't exist, user doesn't belong to it or it is
* not annotated.
* If data wasn't yet loaded - returns `none`.
*/
public final function Text GetAnnotationForSteamID(
BaseText groupName,
BaseText steamID)
{
if (usersFeature != none) {
return usersFeature.GetAnnotationForSteamID(groupName, steamID);
}
return none;
}
/**
* Returns annotation for user given by SteamID inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method returns these annotations, if they exists.
* NOTE: Same user can have different annotations in different groups.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, in whose annotation we are interested.
* @return Annotation for the specified user inside the specified group.
* Empty `string` if either group doesn't exist, user doesn't belong to it
* or it is not annotated.
* If data wasn't yet loaded - returns empty `string`.
*/
public final /*unreal*/ function string GetAnnotationForSteamID_S(
string groupName,
string steamID)
{
if (usersFeature != none) {
return usersFeature.GetAnnotationForSteamID_S(groupName, steamID);
}
return "";
}
/**
* Returns annotation for user given by `UserID` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method returns these annotations, if they exists.
* NOTE: Same user can have different annotations in different groups.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, in whose annotation we are interested.
* @return Annotation for the specified user inside the specified group.
* `none` if either group doesn't exist, user doesn't belong to it or it is
* not annotated.
* If data wasn't yet loaded - returns `none`.
*/
public final function Text GetAnnotationForUserID(BaseText groupName, UserID id)
{
if (usersFeature != none) {
return usersFeature.GetAnnotationForUserID(groupName, id);
}
return none;
}
/**
* Returns annotation for user given by `UserID` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method returns these annotations, if they exists.
* NOTE: Same user can have different annotations in different groups.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, in whose annotation we are interested.
* @return Annotation for the specified user inside the specified group.
* Empty `string` if either group doesn't exist, user doesn't belong to it
* or it is not annotated.
* If data wasn't yet loaded - returns empty `string`.
*/
public final /*unreal*/ function string GetAnnotationForUserID_S(
string groupName,
UserID id)
{
if (usersFeature != none) {
return usersFeature.GetAnnotationForUserID_S(groupName, id);
}
return "";
}
/**
* Returns annotation for user given by `User` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method returns these annotations, if they exists.
* NOTE: Same user can have different annotations in different groups.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, in whose annotation we are interested.
* @return Annotation for the specified user inside the specified group.
* `none` if either group doesn't exist, user doesn't belong to it or it is
* not annotated.
* If data wasn't yet loaded - returns `none`.
*/
public final function Text GetAnnotationForUser(BaseText groupName, User user)
{
if (usersFeature != none) {
return usersFeature.GetAnnotationForUser(groupName, user);
}
return none;
}
/**
* Returns annotation for user given by `User` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method returns these annotations, if they exists.
* NOTE: Same user can have different annotations in different groups.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, in whose annotation we are interested.
* @return Annotation for the specified user inside the specified group.
* Empty `string` if either group doesn't exist, user doesn't belong to it
* or it is not annotated.
* If data wasn't yet loaded - returns empty `string`.
*/
public final /*unreal*/ function string GetAnnotationForUser_S(
string groupName,
User user)
{
if (usersFeature != none) {
return usersFeature.GetAnnotationForUser_S(groupName, user);
}
return "";
}
/**
* Changes annotation for user given by SteamID inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method allows to change these annotations.
* NOTE: Same user can have different annotations in different groups.
*
* In case this feature is configured to load user groups from a database
* (either local or remote), changes are guaranteed to be made to the locally
* cached copy that will persist for the duration of the game. Method will also
* attempt to change the database value, but that is not guaranteed to succeed,
* meaning that changes might not be saved for later matches.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, whose annotation we want to change.
* @param annotation New annotation for the specified user.
*/
public final function SetAnnotationForSteamID(
BaseText groupName,
BaseText steamID,
BaseText annotation)
{
if (usersFeature != none) {
usersFeature.SetAnnotationForSteamID(groupName, steamID, annotation);
}
}
/**
* Changes annotation for user given by SteamID inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method allows to change these annotations.
* NOTE: Same user can have different annotations in different groups.
*
* In case this feature is configured to load user groups from a database
* (either local or remote), changes are guaranteed to be made to the locally
* cached copy that will persist for the duration of the game. Method will also
* attempt to change the database value, but that is not guaranteed to succeed,
* meaning that changes might not be saved for later matches.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, whose annotation we want to change.
* @param annotation New annotation for the specified user. Empty annotation
* means simply removing any existing annotation.
*/
public final /*unreal*/ function SetAnnotationForSteamID_S(
string groupName,
string steamID,
string annotation)
{
if (usersFeature != none) {
usersFeature.SetAnnotationForSteamID_S(groupName, steamID, annotation);
}
}
/**
* Changes annotation for user given by `UserID` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method allows to change these annotations.
* NOTE: Same user can have different annotations in different groups.
*
* In case this feature is configured to load user groups from a database
* (either local or remote), changes are guaranteed to be made to the locally
* cached copy that will persist for the duration of the game. Method will also
* attempt to change the database value, but that is not guaranteed to succeed,
* meaning that changes might not be saved for later matches.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, whose annotation we want to change.
* @param annotation New annotation for the specified user.
*/
public final function SetAnnotationForUserID(
BaseText groupName,
UserID id,
BaseText annotation)
{
if (usersFeature != none) {
usersFeature.SetAnnotationForUserID(groupName, id, annotation);
}
}
/**
* Changes annotation for user given by `UserID` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method allows to change these annotations.
* NOTE: Same user can have different annotations in different groups.
*
* In case this feature is configured to load user groups from a database
* (either local or remote), changes are guaranteed to be made to the locally
* cached copy that will persist for the duration of the game. Method will also
* attempt to change the database value, but that is not guaranteed to succeed,
* meaning that changes might not be saved for later matches.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, whose annotation we want to change.
* @param annotation New annotation for the specified user. Empty annotation
* means simply removing any existing annotation.
*/
public final /*unreal*/ function SetAnnotationForUserID_S(
string groupName,
UserID id,
string annotation)
{
if (usersFeature != none) {
usersFeature.SetAnnotationForUserID_S(groupName, id, annotation);
}
}
/**
* Changes annotation for user given by `User` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method allows to change these annotations.
* NOTE: Same user can have different annotations in different groups.
*
* In case this feature is configured to load user groups from a database
* (either local or remote), changes are guaranteed to be made to the locally
* cached copy that will persist for the duration of the game. Method will also
* attempt to change the database value, but that is not guaranteed to succeed,
* meaning that changes might not be saved for later matches.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, whose annotation we want to change.
* @param annotation New annotation for the specified user.
*/
public final function SetAnnotationForUser(
BaseText groupName,
User user,
BaseText annotation)
{
if (usersFeature != none) {
usersFeature.SetAnnotationForUser(groupName, user, annotation);
}
}
/**
* Changes annotation for user given by `User` inside the group named
* `groupName`. `UserID`s that are used to store belonging users into groups
* aren't necessarily human-readable (e.g. SteamID) and to help organize
* configs they can be annotated with a `Text` name.
* This method allows to change these annotations.
* NOTE: Same user can have different annotations in different groups.
*
* In case this feature is configured to load user groups from a database
* (either local or remote), changes are guaranteed to be made to the locally
* cached copy that will persist for the duration of the game. Method will also
* attempt to change the database value, but that is not guaranteed to succeed,
* meaning that changes might not be saved for later matches.
*
* @param groupName Name of the group. Case-insensitive.
* @param steamID ID of the user, whose annotation we want to change.
* @param annotation New annotation for the specified user. Empty annotation
* means simply removing any existing annotation.
*/
public final /*unreal*/ function SetAnnotationForUser_S(
string groupName,
User user,
string annotation)
{
if (usersFeature != none) {
usersFeature.SetAnnotationForUser_S(groupName, user, annotation);
}
}
/**
* Checks whether user given by SteamID belongs to the group named `groupName`.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param steamID ID of the user to check.
* @param groupName Name of the group. Case-insensitive.
* @return `true` if user with an ID given by `id` belongs to the group named
* `groupName` and false if: it does not, either of the parameters is
* invalid or group data wasn't yet properly loaded.
*/
public final function bool IsSteamIDInGroup(
BaseText steamID,
BaseText groupName)
{
if (usersFeature != none) {
return usersFeature.IsSteamIDInGroup(steamID, groupName);
}
return false;
}
/**
* Checks whether user given by SteamID belongs to the group named `groupName`.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param steamID ID of the user to check.
* @param groupName Name of the group. Case-insensitive.
* @return `true` if user with an ID given by `id` belongs to the group named
* `groupName` and false if: it does not, either of the parameters is
* invalid or group data wasn't yet properly loaded.
*/
public final /*unreal*/ function bool IsSteamIDInGroup_S(
string id,
string groupName)
{
if (usersFeature != none) {
return usersFeature.IsSteamIDInGroup_S(id, groupName);
}
return false;
}
/**
* Checks whether user given by the `UserID` belongs to the group named
* `groupName`.
@ -752,7 +1420,7 @@ public final function array<Users_Feature.AnnotatedUserID> GetAnnotatedGroupMemb
* `groupName` and false if: it does not, either of the parameters is
* invalid or group data wasn't yet properly loaded.
*/
public final function bool IsUserIDInGroup(UserID id, Text groupName)
public final function bool IsUserIDInGroup(UserID id, BaseText groupName)
{
if (usersFeature != none) {
return usersFeature.IsUserIDInGroup(id, groupName);
@ -760,6 +1428,33 @@ public final function bool IsUserIDInGroup(UserID id, Text groupName)
return false;
}
/**
* Checks whether user given by the `UserID` belongs to the group named
* `groupName`.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param id ID of the user to check.
* @param groupName Name of the group. Case-insensitive.
* @return `true` if user with an ID given by `id` belongs to the group named
* `groupName` and false if: it does not, either of the parameters is
* invalid or group data wasn't yet properly loaded.
*/
public final /*unreal*/ function bool IsUserIDInGroup_S(
UserID id,
string groupName)
{
if (usersFeature != none) {
return usersFeature.IsUserIDInGroup_S(id, groupName);
}
return false;
}
/**
* Checks whether user belongs to the given group.
*
@ -777,7 +1472,7 @@ public final function bool IsUserIDInGroup(UserID id, Text groupName)
* `groupName` and false if: it does not, either of the parameters is
* invalid or group data wasn't yet properly loaded.
*/
public final function bool IsUserInGroup(User user, Text groupName)
public final function bool IsUserInGroup(User user, BaseText groupName)
{
if (usersFeature != none) {
return usersFeature.IsUserInGroup(user, groupName);
@ -785,6 +1480,33 @@ public final function bool IsUserInGroup(User user, Text groupName)
return false;
}
/**
* Checks whether user belongs to the given group.
*
* Will only work if `Users_Feature` is active.
* In case active config of `Users_Feature` is set up to load user groups
* from a database (either local or remote), the returned value is a locally
* cached one. This helps us avoid having to query database each time we want
* to check something about user groups, but it also means we might have
* an outdated information.
*
* @param user Reference to `User` object that represent the user we are to
* check for belonging to the group.
* @param groupName Name of the group. Case-insensitive.
* @return `true` if user with an ID given by `id` belongs to the group named
* `groupName` and false if: it does not, either of the parameters is
* invalid or group data wasn't yet properly loaded.
*/
public final /*unreal*/ function bool IsUserInGroup_S(
User user,
string groupName)
{
if (usersFeature != none) {
return usersFeature.IsUserInGroup_S(user, groupName);
}
return false;
}
/**
* Checks whether user groups' data was already loaded from the source
* (either config file or local/remote database).

1019
sources/Users/Users_Feature.uc
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save