public async Task <ModifyEntityResult> MakeCharacterCurrentOnServerAsync ( [NotNull] ICommandContext context, [NotNull] IGuild discordServer, [NotNull] Character character ) { var getInvokerResult = await _users.GetOrRegisterUserAsync(context.User); if (!getInvokerResult.IsSuccess) { return(ModifyEntityResult.FromError(getInvokerResult)); } var user = getInvokerResult.Entity; if (character.IsCurrent) { return(ModifyEntityResult.FromError("The character is already current on the server.")); } await ClearCurrentCharacterOnServerAsync(user, discordServer); character.IsCurrent = true; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> SetDefaultCharacterForUserAsync ( [NotNull] ICommandContext context, [NotNull] Character newDefaultCharacter, [NotNull] User targetUser ) { var getDefaultCharacterResult = await GetDefaultCharacterAsync(targetUser, context.Guild); if (getDefaultCharacterResult.IsSuccess) { var currentDefault = getDefaultCharacterResult.Entity; if (currentDefault == newDefaultCharacter) { var isCurrentUser = context.Message.Author.Id == (ulong)newDefaultCharacter.Owner.DiscordID; var errorMessage = isCurrentUser ? "That's already your default character." : "That's already the user's default character."; return(ModifyEntityResult.FromError(errorMessage)); } currentDefault.IsDefault = false; } newDefaultCharacter.IsDefault = true; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Sets the contents of the given note. /// </summary> /// <param name="note">The note.</param> /// <param name="content">The content.</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> SetNoteContentsAsync ( UserNote note, string content, CancellationToken ct = default ) { 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(ct); return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> GrantPermissionAsync ( [NotNull] IRole discordRole, [NotNull] IPermission grantedPermission, PermissionTarget target ) { // Special All target handling if (target == PermissionTarget.All) { var grantSelfResult = await GrantPermissionAsync ( discordRole, grantedPermission, PermissionTarget.Self ); var grantOtherResult = await GrantPermissionAsync ( discordRole, grantedPermission, PermissionTarget.Other ); if (grantSelfResult.IsSuccess || grantOtherResult.IsSuccess) { return(ModifyEntityResult.FromSuccess()); } // Both are false, so we'll just inherit the self result. return(ModifyEntityResult.FromError(grantSelfResult)); } var getPermissionResult = await GetOrCreateRolePermissionAsync ( discordRole, grantedPermission, target ); if (!getPermissionResult.IsSuccess) { return(ModifyEntityResult.FromError(getPermissionResult)); } var permission = getPermissionResult.Entity; if (permission.IsGranted) { return(ModifyEntityResult.FromError("The user already has permission to do that.")); } permission.IsGranted = true; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> RevokePermissionAsync ( [NotNull] IRole discordRole, [NotNull] IPermission revokedPermission, PermissionTarget target ) { // Special All target handling if (target == PermissionTarget.All) { var revokeSelfResult = await RevokePermissionAsync ( discordRole, revokedPermission, PermissionTarget.Self ); var revokeOtherResult = await RevokePermissionAsync ( discordRole, revokedPermission, PermissionTarget.Other ); if (revokeSelfResult.IsSuccess || revokeOtherResult.IsSuccess) { return(ModifyEntityResult.FromSuccess()); } // Both are false, so we'll just inherit the self result. return(ModifyEntityResult.FromError(revokeSelfResult)); } var getPermissionResult = await GetOrCreateRolePermissionAsync ( discordRole, revokedPermission, target ); if (!getPermissionResult.IsSuccess) { return(ModifyEntityResult.FromError(getPermissionResult)); } var permission = getPermissionResult.Entity; if (!permission.IsGranted) { return(ModifyEntityResult.FromError("The role is already prohibited from doing that.")); } permission.IsGranted = false; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Sets the PDF data of a given dossier. This overwrites existing data. /// </summary> /// <param name="dossier">The dosser for which to set the data.</param> /// <param name="message">The message containing the PDF data.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>An entity modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> SetDossierDataAsync ( Dossier dossier, IUserMessage message, CancellationToken ct = default ) { if (message.Attachments.Count <= 0) { return(ModifyEntityResult.FromError("No file provided. Please attach a PDF with the dossier data.")); } var dossierAttachment = message.Attachments.First(); if (!dossierAttachment.Filename.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase)) { return(ModifyEntityResult.FromError("Invalid dossier format. PDF files are accepted.")); } using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(2) }; try { var dossierPath = GetDossierDataPath(dossier); await using var dataStream = await client.GetStreamAsync(dossierAttachment.Url); try { await using var dataFile = _content.FileSystem.CreateFile(dossierPath); await dataStream.CopyToAsync(dataFile, ct); if (!await dataFile.HasSignatureAsync(FileSignatures.PDF)) { return(ModifyEntityResult.FromError ( "Invalid dossier format. PDF files are accepted." )); } } catch (Exception e) { return(ModifyEntityResult.FromError(e)); } } catch (TaskCanceledException) { return(ModifyEntityResult.FromError ( "The download operation timed out. The data file was not added." )); } return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Blacklists the given user, preventing them from transforming the <paramref name="discordUser"/>. /// </summary> /// <param name="discordUser">The user to modify.</param> /// <param name="blacklistedUser">The user to add to the blacklist.</param> /// <returns>An entity modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> BlacklistUserAsync ( IUser discordUser, IUser blacklistedUser ) { if (discordUser == blacklistedUser) { return(ModifyEntityResult.FromError("You can't blacklist yourself.")); } var getGlobalProtectionResult = await GetOrCreateGlobalUserProtectionAsync(discordUser); if (!getGlobalProtectionResult.IsSuccess) { return(ModifyEntityResult.FromError(getGlobalProtectionResult)); } var protection = getGlobalProtectionResult.Entity; if (protection.Blacklist.Any(u => u.DiscordID == (long)blacklistedUser.Id)) { return(ModifyEntityResult.FromError("You've already blacklisted that user.")); } var protectionEntry = protection.UserListing.FirstOrDefault(u => u.User.DiscordID == (long)discordUser.Id); if (protectionEntry is null) { var getUserResult = await _users.GetOrRegisterUserAsync(blacklistedUser); if (!getUserResult.IsSuccess) { return(ModifyEntityResult.FromError(getUserResult)); } var user = getUserResult.Entity; protectionEntry = new UserProtectionEntry(protection, user) { Type = ListingType.Blacklist }; // Ensure we don't try to add the user we got from another context _database.Update(protectionEntry); protection.UserListing.Add(protectionEntry); } else { protectionEntry.Type = ListingType.Blacklist; } await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
private async Task <ModifyEntityResult> ConfigureDefaultUserRolePermissions ( IGuild guild, IGuildChannel dedicatedChannel ) { var getServer = await _servers.GetOrRegisterServerAsync(guild); if (!getServer.IsSuccess) { return(ModifyEntityResult.FromError(getServer)); } var server = getServer.Entity; var getSettings = await _serverSettings.GetOrCreateServerRoleplaySettingsAsync(server); if (!getSettings.IsSuccess) { return(ModifyEntityResult.FromError(getSettings)); } var settings = getSettings.Entity; var denyView = OverwritePermissions.InheritAll.Modify ( viewChannel: PermValue.Deny, sendMessages: PermValue.Deny, addReactions: PermValue.Deny ); // Configure visibility for everyone // viewChannel starts off as deny, since starting or stopping the RP will set the correct permissions. IRole defaultUserRole; if (settings.DefaultUserRole.HasValue) { var defaultRole = guild.GetRole((ulong)settings.DefaultUserRole.Value); defaultUserRole = defaultRole ?? guild.EveryoneRole; } else { defaultUserRole = guild.EveryoneRole; } await dedicatedChannel.AddPermissionOverwriteAsync(defaultUserRole, denyView); if (defaultUserRole != guild.EveryoneRole) { // Also override @everyone so it can't see anything await dedicatedChannel.AddPermissionOverwriteAsync(guild.EveryoneRole, denyView); } return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Sets whether or not a roleplay is public. /// </summary> /// <param name="roleplay">The roleplay to set the value in.</param> /// <param name="isPublic">The new value.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> SetRoleplayIsPublicAsync(Roleplay roleplay, bool isPublic) { if (roleplay.IsPublic == isPublic) { return(ModifyEntityResult.FromError($"The roleplay is already {(isPublic ? "public" : "private")}.")); } roleplay.IsPublic = isPublic; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Sets the summary of the given roleplay. /// </summary> /// <param name="roleplay">The roleplay to set the summary of.</param> /// <param name="newRoleplaySummary">The new summary.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> SetRoleplaySummaryAsync(Roleplay roleplay, string newRoleplaySummary) { if (string.IsNullOrWhiteSpace(newRoleplaySummary)) { return(ModifyEntityResult.FromError("You need to provide a new summary.")); } roleplay.Summary = newRoleplaySummary; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Sets the access conditions for the given character role. /// </summary> /// <param name="role">The character role.</param> /// <param name="access">The access conditions.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> SetCharacterRoleAccessAsync(CharacterRole role, RoleAccess access) { if (role.Access == access) { return(ModifyEntityResult.FromError("The role already has those access conditions.")); } role.Access = access; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Clears the first-join message, if one is set. /// </summary> /// <param name="server">The server.</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> ClearJoinMessageAsync(Server server, CancellationToken ct = default) { if (server.JoinMessage is null) { return(ModifyEntityResult.FromError("No join message has been set.")); } server.JoinMessage = null; await _database.SaveChangesAsync(ct); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Resets the channel permissions for the given roleplay to their default values. /// </summary> /// <param name="guild">The guild.</param> /// <param name="roleplay">The roleplay.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> ResetChannelPermissionsAsync(IGuild guild, Roleplay roleplay) { var getChannel = await GetDedicatedChannelAsync(guild, roleplay); if (!getChannel.IsSuccess) { return(ModifyEntityResult.FromError(getChannel)); } var channel = getChannel.Entity; return(await ResetChannelPermissionsAsync(channel, roleplay)); }
/// <summary> /// Disables the given autorole. /// </summary> /// <param name="autorole">The autorole.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> DisableAutoroleAsync(AutoroleConfiguration autorole) { if (!autorole.IsEnabled) { return(ModifyEntityResult.FromError("The autorole is already disabled.")); } autorole.IsEnabled = false; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Invites the given user to the given roleplay. /// </summary> /// <param name="roleplay">The roleplay to invite the user to.</param> /// <param name="discordUser">The user to invite.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> InviteUserToRoleplayAsync(Roleplay roleplay, IGuildUser discordUser) { var getUser = await _users.GetOrRegisterUserAsync(discordUser); if (!getUser.IsSuccess) { return(ModifyEntityResult.FromError(getUser)); } var user = getUser.Entity; return(await _roleplays.InviteUserToRoleplayAsync(roleplay, user)); }
/// <summary> /// Makes the given character the given user's current character. /// </summary> /// <param name="guildUser">The user.</param> /// <param name="character">The character.</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> MakeCharacterCurrentAsync ( IGuildUser guildUser, Character character, CancellationToken ct = default ) { var getUser = await _users.GetOrRegisterUserAsync(guildUser, ct); if (!getUser.IsSuccess) { return(ModifyEntityResult.FromError(getUser)); } var getServer = await _servers.GetOrRegisterServerAsync(guildUser.Guild, ct); if (!getServer.IsSuccess) { return(ModifyEntityResult.FromError(getServer)); } var user = getUser.Entity; var server = getServer.Entity; var getOriginalCharacter = await _characters.GetCurrentCharacterAsync(user, server, ct); var makeCurrent = await _characters.MakeCharacterCurrentAsync(user, server, character, ct); if (!makeCurrent.IsSuccess) { return(makeCurrent); } // Update the user's nickname var updateNickname = await UpdateUserNickname(guildUser, ct); if (!updateNickname.IsSuccess) { return(updateNickname); } var originalCharacter = getOriginalCharacter.IsSuccess ? getOriginalCharacter.Entity : null; var updateRoles = await _characterRoles.UpdateUserRolesAsync(guildUser, originalCharacter, ct); if (!updateRoles.IsSuccess) { return(updateRoles); } return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Stops the given roleplay. /// </summary> /// <param name="roleplay">The roleplay to stop.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public async Task <ModifyEntityResult> StopRoleplayAsync(Roleplay roleplay) { if (!roleplay.IsActive) { return(ModifyEntityResult.FromError("The roleplay is not active.")); } roleplay.IsActive = false; roleplay.ActiveChannelID = null; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> AddToOrUpdateMessageInRoleplayAsync ( [NotNull] Roleplay roleplay, [NotNull] IMessage message ) { if (!roleplay.HasJoined(message.Author)) { return(ModifyEntityResult.FromError("The given message was not authored by a participant of the roleplay.")); } var userNick = message.Author.Username; if (message.Author is SocketGuildUser guildUser && !string.IsNullOrEmpty(guildUser.Nickname)) { userNick = guildUser.Nickname; } if (roleplay.Messages.Any(m => m.DiscordMessageID == (long)message.Id)) { // Edit the existing message var existingMessage = roleplay.Messages.Find(m => m.DiscordMessageID == (long)message.Id); if (existingMessage.Contents.Equals(message.Content)) { return(ModifyEntityResult.FromError("Nothing to do; message content match.")); } existingMessage.Contents = message.Content; // Update roleplay timestamp roleplay.LastUpdated = DateTime.Now; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); } var roleplayMessage = UserMessage.FromDiscordMessage(message, userNick); roleplay.Messages.Add(roleplayMessage); // Update roleplay timestamp roleplay.LastUpdated = DateTime.Now; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> SetCharacterNameAsync ( [NotNull] ICommandContext context, [NotNull] Character character, [NotNull] string newCharacterName ) { if (string.IsNullOrWhiteSpace(newCharacterName)) { return(ModifyEntityResult.FromError("You need to provide a name.")); } if (string.Equals(character.Name, newCharacterName, StringComparison.OrdinalIgnoreCase)) { return(ModifyEntityResult.FromError("The character already has that name.")); } if (newCharacterName.Contains("\"")) { return(ModifyEntityResult.FromError("The name may not contain double quotes.")); } var isCurrentUser = context.Message.Author.Id == (ulong)character.Owner.DiscordID; if (!await IsCharacterNameUniqueForUserAsync(character.Owner, newCharacterName, context.Guild)) { var errorMessage = isCurrentUser ? "You already have a character with that name." : "The user already has a character with that name."; return(ModifyEntityResult.FromError(errorMessage)); } var commandModule = _commands.Modules.FirstOrDefault(m => m.Name == "character"); if (!(commandModule is null)) { var validNameResult = _ownedEntities.IsEntityNameValid(commandModule.GetAllCommandNames(), newCharacterName); if (!validNameResult.IsSuccess) { return(ModifyEntityResult.FromError(validNameResult)); } } character.Name = newCharacterName; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Starts the given roleplay. /// </summary> /// <param name="roleplay">The roleplay.</param> /// <param name="channelID">The Discord ID of the channel.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> StartRoleplayAsync(Roleplay roleplay, long channelID) { if (roleplay.IsActive && roleplay.ActiveChannelID == channelID) { return(ModifyEntityResult.FromError("The roleplay is already running.")); } roleplay.ActiveChannelID = channelID; roleplay.IsActive = true; roleplay.LastUpdated = DateTime.Now; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Sets the custom role of a character. /// </summary> /// <param name="guildUser">The owner of the character.</param> /// <param name="character">The character.</param> /// <param name="characterRole">The role to set.</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> SetCharacterRoleAsync ( IGuildUser guildUser, Character character, CharacterRole characterRole, CancellationToken ct = default ) { if (character.Role == characterRole) { return(ModifyEntityResult.FromError("The character already has that role.")); } if (character.IsCurrent) { if (!(character.Role is null)) { var oldRole = guildUser.Guild.GetRole((ulong)character.Role.DiscordID); if (!(oldRole is null)) { var removeRole = await _discord.RemoveUserRoleAsync(guildUser, oldRole); if (!removeRole.IsSuccess) { return(removeRole); } } } var newRole = guildUser.Guild.GetRole((ulong)characterRole.DiscordID); if (newRole is null) { return(ModifyEntityResult.FromError("Failed to get the new role.")); } var addRole = await _discord.AddUserRoleAsync(guildUser, newRole); if (!addRole.IsSuccess) { return(addRole); } } character.Role = characterRole; await _database.SaveChangesAsync(ct); return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> InviteUserAsync ( [NotNull] Roleplay roleplay, [NotNull] IUser invitedUser ) { if (roleplay.IsPublic && !roleplay.IsKicked(invitedUser)) { return(ModifyEntityResult.FromError("The roleplay is not set to private.")); } if (roleplay.InvitedUsers.Any(p => p.User.DiscordID == (long)invitedUser.Id)) { return(ModifyEntityResult.FromError("The user has already been invited to that roleplay.")); } // Remove the invited user from the kick list, if they're on it var participantEntry = roleplay.ParticipatingUsers.FirstOrDefault(p => p.User.DiscordID == (long)invitedUser.Id); if (participantEntry is null) { var getUserResult = await _users.GetOrRegisterUserAsync(invitedUser); if (!getUserResult.IsSuccess) { return(ModifyEntityResult.FromError(getUserResult)); } var user = getUserResult.Entity; // Ensure the user is attached, so we don't create any conflicts. _database.Attach(user); participantEntry = new RoleplayParticipant(roleplay, user) { Status = ParticipantStatus.Invited }; roleplay.ParticipatingUsers.Add(participantEntry); } else { participantEntry.Status = ParticipantStatus.Invited; } await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Sets the summary of the dossier. /// </summary> /// <param name="dossier">The dossier to modify.</param> /// /// <param name="newSummary">The new summary.</param> /// <returns>An entity modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> SetDossierSummaryAsync ( Dossier dossier, string newSummary ) { if (newSummary.IsNullOrWhitespace()) { return(ModifyEntityResult.FromError("You need to provide a summary.")); } dossier.Summary = newSummary; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> SetRoleplayIsNSFWAsync ( [NotNull] Roleplay roleplay, bool isNSFW ) { if (roleplay.Messages.Count > 0 && roleplay.IsNSFW && !isNSFW) { return(ModifyEntityResult.FromError("You can't mark a NSFW roleplay with messages in it as non-NSFW.")); } roleplay.IsNSFW = isNSFW; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Consumes a message, adding it to the active roleplay in its channel if the author is a participant. /// </summary> /// <param name="message">The received message.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public async Task <ModifyEntityResult> ConsumeMessageAsync(IUserMessage message) { if (!(message.Channel is ITextChannel textChannel)) { return(ModifyEntityResult.FromError("The message did not come from a text channel.")); } var result = await GetActiveRoleplayAsync(textChannel); if (!result.IsSuccess) { return(ModifyEntityResult.FromError(result)); } var roleplay = result.Entity; if (!roleplay.HasJoined(message.Author)) { return(ModifyEntityResult.FromError("The given message was not authored by a participant of the roleplay.")); } var userNick = message.Author.Username; if (message.Author is IGuildUser guildUser && !string.IsNullOrEmpty(guildUser.Nickname)) { userNick = guildUser.Nickname; } var getAuthor = await _users.GetOrRegisterUserAsync(message.Author); if (!getAuthor.IsSuccess) { return(ModifyEntityResult.FromError(getAuthor)); } var author = getAuthor.Entity; return(await _roleplays.AddOrUpdateMessageInRoleplayAsync ( roleplay, author, (long)message.Id, message.Timestamp, userNick, message.Content )); }
/// <summary> /// Updates the user's current nickname based on their character. /// </summary> /// <param name="guildUser">The user.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A modification result which may or may not have succeeded.</returns> private async Task <ModifyEntityResult> UpdateUserNickname ( IGuildUser guildUser, CancellationToken ct = default ) { var getUser = await _users.GetOrRegisterUserAsync(guildUser, ct); if (!getUser.IsSuccess) { return(ModifyEntityResult.FromError(getUser)); } var getServer = await _servers.GetOrRegisterServerAsync(guildUser.Guild, ct); if (!getServer.IsSuccess) { return(ModifyEntityResult.FromError(getServer)); } var user = getUser.Entity; var server = getServer.Entity; string newNick; var getNewCharacter = await _characters.GetCurrentCharacterAsync(user, server, ct); if (getNewCharacter.IsSuccess) { var newCharacter = getNewCharacter.Entity; newNick = newCharacter.Nickname.IsNullOrWhitespace() ? guildUser.Username : newCharacter.Nickname; } else { newNick = guildUser.Username; } var setNick = await _discord.SetUserNicknameAsync(guildUser, newNick); if (!setNick.IsSuccess) { return(setNick); } return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Transfers ownership of the given roleplay to the given user. /// </summary> /// <param name="newDiscordOwner">The new owner.</param> /// <param name="roleplay">The roleplay to transfer.</param> /// <returns>An execution result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> TransferRoleplayOwnershipAsync ( IGuildUser newDiscordOwner, Roleplay roleplay ) { var getNewOwner = await _users.GetOrRegisterUserAsync(newDiscordOwner); if (!getNewOwner.IsSuccess) { return(ModifyEntityResult.FromError(getNewOwner)); } var newOwner = getNewOwner.Entity; return(await _roleplays.TransferRoleplayOwnershipAsync(newOwner, roleplay)); }
/// <summary> /// Clears the default character from the given user. /// </summary> /// <param name="user">The user to clear the default character of.</param> /// <param name="server">The server the user is on.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> ClearDefaultCharacterAsync(User user, Server server) { user = _database.NormalizeReference(user); server = _database.NormalizeReference(server); var getDefaultCharacterResult = await GetDefaultCharacterAsync(user, server); if (!getDefaultCharacterResult.IsSuccess) { return(ModifyEntityResult.FromError("That user doesn't have a default character.")); } getDefaultCharacterResult.Entity.IsDefault = false; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Revokes consent to store user data for a given user. /// </summary> /// <param name="discordUser">The user that has revoked consent.</param> /// <returns>A task that must be awaited.</returns> public async Task <ModifyEntityResult> RevokeUserConsentAsync(IUser discordUser) { var userConsent = await _database.UserConsents.FirstOrDefaultAsync ( uc => uc.DiscordID == (long)discordUser.Id ); if (userConsent is null) { return(ModifyEntityResult.FromError("The user has not consented.")); } userConsent.HasConsented = false; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Logs the ambassador into Discord. /// </summary> /// <returns>A task representing the login action.</returns> public async Task <ModifyEntityResult> LoginAsync() { var contentService = _services.GetRequiredService <ContentService>(); var getTokenResult = await contentService.GetBotTokenAsync(); if (!getTokenResult.IsSuccess) { return(ModifyEntityResult.FromError(getTokenResult)); } var token = getTokenResult.Entity.Trim(); await _client.LoginAsync(TokenType.Bot, token); return(ModifyEntityResult.FromSuccess()); }