/// <summary>
/// Sets the current appearance of the given character as its default appearance.
/// </summary>
/// <param name="character">The character to set the default appearance of.</param>
/// <returns>An entity modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetCurrentAppearanceAsDefaultForCharacterAsync
(
Character character
)
{
// First, erase the existing default
var getExistingDefaultAppearance = await GetOrCreateDefaultAppearanceAsync(character);
if (getExistingDefaultAppearance.IsSuccess)
{
var existingDefault = getExistingDefaultAppearance.Entity;
_database.Appearances.Remove(existingDefault);
}
// Then, get the existing current appearance
var getCurrentAppearance = await GetOrCreateCurrentAppearanceAsync(character);
if (!getCurrentAppearance.IsSuccess)
{
return(ModifyEntityResult.FromError(getCurrentAppearance));
}
var existingCurrentAppearance = getCurrentAppearance.Entity;
// Flip the flags. Note that we don't create a new current appearance right away, because one will
// automatically be created if one is requested.
existingCurrentAppearance.IsDefault = true;
existingCurrentAppearance.IsCurrent = false;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the public status of the roleplay, updating channel permissions if necessary.
/// </summary>
/// <param name="roleplay">The roleplay.</param>
/// <param name="isPublic">Whether the roleplay is public.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetRoleplayIsPublicAsync(Roleplay roleplay, bool isPublic)
{
var setPublic = await _roleplays.SetRoleplayIsPublicAsync(roleplay, isPublic);
if (!setPublic.IsSuccess)
{
return(setPublic);
}
if (!roleplay.DedicatedChannelID.HasValue)
{
return(setPublic);
}
var guild = await _client.GetGuildAsync((ulong)roleplay.Server.DiscordID);
if (guild is null)
{
return(ModifyEntityResult.FromError("Failed to get a valid guild"));
}
var updatePermissions = await _dedicatedChannels.UpdateParticipantPermissionsAsync(guild, roleplay);
if (!updatePermissions.IsSuccess)
{
return(updatePermissions);
}
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the channel category to use for dedicated roleplay channels.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="category">The category to use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetDedicatedChannelCategoryAsync
(
Server server,
ICategoryChannel?category
)
{
var getSettingsResult = await GetOrCreateServerRoleplaySettingsAsync(server);
if (!getSettingsResult.IsSuccess)
{
return(ModifyEntityResult.FromError(getSettingsResult));
}
var settings = getSettingsResult.Entity;
long?categoryId;
if (category?.Id is null)
{
categoryId = null;
}
else
{
categoryId = (long)category.Id;
}
settings.DedicatedRoleplayChannelsCategory = categoryId;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the affirmation notification channel for the given guild.
/// </summary>
/// <param name="guild">The guild.</param>
/// <param name="textChannel">The channel.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetAffirmationNotificationChannelAsync
(
IGuild guild,
ITextChannel textChannel
)
{
var getSettings = await GetOrCreateServerSettingsAsync(guild);
if (!getSettings.IsSuccess)
{
return(ModifyEntityResult.FromError(getSettings));
}
var settings = getSettings.Entity;
if (settings.AffirmationRequiredNotificationChannelID == (decimal?)textChannel.Id)
{
return(ModifyEntityResult.FromError("That's already the affirmation notification channel."));
}
settings.AffirmationRequiredNotificationChannelID = (long)textChannel.Id;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Stops the given roleplay, disabling its dedicated channel if one exists.
/// </summary>
/// <param name="roleplay">The roleplay.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> StopRoleplayAsync(Roleplay roleplay)
{
var stop = await _roleplays.StopRoleplayAsync(roleplay);
if (!stop.IsSuccess)
{
return(stop);
}
// If the channel in question is the roleplay's dedicated channel, disable it
if (!roleplay.DedicatedChannelID.HasValue)
{
return(ModifyEntityResult.FromSuccess());
}
var guild = await _client.GetGuildAsync((ulong)roleplay.Server.DiscordID);
if (guild is null)
{
return(ModifyEntityResult.FromError("Failed to get a valid guild for the roleplay."));
}
var enableChannel = await _dedicatedChannels.UpdateParticipantPermissionsAsync(guild, roleplay);
if (!enableChannel.IsSuccess)
{
return(enableChannel);
}
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Clears the affirmation notification channel for the given guild.
/// </summary>
/// <param name="guild">The guild.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> ClearAffirmationNotificationChannelAsync
(
IGuild guild,
CancellationToken ct = default
)
{
var getSettings = await GetOrCreateServerSettingsAsync(guild, ct);
if (!getSettings.IsSuccess)
{
return(ModifyEntityResult.FromError(getSettings));
}
var settings = getSettings.Entity;
if (settings.AffirmationRequiredNotificationChannelID is null)
{
return(ModifyEntityResult.FromError("There's no affirmation notification channel set."));
}
settings.AffirmationRequiredNotificationChannelID = null;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the contents of the given note.
/// </summary>
/// <param name="note">The note.</param>
/// <param name="content">The content.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetNoteContentsAsync(UserNote note, string content)
{
if (content.IsNullOrWhitespace())
{
return(ModifyEntityResult.FromError("You must provide some content for the note."));
}
if (content.Length > 1024)
{
return(ModifyEntityResult.FromError
(
"The note is too long. It can be at most 1024 characters."
));
}
if (note.Content == content)
{
return(ModifyEntityResult.FromError("That's already the note's contents."));
}
note.Content = content;
note.NotifyUpdate();
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> ClearCurrentCharacterAsync
(
User user,
Server server,
CancellationToken ct = default
)
{
user = _database.NormalizeReference(user);
server = _database.NormalizeReference(server);
var getCurrentCharacter = await GetCurrentCharacterAsync(user, server, ct);
if (!getCurrentCharacter.IsSuccess)
{
return(ModifyEntityResult.FromError(getCurrentCharacter));
}
var currentCharacter = getCurrentCharacter.Entity;
currentCharacter.IsCurrent = false;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> SetDefaultCharacterAsync
(
User user,
Server server,
Character character,
CancellationToken ct = default
)
{
user = _database.NormalizeReference(user);
server = _database.NormalizeReference(server);
if (character.Owner != user)
{
return(ModifyEntityResult.FromError("The user doesn't own that character."));
}
var getDefaultCharacterResult = await GetDefaultCharacterAsync(user, server, ct);
if (getDefaultCharacterResult.IsSuccess)
{
var currentDefault = getDefaultCharacterResult.Entity;
if (currentDefault == character)
{
return(ModifyEntityResult.FromError("That's already the user's default character."));
}
currentDefault.IsDefault = false;
}
character.IsDefault = true;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the nickname of the given character.
/// </summary>
/// <param name="guildUser">The owner of the character.</param>
/// <param name="character">The character.</param>
/// <param name="nickname">The new nickname.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetCharacterNicknameAsync
(
IGuildUser guildUser,
Character character,
string nickname,
CancellationToken ct = default
)
{
var setNickname = await _characterEditor.SetCharacterNicknameAsync(character, nickname, ct);
if (!setNickname.IsSuccess)
{
return(setNickname);
}
var getCurrentCharacter = await GetCurrentCharacterAsync(guildUser, ct);
if (!getCurrentCharacter.IsSuccess)
{
return(ModifyEntityResult.FromSuccess());
}
var currentCharacter = getCurrentCharacter.Entity;
if (currentCharacter != character)
{
return(ModifyEntityResult.FromSuccess());
}
return(await UpdateUserNickname(guildUser, ct));
}
/// <summary>
/// Transfers ownership of the given character to the specified user.
/// </summary>
/// <param name="newOwner">The new owner.</param>
/// <param name="character">The character to transfer.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> TransferCharacterOwnershipAsync
(
IGuildUser newOwner,
Character character,
CancellationToken ct = default
)
{
var getUser = await _users.GetOrRegisterUserAsync(newOwner, ct);
if (!getUser.IsSuccess)
{
return(ModifyEntityResult.FromError(getUser));
}
var getServer = await _servers.GetOrRegisterServerAsync(newOwner.Guild, ct);
if (!getServer.IsSuccess)
{
return(ModifyEntityResult.FromError(getServer));
}
var user = getUser.Entity;
var server = getServer.Entity;
return(await _characters.TransferCharacterOwnershipAsync(user, server, character, ct));
}
/// <summary>
/// Sets the warning threshold for the given server.
/// </summary>
/// <param name="guild">The server.</param>
/// <param name="warningThreshold">The warning threshold.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetWarningThresholdAsync
(
IGuild guild,
int warningThreshold
)
{
var getSettings = await GetOrCreateServerSettingsAsync(guild);
if (!getSettings.IsSuccess)
{
return(ModifyEntityResult.FromError(getSettings));
}
var settings = getSettings.Entity;
if (settings.WarningThreshold == warningThreshold)
{
return(ModifyEntityResult.FromError($"The warning threshold is already {warningThreshold}."));
}
settings.WarningThreshold = warningThreshold;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the monitoring channel for the given server.
/// </summary>
/// <param name="guild">The server.</param>
/// <param name="channel">The channel.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetMonitoringChannelAsync
(
IGuild guild,
ITextChannel channel
)
{
var getSettings = await GetOrCreateServerSettingsAsync(guild);
if (!getSettings.IsSuccess)
{
return(ModifyEntityResult.FromError(getSettings));
}
var settings = getSettings.Entity;
if (settings.MonitoringChannel == (long)channel.Id)
{
return(ModifyEntityResult.FromError("That's already the monitoring channel."));
}
settings.MonitoringChannel = (long)channel.Id;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the protection type that the user has for transformations on the given server.
/// </summary>
/// <param name="discordUser">The user to set the protection for.</param>
/// <param name="discordServer">The server to set the protection on.</param>
/// <param name="protectionType">The protection type to set.</param>
/// <returns>An entity modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetServerProtectionTypeAsync
(
IUser discordUser,
IGuild discordServer,
ProtectionType protectionType
)
{
var getServerProtectionResult = await GetOrCreateServerUserProtectionAsync(discordUser, discordServer);
if (!getServerProtectionResult.IsSuccess)
{
return(ModifyEntityResult.FromError(getServerProtectionResult));
}
var protection = getServerProtectionResult.Entity;
if (protection.Type == protectionType)
{
return(ModifyEntityResult.FromError($"{protectionType.Humanize()} is already your current setting."));
}
protection.Type = protectionType;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Explicitly affirms an autorole assignment.
/// </summary>
/// <param name="autorole">The autorole.</param>
/// <param name="discordUser">The user.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> AffirmAutoroleAsync
(
AutoroleConfiguration autorole,
IUser discordUser,
CancellationToken ct = default
)
{
if (!autorole.RequiresConfirmation)
{
return(ModifyEntityResult.FromError("The autorole doesn't require explicit affirmation."));
}
var getCondition = await GetOrCreateAutoroleConfirmationAsync(autorole, discordUser, ct);
if (!getCondition.IsSuccess)
{
return(ModifyEntityResult.FromError(getCondition));
}
var condition = getCondition.Entity;
if (condition.IsConfirmed)
{
return(ModifyEntityResult.FromError("The autorole assignment has already been affirmed."));
}
condition.IsConfirmed = true;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> SetCharacterNameAsync
(
Character character,
string name,
CancellationToken ct = default
)
{
if (string.IsNullOrWhiteSpace(name))
{
return(ModifyEntityResult.FromError("You need to provide a name."));
}
if (string.Equals(character.Name, name, StringComparison.OrdinalIgnoreCase))
{
return(ModifyEntityResult.FromError("The character already has that name."));
}
if (name.Contains("\""))
{
return(ModifyEntityResult.FromError("The name may not contain double quotes."));
}
if (!await IsNameUniqueForUserAsync(character.Owner, character.Server, name, ct))
{
return(ModifyEntityResult.FromError("The user already has a character with that name."));
}
character.Name = name;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Explicitly affirms an autorole assignment for all currently qualifying users for the role.
/// </summary>
/// <param name="autorole">The autorole.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> AffirmAutoroleForAllAsync
(
AutoroleConfiguration autorole,
CancellationToken ct = default
)
{
if (!autorole.RequiresConfirmation)
{
return(ModifyEntityResult.FromError("The autorole doesn't require explicit affirmation."));
}
var qualifyingUsers = await _database.AutoroleConfirmations.ServersideQueryAsync
(
q => q
.Where(a => a.Autorole == autorole)
.Where(a => !a.IsConfirmed),
ct
);
foreach (var qualifyingUser in qualifyingUsers)
{
qualifyingUser.IsConfirmed = true;
}
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> SetCharacterAvatarAsync
(
Character character,
string avatarUrl,
CancellationToken ct = default
)
{
avatarUrl = avatarUrl.Unquote(new[] { '<', '>' });
if (string.IsNullOrWhiteSpace(avatarUrl))
{
return(ModifyEntityResult.FromError("You need to provide a new avatar url."));
}
if (!Uri.TryCreate(avatarUrl, UriKind.Absolute, out _))
{
return(ModifyEntityResult.FromError("The given image URL wasn't valid."));
}
if (character.AvatarUrl == avatarUrl)
{
return(ModifyEntityResult.FromError("The character's avatar is already set to that URL."));
}
character.AvatarUrl = avatarUrl;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the user's bio.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="bio">The bio.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task <ModifyEntityResult> SetUserBioAsync
(
User user,
string bio,
CancellationToken ct = default
)
{
if (bio.IsNullOrWhitespace())
{
return(ModifyEntityResult.FromError("You must provide a bio."));
}
if (bio.Length > 1024)
{
return(ModifyEntityResult.FromError("Your bio may not be longer than 1024 characters."));
}
if (user.Bio == bio)
{
return(ModifyEntityResult.FromError("That's already your bio."));
}
user.Bio = bio;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> SetCharacterNicknameAsync
(
Character character,
string nickname,
CancellationToken ct = default
)
{
if (string.IsNullOrWhiteSpace(nickname))
{
return(ModifyEntityResult.FromError("You need to provide a new nickname."));
}
if (character.Nickname == nickname)
{
return(ModifyEntityResult.FromError("The character already has that nickname."));
}
if (nickname.Length > 32)
{
return(ModifyEntityResult.FromError("The nickname is too long. It can be at most 32 characters."));
}
character.Nickname = nickname;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Explicitly denies an autorole assignment.
/// </summary>
/// <param name="autorole">The autorole.</param>
/// <param name="discordUser">The user.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> DenyAutoroleAsync
(
AutoroleConfiguration autorole,
IUser discordUser
)
{
if (!autorole.RequiresConfirmation)
{
return(ModifyEntityResult.FromError("The autorole doesn't require explicit affirmation."));
}
var getCondition = await GetOrCreateAutoroleConfirmationAsync(autorole, discordUser);
if (!getCondition.IsSuccess)
{
return(ModifyEntityResult.FromError(getCondition));
}
var condition = getCondition.Entity;
if (condition.IsConfirmed)
{
return(ModifyEntityResult.FromError
(
"The autorole assignment has already been denied, or has never been affirmed."
));
}
condition.IsConfirmed = false;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> SetCharacterSummaryAsync
(
Character character,
string summary,
CancellationToken ct = default
)
{
if (string.IsNullOrWhiteSpace(summary))
{
return(ModifyEntityResult.FromError("You need to provide a new summary."));
}
if (character.Summary == summary)
{
return(ModifyEntityResult.FromError("That's already the character's summary."));
}
if (summary.Length > 240)
{
return(ModifyEntityResult.FromError("The summary is too long. It can be at most 240 characters."));
}
character.Summary = summary;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Kicks the given user from the given roleplay, preventing them from joining again.
/// </summary>
/// <param name="roleplay">The roleplay.</param>
/// <param name="discordUser">The user.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> KickUserFromRoleplayAsync(Roleplay roleplay, IGuildUser discordUser)
{
var getUser = await _users.GetOrRegisterUserAsync(discordUser);
if (!getUser.IsSuccess)
{
return(ModifyEntityResult.FromError(getUser));
}
var user = getUser.Entity;
var removeUserAsync = await _roleplays.KickUserFromRoleplayAsync(roleplay, user);
if (!removeUserAsync.IsSuccess)
{
return(removeUserAsync);
}
if (!roleplay.DedicatedChannelID.HasValue)
{
return(removeUserAsync);
}
var revoke = await _dedicatedChannels.RevokeUserAccessAsync(roleplay, discordUser);
if (!revoke.IsSuccess)
{
return(ModifyEntityResult.FromError(revoke));
}
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> SetCharacterDescriptionAsync
(
Character character,
string description,
CancellationToken ct = default
)
{
if (string.IsNullOrWhiteSpace(description))
{
return(ModifyEntityResult.FromError("You need to provide a new description."));
}
if (character.Description == description)
{
return(ModifyEntityResult.FromError("The character already has that description."));
}
if (description.Length > 1000)
{
return(ModifyEntityResult.FromError("The description is too long. It can be at most 1000 characters."));
}
character.Description = description;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the name of the roleplay, updating the name of the dedicated channel (if one exists).
/// </summary>
/// <param name="roleplay">The roleplay.</param>
/// <param name="name">The new name.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetRoleplayNameAsync(Roleplay roleplay, string name)
{
var commandModule = _commands.Modules.First(m => m.Name == "roleplay");
var validNameResult = _ownedEntities.IsEntityNameValid(commandModule.GetAllCommandNames(), name);
if (!validNameResult.IsSuccess)
{
return(ModifyEntityResult.FromError(validNameResult));
}
var setName = await _roleplays.SetRoleplayNameAsync(roleplay, name);
if (!setName.IsSuccess)
{
return(setName);
}
if (!roleplay.DedicatedChannelID.HasValue)
{
return(ModifyEntityResult.FromSuccess());
}
var setChannelName = await _dedicatedChannels.UpdateChannelNameAsync(roleplay);
if (!setChannelName.IsSuccess)
{
return(setChannelName);
}
return(ModifyEntityResult.FromSuccess());
}
/// <inheritdoc />
public async Task <ModifyEntityResult> SetCharacterPronounsAsync
(
Character character,
string pronounFamily,
CancellationToken ct = default
)
{
if (pronounFamily.IsNullOrWhitespace())
{
return(ModifyEntityResult.FromError("You need to provide a pronoun family."));
}
if (character.PronounProviderFamily == pronounFamily)
{
return(ModifyEntityResult.FromError("The character is already using that pronoun set."));
}
var getPronounProviderResult = _pronouns.GetPronounProvider(pronounFamily);
if (!getPronounProviderResult.IsSuccess)
{
return(ModifyEntityResult.FromError(getPronounProviderResult));
}
var pronounProvider = getPronounProviderResult.Entity;
character.PronounProviderFamily = pronounProvider.Family;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
private async Task <ModifyEntityResult> OpenCategory(string categoryName)
{
var getCategoryResult = _categories.Select(c => c.ToString()).BestLevenshteinMatch(categoryName, 0.75);
if (!getCategoryResult.IsSuccess)
{
return(ModifyEntityResult.FromError(getCategoryResult));
}
if (!Enum.TryParse <KinkCategory>(getCategoryResult.Entity, true, out var category))
{
return(ModifyEntityResult.FromError("Could not parse kink category."));
}
var getKinkResult = await _kinks.GetFirstKinkWithoutPreferenceInCategoryAsync(_targetUser, category);
if (!getKinkResult.IsSuccess)
{
getKinkResult = await _kinks.GetFirstKinkInCategoryAsync(category);
}
if (!getKinkResult.IsSuccess)
{
return(ModifyEntityResult.FromError(getKinkResult));
}
var kink = getKinkResult.Entity;
_currentFListKinkID = (int)kink.FListID;
_state = KinkWizardState.KinkPreference;
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Removes a condition with the given ID from the given autorole.
/// </summary>
/// <param name="autorole">The autorole.</param>
/// <param name="conditionID">The ID of the condition.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A modification which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> RemoveConditionAsync
(
AutoroleConfiguration autorole,
long conditionID,
CancellationToken ct = default
)
{
var condition = autorole.Conditions.FirstOrDefault(c => c.ID == conditionID);
if (condition is null)
{
return(ModifyEntityResult.FromError("The autorole doesn't have any condition with that ID."));
}
if (autorole.Conditions.Count == 1 && autorole.IsEnabled)
{
return(ModifyEntityResult.FromError
(
"The autorole is still enabled, so it requires at least one condition to be present. " +
"Either disable the role, or add more conditions."
));
}
autorole.Conditions.Remove(condition);
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the channel to use for archived roleplays.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="channel">The channel to use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetArchiveChannelAsync
(
Server server,
ITextChannel?channel
)
{
var getSettingsResult = await GetOrCreateServerRoleplaySettingsAsync(server);
if (!getSettingsResult.IsSuccess)
{
return(ModifyEntityResult.FromError(getSettingsResult));
}
var settings = getSettingsResult.Entity;
long?channelId;
if (channel?.Id is null)
{
channelId = null;
}
else
{
channelId = (long)channel.Id;
}
settings.ArchiveChannel = channelId;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Resets the given character's appearance to its default state.
/// </summary>
/// <param name="character">The character to reset.</param>
/// <returns>An entity modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> ResetCharacterFormAsync(Character character)
{
var getDefaultAppearanceResult = await GetOrCreateDefaultAppearanceAsync(character);
if (!getDefaultAppearanceResult.IsSuccess)
{
return(ModifyEntityResult.FromError(getDefaultAppearanceResult));
}
var getCurrentAppearance = await GetCurrentAppearanceAsync(character);
if (getCurrentAppearance.IsSuccess)
{
// Delete the existing current appearance
_database.Appearances.Remove(getCurrentAppearance.Entity);
}
// Piggyback on the get/create method to clone the default appearance
var createNewCurrentResult = await GetOrCreateCurrentAppearanceAsync(character);
if (!createNewCurrentResult.IsSuccess)
{
return(ModifyEntityResult.FromError(createNewCurrentResult));
}
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
