public Bot()
{
Client = new DiscordSocketClient(new DiscordSocketConfig
{
LogLevel = LogSeverity.Debug
});
Commands = new CommandService(new CommandServiceConfig
{
LogLevel = LogSeverity.Debug,
CaseSensitiveCommands = true,
DefaultRunMode = RunMode.Async,
IgnoreExtraArgs = true
});
Interactive = new InteractiveService(Client, new InteractiveServiceConfig
{
DefaultTimeout = TimeSpan.FromMinutes(2)
});
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Information()
.MinimumLevel.Override("Microsoft", Serilog.Events.LogEventLevel.Debug)
.MinimumLevel.Override("Microsoft", Serilog.Events.LogEventLevel.Information)
.WriteTo.Console(
outputTemplate: "{Timestamp:HH:mm:ss} - [{Level:u4}] => {Message:lj}{NewLine}{Exception}"
)
.CreateLogger();
Services = BuildServiceProvder();
}
public Trivia(GuildRepository guildRepo, UserRepository userRepo, InteractiveService interactiveService, GameService gameService)
{
_guildRepo = guildRepo;
_userRepo = userRepo;
_interactiveService = interactiveService;
_gameService = gameService;
}
public HelpService(SkillsService skillsService,
SpecialService specialService,
InteractiveService interactiveService)
{
_skillsService = skillsService;
_interactiveService = interactiveService;
}
public AudioModule(
LavaNode node,
InteractiveService interactiveService)
{
_node = node;
_interactiveService = interactiveService;
}
public Items(UserRepository userRepo, InteractiveService interactiveService, GameService gameService, CooldownService cooldownService)
{
_userRepo = userRepo;
_interactiveService = interactiveService;
_gameService = gameService;
_cooldownService = cooldownService;
}
public HelpCommand(CommandService commands, MiscService misc, IServiceProvider services, InteractiveService inter)
{
_commands = commands;
_misc = misc;
_services = services;
_inter = inter;
}
public CommandsCommand(CommandService commands, MiscService misc, RandomService rand, InteractiveService inter)
{
_commands = commands;
_misc = misc;
_rand = rand;
_inter = inter;
}
public Gangs(GangRepository gangRepo, UserRepository userRepo, InteractiveService interactiveService, CooldownService CooldownService)
{
_gangRepo = gangRepo;
_userRepo = userRepo;
_interactiveService = interactiveService;
_cooldownService = CooldownService;
}
public async Task Reset_Points()
{
_interactiveService = new InteractiveService(_client.GetShardFor(Context.Guild));
var violators = (await _unit.Violators.GetAllAsync(Context.Guild)).ToList();
await ReplyAsync(
$"Are you sure you want to reset all points for all Users in {Context.Guild} ? *({violators.Count} total)*" +
"\n**Yes** - confirm" +
"\n**No** - cancel" +
"\n**30 sec timeout**");
var response = await _interactiveService.WaitForMessage(Context.User, Context.Channel, TimeSpan.FromSeconds(30),
new MessageContainsResponsePrecondition("yes"));
if (response.Content.ToLower() == "yes")
{
var changes = ClearPoints(Context.Guild);
await ReplyAsync($"{changes} {(changes > 1 ? "entries" : "entry")} deleted!");
var logger = LogManager.GetLogger("Violations");
logger.Info($"Removed all [{changes}] Violator entries for {Context.Guild}");
try
{
await response.DeleteAsync();
}
catch (Exception e)
{
LogManager.GetLogger("GuildModule").Warn(e, $"Failed to delete message {response.Id} by {response.Author} in {Context.Guild}/{Context.Channel}");
}
}
else
{
await ReplyAsync("*Canceled*");
}
}
public KickUserRcon(SocketCommandContext context, InteractiveService interactive, DataService data, LogHandler log)
{
_context = context;
_interactive = interactive;
_data = data;
_log = log;
}
public static async Task <IUserMessage> SendInteractiveMessageAsync
(
this InteractiveService @this,
[NotNull] SocketCommandContext context,
[NotNull] IInteractiveMessage interactiveMessage,
[CanBeNull] ISocketMessageChannel channel = null
)
{
channel = channel ?? context.Channel;
var message = await interactiveMessage.DisplayAsync(channel);
if (interactiveMessage.ReactionCallback is null)
{
return(message);
}
@this.AddReactionCallback(message, interactiveMessage.ReactionCallback);
if (interactiveMessage.Timeout.HasValue)
{
// ReSharper disable once AssignmentIsFullyDiscarded
_ = Task.Delay(interactiveMessage.Timeout.Value).ContinueWith(c =>
{
@this.RemoveReactionCallback(interactiveMessage.Message);
interactiveMessage.Message.DeleteAsync();
});
}
return(message);
}
public static async Task <IUserMessage> SendPrivateInteractiveMessageAsync
(
this InteractiveService @this,
[NotNull] SocketCommandContext context,
[NotNull] UserFeedbackService feedback,
[NotNull] IInteractiveMessage interactiveMessage
)
{
if (!(await context.User.GetOrCreateDMChannelAsync() is ISocketMessageChannel userChannel))
{
throw new InvalidOperationException("Could not create DM channel for target user.");
}
try
{
await feedback.SendConfirmationAsync(context, "Loading...");
}
catch (HttpException hex) when(hex.WasCausedByDMsNotAccepted())
{
await feedback.SendWarningAsync(context, "You don't accept DMs from non-friends on this server, so I'm unable to do that.");
throw new InvalidOperationException("User does not accept DMs from non-friends.");
}
finally
{
await((IDMChannel)userChannel).CloseAsync();
}
if (!context.IsPrivate)
{
await feedback.SendConfirmationAsync(context, "Please check your private messages.");
}
return(await SendInteractiveMessageAsync(@this, context, interactiveMessage, userChannel));
}
public SetCommand(MiscService misc, DbService db, InteractiveService inter, RandomService rand)
{
_misc = misc;
_db = db;
_inter = inter;
_rand = rand;
}
public UtilityModule(DatabaseService databaseService, ResponseService responseService, HelperService helperService, InteractiveService interactiveService)
{
_databaseService = databaseService;
_responseService = responseService;
_helperService = helperService;
_interactiveService = interactiveService;
}
public override void Start(ImageViewer imageViewer)
{
base.Start(imageViewer);
InteractiveService service = base.InteractiveService;
service.Tap += new EventHandler <InteractiveEventArgs>(service_Tap);
}
public KickUserRcon(SocketCommandContext context, InteractiveService interactive, RconService rconService,
LogHandler log)
{
_context = context;
_interactive = interactive;
_rconService = rconService;
_log = log;
}
public ChannelFilters(DiscordSocketClient discord, TownDatabase database, InteractiveService interactive)
{
this.database = database;
this.discord = discord;
this.interactive = interactive;
discord.MessageReceived += Handle;
}
public VerificationModule(DiscordSocketClient client, CommandService commands, DataService data, VerificationService verificationService, InteractiveService interactive)
{
_client = client;
_commands = commands;
_dataService = data;
_verificationService = verificationService;
_interactive = interactive;
}
/// <summary>
/// Interaction handler constructor.
/// </summary>
/// <param name="client">The current <see cref="DiscordSocketClient"/>.</param>
/// <param name="interactionCommands">The Discord interaction command service.</param>
/// <param name="interactiveService">The interactive service to handle pagination and selections.</param>
/// <param name="services">The service provider.</param>
/// <param name="logger">The log4net <see cref="ILog"/> instance.</param>
public InteractionHandler(DiscordSocketClient client, InteractionService interactionCommands, InteractiveService interactiveService, IServiceProvider services, ILog logger = null)
{
Client = client;
InteractionCommands = interactionCommands;
InteractiveService = interactiveService;
Services = services;
Logger = logger;
}
public MiscService(DiscordShardedClient client, IServiceProvider services, NetService net, Random random, RandomService rand, InteractiveService inter)
{
_client = client;
_services = services;
_random = random;
_net = net;
_rand = rand;
_inter = inter;
}
private IServiceProvider BuildServiceProvider(DiscordSocketClient client)
{
InteractiveService interactiveService = new InteractiveService(client);
return(new ServiceCollection()
.AddSingleton <InteractiveService>(interactiveService)
.AddDbContext <FloofDataContext>()
.BuildServiceProvider());
}
public Crime(UserRepository userRepo, GangRepository gangRepo, ModerationService moderationService, GameService gameService, InteractiveService interactiveService, CooldownService CooldownService)
{
_userRepo = userRepo;
_gangRepo = gangRepo;
_moderationService = moderationService;
_gameService = gameService;
_interactiveService = interactiveService;
_cooldownService = CooldownService;
}
public Owners(GuildRepository guildRepo, UserRepository userRepo, GangRepository gangRepo, RankHandler rankHandler, GameService gameService, InteractiveService interactiveService)
{
_guildRepo = guildRepo;
_gangRepo = gangRepo;
_userRepo = userRepo;
_RankHandler = rankHandler;
_gameService = gameService;
_interactiveService = interactiveService;
}
public override void Stop(ImageViewer imageViewer)
{
if (IsStarted)
{
InteractiveService service = base.InteractiveService;
service.Tap -= new EventHandler <InteractiveEventArgs>(service_Tap);
base.Stop(imageViewer);
}
}
public ModerationModule(DataService data, DiscordSocketClient client, LogHandler log, GoogleCalendar calendar,
PlaytestService playtestService, InteractiveService interactive)
{
_playtestService = playtestService;
_calendar = calendar;
_data = data;
_client = client;
_log = log;
_interactive = interactive;
}
public static async Task <IUserMessage> NewSendPaginatedMessageAsync(this InteractiveService IS,
SocketCommandContext context,
PaginatedMessage pager,
ICriterion <SocketReaction> criterion = null)
{
var callback = new CustomPMC(IS, context, pager, criterion);
await callback.DisplayAsync().ConfigureAwait(false);
return(callback.Message);
}
public PaginationWithAction(ConfigurationStep step, ConfigurationStep parent, System.Collections.Generic.List <IPaginatable> elements,
bool confirmation, SocketCommandContext context, InteractiveService interactive)
{
this.step = step;
this.parent = parent;
this.elements = elements;
this.needsConfirmation = confirmation;
this.context = context;
this.interactive = interactive;
}
public PaginatedMessageCallback(InteractiveService interactive,
EspeonContext sourceContext,
PaginatedMessage pager, ICriterion <Emoji> criterion = null)
{
_interactive = interactive;
Context = sourceContext;
Criterion = criterion ?? new EmptyCriterion <Emoji>();
_pager = pager;
_pages = _pager.Pages.Count();
}
/// <summary>
/// Sends a confirmation message, and deletes it after a specified timeout.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="interactivity">The interactivity service.</param>
/// <param name="contents">The contents of the message.</param>
/// <param name="timeout">The timeout after which the message should be deleted.</param>
public async Task SendConfirmationAndDeleteAsync
(
[NotNull] SocketCommandContext context,
[NotNull] InteractiveService interactivity,
[NotNull] string contents,
[CanBeNull] TimeSpan?timeout = null
)
{
await SendEmbedAndDeleteAsync(context, interactivity, Color.DarkPurple, contents, timeout);
}
public async Task InitializeAsync()
{
_ = PublicVariables.Colors;
_configuration = ConfigurationService.LoadNewConfig();
_database = new DatabaseService(_configuration);
_http = new HttpClient();
_client = new DiscordShardedClient(new DiscordSocketConfig
{
AlwaysDownloadUsers = true,
DefaultRetryMode = RetryMode.AlwaysRetry,
LogLevel = LogSeverity.Info,
MessageCacheSize = 2048,
TotalShards = _configuration.ShardCount
});
_commands = new CommandService(new CommandServiceConfig
{
CaseSensitiveCommands = false,
LogLevel = LogSeverity.Info,
DefaultRunMode = RunMode.Sync
});
_interactive = new InteractiveService(_client);
_services = new ServiceCollection()
.AddSingleton(_client)
.AddSingleton(_commands)
.AddSingleton(_configuration)
.AddSingleton(_database)
.AddSingleton(_interactive)
.AddSingleton(_http)
.AddSingleton(new Giphy(_configuration.GiphyApiKey))
.AddSingleton <StatisticsService>()
.AddSingleton <Random>()
.AddSingleton <LogService>()
.AddSingleton <CachingService>()
.AddSingleton <ServerService>()
.AddSingleton <NsfwService>()
.BuildServiceProvider();
_services.GetService <LogService>();
_services.GetService <StatisticsService>();
_client.MessageReceived += MessageReceived;
_client.ReactionAdded += ReactionAdded;
_client.Log += Log;
_commands.Log += Log;
_client.ShardReady += Ready;
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
Console.WriteLine($"{_commands.Commands.Count()} commands | {_commands.Modules.Count()} modules");
await _client.LoginAsync(TokenType.Bot, _configuration.BotToken);
await _client.StartAsync();
await Task.Delay(-1);
}
