/// <summary>
 /// Initializes a new instance of the <see cref="SetCommands"/> class.
 /// </summary>
 /// <param name="discordRoleplays">The roleplay service.</param>
 /// <param name="feedback">The feedback service.</param>
 public SetCommands
 (
     RoleplayDiscordService discordRoleplays, FeedbackService feedback)
 {
     _discordRoleplays = discordRoleplays;
     _feedback         = feedback;
 }
 /// <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;
 }
Esempio n. 3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="RoleplayLoggingResponder"/> class.
 /// </summary>
 /// <param name="roleplays">The roleplay service.</param>
 /// <param name="log">The logging instance.</param>
 /// <param name="userAPI">The user API.</param>
 public RoleplayLoggingResponder
 (
     RoleplayDiscordService roleplays,
     ILogger <RoleplayLoggingResponder> log,
     IDiscordRestUserAPI userAPI
 )
 {
     _roleplays = roleplays;
     _log       = log;
     _userAPI   = userAPI;
 }
Esempio n. 4
0
 /// <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;
 }
    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));
    }
Esempio n. 9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="RoleplayParser"/> class.
 /// </summary>
 /// <param name="roleplays">The roleplaying service.</param>
 /// <param name="context">The command context.</param>
 public RoleplayParser(RoleplayDiscordService roleplays, ICommandContext context)
 {
     _roleplays = roleplays;
     _context   = context;
 }
Esempio n. 10
0
 /// <summary>
 /// Initializes a new instance of the <see cref="RequireActiveRoleplayCondition"/> class.
 /// </summary>
 /// <param name="context">The command context.</param>
 /// <param name="roleplayService">The roleplay service.</param>
 public RequireActiveRoleplayCondition(ICommandContext context, RoleplayDiscordService roleplayService)
 {
     _context         = context;
     _roleplayService = roleplayService;
 }