AcediaFramework
/
AcediaCore
2
0
Fork 0
Code Issues 9 Pull Requests Releases Wiki Activity
UnrealScript library and basis for all Acedia Framework mods
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.
443 Commits
3 Branches
0 Tags
9.2 MiB
 
Tree: 78aff18cad
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '78aff18cad'
${ noResults }
AcediaCore/sources/Users/ACommandUserGroups.uc

655 lines
20 KiB
Raw Blame History

/**
* Command for displaying help information about registered Acedia's commands.
* Copyright 2022-2023 Anton Tarasenko
*------------------------------------------------------------------------------
* This file is part of Acedia.
*
* Acedia is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3 of the License, or
* (at your option) any later version.
*
* Acedia is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Acedia. If not, see <https://www.gnu.org/licenses/>.
*/
class ACommandUserGroups extends Command
dependson(Users_Feature);
protected function BuildData(CommandDataBuilder builder)
{
builder.Name(P("usergroups"))
.Group(P("admin"))
.Summary(P("User groups management."))
.Describe(P("Allows to add/remove user groups and users to these:"
@ "groups. Changes made by it will always affect current session,"
@ "but might fail to be saved in case user groups are stored in"
@ "a database that is either corrupted or in read-only mode."));
builder.SubCommand(P("list"))
.Describe(P("Lists specified groups along with users that belong to"
@ "them. If no groups were specified at all - lists all available"
@ "groups."))
.OptionalParams()
.ParamTextList(P("groups"));
builder.SubCommand(P("add"))
.Describe(P("Adds a new group"))
.ParamText(P("group_name"));
builder.SubCommand(P("remove"))
.Describe(P("Removes a group"))
.ParamText(P("group_name"));
builder.SubCommand(P("addplayer"))
.Describe(F("Adds new user to the group, specified by the player"
@ "selector. Can add several players at once."
@ "Allows to also optionally specify annotation"
@ "(human-readable name) that can be thought of as"
@ "a {$TextEmphasis comment}. If annotation isn't specified"
@ "current nickname will be used as one."))
.ParamText(P("group_name"))
.ParamPlayers(P("player_selector"))
.OptionalParams()
.ParamText(P("annotation"));
builder.SubCommand(P("removeplayer"))
.Describe(P("Removes user from the group, specified by player selector."
@ "Can remove several players at once."))
.ParamText(P("group_name"))
.ParamPlayers(P("player_selector"));
builder.SubCommand(P("adduser"))
.Describe(F("Adds new user to the group. Allows to also optionally"
@ "specify annotation (human-readable name) that can be thought of"
@ "as a {$TextEmphasis comment}."))
.ParamText(P("group_name"))
.ParamText(P("user_id"))
.OptionalParams()
.ParamText(P("annotation"));
builder.SubCommand(P("removeuser"))
.Describe(P("Removes user from the group. User can be specified by both"
@ "user's id or annotation, with id taking priority."))
.ParamText(P("group_name"))
.ParamText(P("user_name"));
builder.Option(P("force"))
.Describe(P("Allows to force usage of invalid user IDs."));
}
protected function Executed(CallData arguments, EPlayer instigator)
{
local bool forceOption;
local Text groupName, userID, userName, annotation;
local ArrayList players, groups;
groupName = arguments.parameters.GetText(P("group_name"));
// For parameters named `user_id`, can only be ID
userID = arguments.parameters.GetText(P("user_id"));
// For parameters named `user_id`, can be either ID or annotation
userName = arguments.parameters.GetText(P("user_name"));
annotation = arguments.parameters.GetText(P("annotation"));
// An array of players that can be specified for some commands
players = arguments.parameters.GetArrayList(P("player_selector"));
groups = arguments.parameters.GetArrayList(P("groups"));
forceOption = arguments.options.HasKey(P("force"));
if (arguments.subCommandName.IsEmpty()) {
DisplayUserGroups();
}
else if (arguments.subCommandName.Compare(P("list"), SCASE_SENSITIVE)) {
DisplayUserGroupsWithUsers(groups);
}
else if (arguments.subCommandName.Compare(P("add"), SCASE_SENSITIVE)) {
AddGroup(groupName);
}
else if (arguments.subCommandName.Compare(P("remove"), SCASE_SENSITIVE)) {
RemoveGroup(groupName);
}
else if (arguments.subCommandName.Compare(P("adduser"), SCASE_SENSITIVE)) {
AddOrAnnotateUser(groupName, userID, annotation, forceOption);
}
else if (arguments.subCommandName.Compare(P("removeuser"), SCASE_SENSITIVE))
{
RemoveUser(groupName, userName);
}
else if (arguments.subCommandName.Compare(P("addplayer"), SCASE_SENSITIVE)) {
AddOrAnnotatePlayers(groupName, players, annotation);
}
else if (arguments.subCommandName
.Compare(P("removeplayer"), SCASE_SENSITIVE))
{
RemovePlayers(groupName, players);
}
_.memory.Free(groupName);
_.memory.Free(userID);
_.memory.Free(userName);
_.memory.Free(annotation);
_.memory.Free(players);
_.memory.Free(groups);
}
private function bool ValidateGroupExistence(BaseText groupName)
{
if (_.users.IsGroupExisting(groupName)) {
return true;
}
callerConsole
.Write(P("Group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.UseColorOnce(_.color.TextFailure)
.Write(P(" doesn't exists"))
.WriteLine(P("!"));
return false;
}
private function bool ValidateUserID(BaseText textUserID)
{
local int i;
if (textUserID == none) {
return false;
}
if (textUserID.IsEmpty())
{
callerConsole.WriteLine(F("Valid User ID"
@ "{$TextFailure shouldn't be empty},"
@ "use {$TextEmphasis --force} flag if you want to enforce"
@ "using it."));
return false;
}
for (i = 0; i < textUserID.GetLength(); i += 1)
{
if (!_.text.IsDigit(textUserID.GetCharacter(i)))
{
callerConsole.WriteLine(F("Valid User ID"
@ "{$TextFailure should consist only of digits},"
@ "use {$TextEmphasis --force} flag if you want"
@ "to enforce using it."));
return false;
}
}
return true;
}
private function bool TryAddingUserID(
BaseText groupName,
UserID userID,
BaseText userSpecifiedID)
{
if (_.users.IsUserIDInGroup(userID, groupName))
{
callerConsole
.Write(P("User id specified as "))
.UseColorOnce(_.color.Gray)
.Write(userSpecifiedID)
.UseColorOnce(_.color.TextFailure)
.Write(P(" is already in the group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P("!"));
}
else if (_.users.AddUserIDToGroup(userID, groupName))
{
callerConsole
.Write(F("{$TextPositive Added} user id specified as "))
.UseColorOnce(_.color.Gray)
.Write(userSpecifiedID)
.Write(P(" to the group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P("!"));
}
else
{
callerConsole
.UseColorOnce(_.color.TextFailure)
.Write(P("Failed (for unknown reason)"))
.Write(P(" to add user id "))
.UseColorOnce(_.color.Gray).Write(userSpecifiedID)
.Write(P(" to the group "))
.UseColorOnce(_.color.TextEmphasis).Write(groupName)
.WriteLine(P("!"));
return false;
}
return true;
}
private function DisplayAnnotation(
BaseText userSpecifiedName,
BaseText groupName,
BaseText annotation)
{
callerConsole
.Write(P("Annotation for user id specified as "))
.UseColorOnce(_.color.Gray)
.Write(userSpecifiedName)
.UseColorOnce(_.color.TextPositive)
.Write(P(" in the group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.Write(P(" is set to "))
.UseColorOnce(_.color.TextNeutral)
.WriteLine(annotation);
}
private function AddOrAnnotateUser(
BaseText groupName,
BaseText textUserID,
BaseText annotation,
bool forceOption)
{
local UserID id;
if (groupName == none) return;
if (textUserID == none) return;
if (!ValidateGroupExistence(groupName)) return;
if (!forceOption && !ValidateUserID(textUserID)) return;
id = UserID(_.memory.Allocate(class'UserID'));
id.Initialize(textUserID);
if (!TryAddingUserID(groupName, id, textUserID) || annotation == none)
{
_.memory.Free(id);
return;
}
_.users.SetAnnotationForUserID(groupName, id, annotation);
_.memory.Free(id);
DisplayAnnotation(textUserID, groupName, annotation);
}
private function AddOrAnnotatePlayers(
BaseText groupName,
ArrayList players,
BaseText annotation)
{
local int i;
local BaseText playerName, nextAnnotation;
local EPlayer nextPlayer;
local UserID nextID;
if (groupName == none) return;
if (players == none) return;
if (!ValidateGroupExistence(groupName)) return;
for (i = 0; i < players.GetLength(); i += 1)
{
nextPlayer = EPlayer(players.GetItem(i));
if (nextPlayer == none) {
continue;
}
playerName = nextPlayer.GetName();
nextID = nextPlayer.GetUserID();
if (TryAddingUserID(groupName, nextID, playerName))
{
if (annotation == none) {
nextAnnotation = playerName;
}
else {
nextAnnotation = annotation;
}
_.users.SetAnnotationForUserID(groupName, nextID, nextAnnotation);
DisplayAnnotation(playerName, groupName, nextAnnotation);
_.memory.Free(nextID);
nextAnnotation = none;
}
_.memory.Free(nextPlayer);
_.memory.Free(playerName);
_.memory.Free(nextID);
nextPlayer = none;
playerName = none;
nextID = none;
}
}
private function TryRemovingUserID(
BaseText groupName,
UserID idToRemove,
BaseText userSpecifiedName)
{
local Text idAsText;
idAsText = idToRemove.GetUniqueID();
if (_.users.RemoveUserIDFromGroup(idToRemove, groupName))
{
callerConsole
.Write(F("{$TextNegative Removed} user "))
.UseColorOnce(_.color.Gray)
.Write(userSpecifiedName)
.Write(P(" (with id "))
.UseColorOnce(_.color.Gray)
.Write(idAsText)
.Write(P(") from the group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P("!"));
}
else
{
callerConsole
.UseColorOnce(_.color.TextFailure)
.Write(P("Failed (for unknown reason)"))
.Write(P("to remove user with id "))
.UseColorOnce(_.color.Gray)
.Write(idAsText)
.Write(P(" from the group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P("."));
}
_.memory.Free(idAsText);
}
private function bool RemoveUsersByAnnotation(
BaseText groupName,
BaseText userName)
{
local int i;
local bool removedUser;
local array<Users_Feature.AnnotatedUserID> annotatedUsers;
annotatedUsers = _.users.GetAnnotatedGroupMembers(groupName);
for (i = 0; i < annotatedUsers.length; i += 1)
{
if (userName.Compare(annotatedUsers[i].annotation, SCASE_INSENSITIVE))
{
TryRemovingUserID(groupName, annotatedUsers[i].id, userName);
removedUser = true;
}
}
for (i = 0; i < annotatedUsers.length; i += 1)
{
_.memory.Free(annotatedUsers[i].id);
_.memory.Free(annotatedUsers[i].annotation);
}
return removedUser;
}
private function RemoveUser(BaseText groupName, BaseText userName)
{
local bool matchedUserName;
local UserID idFromName;
if (groupName == none) return;
if (userName == none) return;
if (!ValidateGroupExistence(groupName)) return;
idFromName = UserID(_.memory.Allocate(class'UserID'));
idFromName.Initialize(userName);
if ( idFromName.IsInitialized()
&& _.users.IsUserIDInGroup(idFromName, groupName))
{
TryRemovingUserID(groupName, idFromName, userName);
matchedUserName = true;
}
else {
matchedUserName = RemoveUsersByAnnotation(groupName, userName);
}
_.memory.Free(idFromName);
if (!matchedUserName)
{
callerConsole
.Write(P("User "))
.UseColorOnce(_.color.Gray)
.Write(userName)
.UseColorOnce(_.color.TextFailure)
.Write(P(" doesn't belong to the group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P("!"));
}
}
private function RemovePlayers(BaseText groupName, ArrayList players)
{
local int i;
local Text playerName;
local EPlayer nextPlayer;
local UserID nextID;
if (groupName == none) return;
if (players == none) return;
if (!ValidateGroupExistence(groupName)) return;
for (i = 0; i < players.GetLength(); i += 1)
{
nextPlayer = EPlayer(players.GetItem(i));
if (nextPlayer == none) {
continue;
}
playerName = nextPlayer.GetName();
nextID = nextPlayer.GetUserID();
if (!_.users.IsUserIDInGroup(nextID, groupName))
{
callerConsole
.Write(P("Player "))
.UseColorOnce(_.color.Gray)
.Write(playerName)
.Write(F(" {$TextFailure doesn't belong} to the group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P("!"));
}
else {
TryRemovingUserID(groupName, nextID, playerName);
}
_.memory.Free(nextPlayer);
_.memory.Free(playerName);
_.memory.Free(nextID);
nextPlayer = none;
playerName = none;
nextID = none;
}
}
private function AddGroup(BaseText groupName)
{
if (_.users.IsGroupExisting(groupName))
{
callerConsole
.Write(P("Group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.UseColorOnce(_.color.TextNegative)
.Write(P(" already exists"))
.WriteLine(P("!"));
return;
}
if (_.users.AddGroup(groupName))
{
callerConsole
.Write(P("Group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.UseColorOnce(_.color.TextPositive)
.Write(P(" was added"))
.WriteLine(P("!"));
}
else
{
callerConsole
.UseColorOnce(_.color.TextFailure)
.Write(P("Cannot add"))
.Write(P(" group with a name "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P(" for unknown reason."));
}
}
private function RemoveGroup(BaseText groupName)
{
if (!_.users.IsGroupExisting(groupName))
{
callerConsole
.Write(P("Group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.UseColorOnce(_.color.TextNegative)
.Write(P(" doesn't exists"))
.WriteLine(P("!"));
return;
}
if (_.users.RemoveGroup(groupName))
{
callerConsole
.Write(P("Group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.UseColorOnce(_.color.TextPositive)
.Write(P(" was removed"))
.WriteLine(P("!"));
}
else
{
callerConsole
.UseColorOnce(_.color.TextFailure)
.Write(P("Cannot remove"))
.Write(P(" group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(groupName)
.WriteLine(P(" for unknown reason."));
}
}
private function DisplayUserGroups()
{
local int i;
local array<Text> availableGroups;
if (!ValidateUsersFeature()) {
return;
}
availableGroups = _.users.GetAvailableGroups();
if (availableGroups.length <= 0)
{
callerConsole.WriteLine(F("{$TextNegative No user groups}"
@ "currently available."));
return;
}
callerConsole
.UseColorOnce(_.color.TextEmphasis)
.Write(P("Available user groups"))
.Write(P(": "));
for (i = 0; i < availableGroups.length; i += 1)
{
if (i > 0) {
callerConsole.Write(P(", "));
}
callerConsole.Write(availableGroups[i]);
}
callerConsole.Flush();
_.memory.FreeMany(availableGroups);
}
private function bool ValidateUsersFeature()
{
if (class'Users_Feature'.static.IsEnabled()) {
return true;
}
callerConsole
.UseColorOnce(_.color.TextFailure)
.WriteLine(P("`Users_Feature` is currently disabled."));
return false;
}
private function bool IsGroupSpecified(
ArrayList specifiedGroups,
BaseText groupToCheck)
{
local int i;
local int length;
local Text nextGroup;
if (groupToCheck == none) return false;
if (specifiedGroups == none) return true;
length = groupToCheck.GetLength();
if (length <= 0) return true;
for (i = 0; i < length; i += 1)
{
nextGroup = specifiedGroups.GetText(i);
if (groupToCheck.Compare(nextGroup, SCASE_INSENSITIVE))
{
nextGroup.FreeSelf();
return true;
}
_.memory.Free(nextGroup);
}
return false;
}
private function DisplayUserGroupsWithUsers(ArrayList specifiedGroups)
{
local int i;
local bool displayedGroup;
local array<Text> availableGroups;
if (!ValidateUsersFeature()) {
return;
}
availableGroups = _.users.GetAvailableGroups();
if (availableGroups.length <= 0)
{
callerConsole.WriteLine(F("{$TextNegative No user groups}"
@ "currently available."));
return;
}
for (i = 0; i < availableGroups.length; i += 1)
{
if (IsGroupSpecified(specifiedGroups, availableGroups[i]))
{
displayedGroup = true;
callerConsole
.Write(P("User group "))
.UseColorOnce(_.color.TextEmphasis)
.Write(availableGroups[i])
.WriteLine(P(":"));
DisplayUsersFor(availableGroups[i]);
}
}
callerConsole.Flush();
_.memory.FreeMany(availableGroups);
if (!displayedGroup && specifiedGroups != none) {
callerConsole.WriteLine(F("{$TextFailure No valid groups} specified!"));
}
}
private function DisplayUsersFor(Text groupName)
{
local int i;
local Text nextID;
local array<Users_Feature.AnnotatedUserID> annotatedUsers;
annotatedUsers = _.users.GetAnnotatedGroupMembers(groupName);
if (annotatedUsers.length <= 0)
{
callerConsole.WriteBlock(P("No users"));
return;
}
for (i = 0; i < annotatedUsers.length; i += 1)
{
if (annotatedUsers[i].id == none) {
continue;
}
nextID = annotatedUsers[i].id.GetUniqueID();
if (annotatedUsers[i].annotation != none)
{
callerConsole
.Write(nextID)
.UseColorOnce(_.color.TextNeutral)
.Write(P(" aka "))
.WriteBlock(annotatedUsers[i].annotation);
}
else {
callerConsole.WriteBlock(nextID);
}
_.memory.Free(nextID);
}
for (i = 0; i < annotatedUsers.length; i += 1)
{
_.memory.Free(annotatedUsers[i].id);
_.memory.Free(annotatedUsers[i].annotation);
}
}
defaultproperties
{
}