public async Task <Result <FeedbackMessage> > HideRoleplayAsync ( [AutocompleteProvider("roleplay::any")] Roleplay roleplay ) { var getDedicatedChannelResult = DedicatedChannelService.GetDedicatedChannel ( roleplay ); if (!getDedicatedChannelResult.IsSuccess) { return(Result <FeedbackMessage> .FromError(getDedicatedChannelResult)); } var dedicatedChannel = getDedicatedChannelResult.Entity; var setVisibility = await _dedicatedChannels.SetChannelVisibilityForUserAsync ( dedicatedChannel, _context.User.ID, false ); return(!setVisibility.IsSuccess ? Result <FeedbackMessage> .FromError(setVisibility) : new FeedbackMessage("Roleplay hidden.", _feedback.Theme.Secondary)); }
/// <summary> /// Initializes a new instance of the <see cref="SetCommands"/> class. /// </summary> /// <param name="discordRoleplays">The roleplay service.</param> /// <param name="dedicatedChannels">The dedicated channel service.</param> public SetCommands ( RoleplayDiscordService discordRoleplays, DedicatedChannelService dedicatedChannels ) { _discordRoleplays = discordRoleplays; _dedicatedChannels = dedicatedChannels; }
/// <summary> /// Initializes a new instance of the <see cref="SetCommands"/> class. /// </summary> /// <param name="discordRoleplays">The roleplay service.</param> /// <param name="feedback">The user feedback service.</param> /// <param name="dedicatedChannels">The dedicated channel service.</param> public SetCommands ( RoleplayDiscordService discordRoleplays, UserFeedbackService feedback, DedicatedChannelService dedicatedChannels ) { _discordRoleplays = discordRoleplays; _feedback = feedback; _dedicatedChannels = dedicatedChannels; }
private async Task <OperationResult> ArchiveRoleplayAsync ( SocketGuild guild, ServerService serverService, RoleplayDiscordService roleplayService, DedicatedChannelService dedicatedChannels, RoleplayServerSettingsService serverSettings, Roleplay roleplay ) { if (roleplay.DedicatedChannelID is null) { return(OperationResult.FromError("The roleplay doesn't have a dedicated channel.")); } if (roleplay.IsPublic) { var postResult = await PostArchivedRoleplayAsync(guild, serverService, serverSettings, roleplay); if (!postResult.IsSuccess) { return(OperationResult.FromError(postResult)); } } var dedicatedChannel = guild.GetTextChannel((ulong)roleplay.DedicatedChannelID); if (dedicatedChannel is null) { // Something's gone wrong in the database. Who the f**k knows why. We'll do an extra delete to be // on the safe side. await dedicatedChannels.DeleteChannelAsync(guild, roleplay); return(OperationResult.FromSuccess()); } // Ensure the messages are all caught up foreach (var message in await dedicatedChannel.GetMessagesAsync().FlattenAsync()) { if (!(message is IUserMessage userMessage)) { continue; } // We don't care about the results here. await roleplayService.ConsumeMessageAsync(userMessage); } await dedicatedChannels.DeleteChannelAsync(guild, roleplay); return(OperationResult.FromSuccess()); }
/// <summary> /// Initializes a new instance of the <see cref="RoleplayCommands"/> class. /// </summary> /// <param name="discordRoleplays">The roleplay service.</param> /// <param name="feedback">The user feedback service.</param> /// <param name="interactivity">The interactivity service.</param> /// <param name="dedicatedChannels">The dedicated channel service.</param> public RoleplayCommands ( RoleplayDiscordService discordRoleplays, UserFeedbackService feedback, InteractivityService interactivity, DedicatedChannelService dedicatedChannels ) { _discordRoleplays = discordRoleplays; _feedback = feedback; _interactivity = interactivity; _dedicatedChannels = dedicatedChannels; }
/// <summary> /// Initializes a new instance of the <see cref="RoleplayCommands"/> class. /// </summary> /// <param name="discordRoleplays">The roleplay service.</param> /// <param name="feedback">The user feedback service.</param> /// <param name="dedicatedChannels">The dedicated channel service.</param> /// <param name="context">The command context.</param> /// <param name="channelAPI">The channel API.</param> /// <param name="services">The available services.</param> public RoleplayCommands ( RoleplayDiscordService discordRoleplays, FeedbackService feedback, DedicatedChannelService dedicatedChannels, ICommandContext context, IDiscordRestChannelAPI channelAPI, IServiceProvider services ) { _discordRoleplays = discordRoleplays; _feedback = feedback; _dedicatedChannels = dedicatedChannels; _context = context; _channelAPI = channelAPI; _services = services; }
/// <summary> /// Initializes a new instance of the <see cref="RoleplayDiscordService"/> class. /// </summary> /// <param name="roleplays">The roleplay service.</param> /// <param name="dedicatedChannels">The dedicated channel service.</param> /// <param name="users">The user service.</param> /// <param name="servers">The server service.</param> /// <param name="guildAPI">The guild API.</param> /// <param name="channelAPI">The channel API.</param> public RoleplayDiscordService ( RoleplayService roleplays, DedicatedChannelService dedicatedChannels, UserService users, ServerService servers, IDiscordRestGuildAPI guildAPI, IDiscordRestChannelAPI channelAPI ) { _roleplays = roleplays; _dedicatedChannels = dedicatedChannels; _users = users; _servers = servers; _guildAPI = guildAPI; _channelAPI = channelAPI; }
public async Task <Result <FeedbackMessage> > ViewRoleplayAsync ( [AutocompleteProvider("roleplay::any")] Roleplay roleplay ) { var getDedicatedChannelResult = DedicatedChannelService.GetDedicatedChannel(roleplay); if (!getDedicatedChannelResult.IsSuccess) { return(new UserError ( "The given roleplay doesn't have a dedicated channel. Try using \"!rp export\" instead." )); } if (!roleplay.IsPublic && roleplay.ParticipatingUsers.All(p => p.User.DiscordID != _context.User.ID)) { return(new UserError ( "You don't have permission to view that roleplay." )); } var dedicatedChannel = getDedicatedChannelResult.Entity; var setVisibility = await _dedicatedChannels.SetChannelVisibilityForUserAsync ( dedicatedChannel, _context.User.ID, true ); if (!setVisibility.IsSuccess) { return(Result <FeedbackMessage> .FromError(setVisibility)); } return(new FeedbackMessage ( $"The roleplay \"{roleplay.Name}\" is now visible in <#{dedicatedChannel}>.", _feedback.Theme.Secondary )); }
private static async Task <Result> ArchiveRoleplayAsync ( IServiceProvider services, FeedbackService feedback, RoleplayDiscordService roleplayService, DedicatedChannelService dedicatedChannels, RoleplayServerSettingsService serverSettings, Roleplay roleplay ) { if (roleplay.DedicatedChannelID is null) { return(new UserError("The roleplay doesn't have a dedicated channel.")); } var ensureLogged = await roleplayService.EnsureAllMessagesAreLoggedAsync(roleplay); if (!ensureLogged.IsSuccess) { return(Result.FromError(ensureLogged)); } if (!roleplay.IsPublic) { return(await dedicatedChannels.DeleteChannelAsync(roleplay)); } var postResult = await PostArchivedRoleplayAsync(services, feedback, serverSettings, roleplay); if (!postResult.IsSuccess) { return(postResult); } return(await dedicatedChannels.DeleteChannelAsync(roleplay)); }
public async Task <Result> MoveRoleplayIntoChannelAsync(string newName, params IUser[] participants) { var createRoleplayAsync = await _discordRoleplays.CreateRoleplayAsync ( _context.GuildID.Value, _context.User.ID, newName, "No summary set.", false, true ); if (!createRoleplayAsync.IsSuccess) { return(Result.FromError(createRoleplayAsync)); } var roleplay = createRoleplayAsync.Entity; foreach (var participant in participants) { if (participant.ID == _context.User.ID) { // Already added continue; } var addParticipantAsync = await _discordRoleplays.AddUserToRoleplayAsync(roleplay, participant.ID); if (addParticipantAsync.IsSuccess) { continue; } var message = $"I couldn't add <@{participant.ID}> to the roleplay ({addParticipantAsync.Error.Message}. " + "Please try to invite them manually."; var sendWarning = await _feedback.SendContextualWarningAsync ( message, _context.User.ID ); if (!sendWarning.IsSuccess) { return(Result.FromError(sendWarning)); } } // Copy the last messages from the participants var before = _context switch { MessageContext messageContext => messageContext.MessageID, InteractionContext interactionContext => interactionContext.ID, _ => throw new ArgumentOutOfRangeException(nameof(_context)) }; var getMessageBatch = await _channelAPI.GetChannelMessagesAsync(_context.ChannelID, before : before); if (!getMessageBatch.IsSuccess) { return(Result.FromError(getMessageBatch)); } var messageBatch = getMessageBatch.Entity; var participantMessages = participants .Select(participant => messageBatch.FirstOrDefault(m => m.Author.ID == participant.ID)) .Where(message => message is not null) .Select(m => m !) .ToList(); var getDedicatedChannel = DedicatedChannelService.GetDedicatedChannel(roleplay); if (!getDedicatedChannel.IsSuccess) { return(Result.FromError(getDedicatedChannel)); } var dedicatedChannel = getDedicatedChannel.Entity; foreach (var participantMessage in participantMessages.OrderByDescending(m => m.Timestamp)) { var messageLink = "https://discord.com/channels/" + $"{_context.GuildID.Value}/{_context.ChannelID}/{participantMessage.ID}"; var send = await _channelAPI.CreateMessageAsync(dedicatedChannel, messageLink); if (!send.IsSuccess) { return(Result.FromError(send)); } } var start = await StartRoleplayAsync(roleplay); return(start.IsSuccess ? Result.FromSuccess() : Result.FromError(start)); } }
public async Task <Result <FeedbackMessage> > ShowOrCreateDedicatedRoleplayChannel ( [RequireEntityOwner] [AutocompleteProvider("roleplay::owned")] Roleplay roleplay ) { var getDedicatedChannelResult = DedicatedChannelService.GetDedicatedChannel(roleplay); if (getDedicatedChannelResult.IsSuccess) { var existingDedicatedChannel = getDedicatedChannelResult.Entity; var message = $"\"{roleplay.Name}\" has a dedicated channel at " + $"<#{existingDedicatedChannel}>"; return(new FeedbackMessage(message, _feedback.Theme.Secondary)); } var workingMessage = new Embed { Colour = _feedback.Theme.Secondary, Description = "Setting up dedicated channel..." }; var send = await _feedback.SendContextualEmbedAsync(workingMessage); if (!send.IsSuccess) { return(Result <FeedbackMessage> .FromError(send)); } // The roleplay either doesn't have a channel, or the one it has has been deleted or is otherwise invalid. var result = await _dedicatedChannels.CreateDedicatedChannelAsync(roleplay); if (!result.IsSuccess) { return(Result <FeedbackMessage> .FromError(result)); } var dedicatedChannel = result.Entity; if (!roleplay.IsActive || roleplay.ActiveChannelID == dedicatedChannel.ID) { return(new FeedbackMessage ( $"All done! Your roleplay now has a dedicated channel at <#{dedicatedChannel}>.", _feedback.Theme.Secondary )); } var stopResult = await StopRoleplayAsync(roleplay); if (!stopResult.IsSuccess) { return(stopResult); } var startResult = await StartRoleplayAsync(roleplay); if (!startResult.IsSuccess) { return(startResult); } return(new FeedbackMessage ( $"All done! Your roleplay now has a dedicated channel at <#{dedicatedChannel}>.", _feedback.Theme.Secondary )); }
/// <summary> /// Starts the given roleplay in the current channel, or the dedicated channel if one exists. /// </summary> /// <param name="currentChannelID">The current channel.</param> /// <param name="roleplay">The roleplay.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <Result> StartRoleplayAsync(Snowflake currentChannelID, Roleplay roleplay) { var getDedicatedChannelResult = DedicatedChannelService.GetDedicatedChannel(roleplay); // Identify the channel to start the RP in. Preference is given to the roleplay's dedicated channel. var channelID = getDedicatedChannelResult.IsSuccess ? getDedicatedChannelResult.Entity : currentChannelID; var getChannel = await _channelAPI.GetChannelAsync(channelID); if (!getChannel.IsSuccess) { return(Result.FromError(getChannel)); } var channel = getChannel.Entity; if (roleplay.IsNSFW && !(channel.IsNsfw.HasValue && channel.IsNsfw.Value)) { return(new UserError ( "This channel is not marked as NSFW, while your roleplay is... naughty!" )); } var getHasActiveRoleplay = await HasActiveRoleplayAsync(channelID); if (!getHasActiveRoleplay.IsSuccess) { return(Result.FromError(getHasActiveRoleplay)); } if (getHasActiveRoleplay.Entity) { var currentRoleplayResult = await GetActiveRoleplayAsync(channelID); if (!currentRoleplayResult.IsSuccess) { return(Result.FromError(currentRoleplayResult)); } var currentRoleplay = currentRoleplayResult.Entity; var timeOfLastMessage = currentRoleplay.Messages.Last().Timestamp; var currentTime = DateTimeOffset.UtcNow; if (timeOfLastMessage < currentTime.AddHours(-4)) { currentRoleplay.IsActive = false; } else { return(new UserError("There's already a roleplay active in this channel.")); } } var start = await _roleplays.StartRoleplayAsync(roleplay, channelID); if (!start.IsSuccess) { return(start); } // If the channel in question is the roleplay's dedicated channel, enable it if (!roleplay.DedicatedChannelID.HasValue) { return(Result.FromSuccess()); } var enableChannel = await _dedicatedChannels.UpdateParticipantPermissionsAsync(roleplay); if (!enableChannel.IsSuccess) { return(enableChannel); } var joinedUsers = roleplay.JoinedUsers.Select ( u => $"<@{u.User.DiscordID}>" ); var participantList = joinedUsers.Humanize(); var send = await _channelAPI.CreateMessageAsync ( roleplay.ActiveChannelID !.Value, $"Calling {participantList}!" ); return(!send.IsSuccess ? Result.FromError(send) : Result.FromSuccess()); }