private async Task InstallCommandsAsync()
{
try
{
if (_client is DiscordSocketClient socketClient)
{
// Hook the MessageReceived event into our command handler
socketClient.MessageReceived += HandleCommandAsync;
}
//Exception and Post Execution handling
_commands.Log += ExceptionLogging.Log;
_commands.CommandExecuted += CommandExecuted;
//Adds custom type readers
_commands.AddTypeReader(typeof(Emoji), new EmojiTypeReader());
_commands.AddTypeReader(typeof(UserRef), new UserRefTypeReader());
_commands.AddTypeReader(typeof(IUser), new BetterUserTypeReader());
_commands.AddTypeReader(typeof(TimeSpan), new TimeSpanTypeReader(), true);
// See Dependency Injection guide for more information.
await _commands.AddModulesAsync(assembly : Assembly.GetAssembly(typeof(MainClass)),
services : services);
//await new LogMessage(LogSeverity.Info, "CMDs", "Commands set up").Log();
}
catch (Exception e)
{
await new LogMessage(LogSeverity.Critical, "CMDs", "Commands set up failed", e).Log();
}
}
public void AddTypeReaders()
{
_service.AddTypeReader <Emoji>(new EmojiTypeReader());
_service.AddTypeReader <AccountOption>(new AccountOptionTypeReader());
_service.AddTypeReader <object>(new ObjectTypeReader());
_service.AddTypeReader <WidgetType>(new WidgetTypeTypeReader());
}
public async Task InitializeAsync()
{
_commands.AddTypeReader <Event>(new EventTypeReader());
_commands.AddTypeReader <EventRole>(new EventRoleTypeReader());
// Register modules that are public and inherit ModuleBase<T>.
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
}
public async Task Init()
{
_commands.AddTypeReader <PKSystem>(new PKSystemTypeReader());
_commands.AddTypeReader <PKMember>(new PKMemberTypeReader());
_commands.CommandExecuted += CommandExecuted;
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
_client.ShardReady += ShardReady;
_client.Log += FrameworkLog;
_client.MessageReceived += (msg) =>
{
// _client.CurrentUser will be null if we've connected *some* shards but not shard #0 yet
// This will cause an error in WebhookCacheService so we just workaround and don't process any messages
// until we properly connect. TODO: can we do this without chucking away a bunch of messages?
if (_client.CurrentUser == null)
{
return(Task.CompletedTask);
}
return(HandleEvent(s => s.AddMessageBreadcrumb(msg), eh => eh.HandleMessage(msg)));
};
_client.ReactionAdded += (msg, channel, reaction) => HandleEvent(s => s.AddReactionAddedBreadcrumb(msg, channel, reaction), eh => eh.HandleReactionAdded(msg, channel, reaction));
_client.MessageDeleted += (msg, channel) => HandleEvent(s => s.AddMessageDeleteBreadcrumb(msg, channel), eh => eh.HandleMessageDeleted(msg, channel));
_client.MessagesBulkDeleted += (msgs, channel) => HandleEvent(s => s.AddMessageBulkDeleteBreadcrumb(msgs, channel), eh => eh.HandleMessagesBulkDelete(msgs, channel));
}
public async Task MainAsync()
{
await _client.LoginAsync(TokenType.Bot, Environment.GetEnvironmentVariable("DiscordToken"), true);
await _client.StartAsync();
//waits until the client is ready before using it
_client.Ready += async() =>
{
_commands.AddTypeReader(typeof(Reminder), new ReminderTypeReader());
_commands.AddTypeReader(typeof(DateTime), new DateTimeTypeReader());
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _provider);
//Checks if the bot is the beta bot or not
//If the bot is beta it will not connect to twitch
if (_client.CurrentUser.Id == MainBotId)
{
_provider.GetRequiredService <TwitchAPIService>();
}
//setting status
IActivity game = new Game("Pushing the smoke...", ActivityType.Playing, ActivityProperties.None, null);
await _client.SetActivityAsync(game);
};
//block the main task from closing
await Task.Delay(Timeout.Infinite);
}
public async Task MainAsync()
{
_config = new ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddJsonFile(path: "config.json")
.Build();
_services = new ServiceCollection()
.AddSingleton(_config)
.AddSingleton <DiscordSocketClient>()
.AddSingleton <InteractivityService>()
.AddSingleton <MessageQueue>()
.AddSingleton <CommandHandler>()
.AddSingleton <CommandService>()
.AddSingleton <GuildSettings>()
.AddSingleton <Logger>()
.BuildServiceProvider();
_client = _services.GetRequiredService <DiscordSocketClient>();
_client.Log += _services.GetRequiredService <Logger>().Log;
await _client.LoginAsync(TokenType.Bot, _config["token"]);
await _client.StartAsync();
commandService = _services.GetRequiredService <CommandService>();
commandService.Log += _services.GetRequiredService <Logger>().Log;
commandService.AddTypeReader(typeof(List <string[]>), new JsonTypeReader <List <string[]> >());
commandService.AddTypeReader(typeof(List <EditData>), new JsonTypeReader <List <EditData> >());
handler = _services.GetRequiredService <CommandHandler>();
await handler.InstallCommandsAsync();
// Block this task until the program is closed.
await Task.Delay(-1);
}
public async Task InstallCommandsAsync()
{
// Hook the MessageReceived event into our command handler
_client.MessageReceived += HandleCommandAsync;
_client.MessageDeleted += _client_MessageDeleted;
_client.MessageUpdated += _client_MessageUpdated;
_client.ReactionAdded += _client_ReactionAdded;
_client.ReactionRemoved += _client_ReactionRemoved;
_commands.AddTypeReader(typeof(System.Numerics.BigInteger), new BigIntegerTypeReader());
_commands.AddTypeReader(typeof(IEmote), new EmojiTypereader());
// Here we discover all of the command modules in the entry
// assembly and load them. Starting from Discord.NET 2.0, a
// service provider is required to be passed into the
// module registration method to inject the
// required dependencies.
//
// If you do not use Dependency Injection, pass null.
// See Dependency Injection guide for more information.
await _commands.AddModuleAsync <BasicModule>(null);
await _commands.AddModuleAsync <ListSortModule>(null);
await _commands.AddModuleAsync <BotServerManagmentModule>(null);
await _commands.AddModuleAsync <MiscCommandsModlue>(null);
await _commands.AddModuleAsync <ReminderModule>(null);
//await _commands.AddModulesAsync(assembly: Assembly.GetEntryAssembly(),
// services: null);
}
public async Task StartClient()
{
if (string.IsNullOrWhiteSpace(_botOptions.Token))
{
throw new Exception("Your token is missing or configured incorrectly.");
}
await _discord.LoginAsync(TokenType.Bot, _botOptions.Token);
await _discord.StartAsync();
await _discord.SetActivityAsync(new Game($"{_botOptions.Prefix}help", ActivityType.Listening));
_commandService.AddTypeReader(typeof(decimal), new DecimalTypeReader(), true);
_commandService.AddTypeReader(typeof(Fraction), new FractionTypeReader());
await _commandService.AddModulesAsync(Assembly.GetEntryAssembly(), _provider);
await CheckModuleFlags();
if (!_commandService.Modules.Any())
{
throw new Exception("There are no modules enabled.");
}
}
private async Task StartAsync(params string[] args)
{
_client = new DiscordSocketClient(new DiscordSocketConfig {
LogLevel = LogSeverity.Info
});
var serv = InstallServices();
serv.GetRequiredService <ReliabilityService>();
serv.GetRequiredService <CommandHandlerService>();
serv.GetRequiredService <InviteService>();
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), serv);
_commands.AddTypeReader <RLPlaylist>(new RLPlatformTypeReader());
_commands.AddTypeReader <RLRegion>(new RLRegionTypeReader());
_commands.AddTypeReader <RLPlaylist>(new RLPlaylistTypeReader());
_client.Log += Log;
_commands.Log += Log;
await _client.LoginAsync(TokenType.Bot, ConfigurationManager.AppSettings["TOKEN"]);
await _client.StartAsync();
await _client.SetGameAsync(ConfigurationManager.AppSettings["GAME"]);
await Task.Delay(-1).ConfigureAwait(false);
}
//Adds modules and services
public override async Task InitializeAsync(CancellationToken cancellationToken)
{
//Adds custom type readers
_commands.AddTypeReader(typeof(IUser), new ExtendedUserTypeReader());
_commands.AddTypeReader(typeof(IRole), new ExtendedRoleTypeReader());
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
}
protected override async Task ExecuteAsync(CancellationToken cancellationToken)
{
_client.MessageReceived += HandleCommandAsync;
_command.AddTypeReader(typeof(PointType), new PointTypeTypeReader());
_command.AddTypeReader(typeof(AccountItem), new AccountItemTypeReader());
await _command.AddModulesAsync(Assembly.GetEntryAssembly(), _provider);
}
//Adds modules and services
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
//Adds custom type readers
_commandService.AddTypeReader(typeof(IUser), new ExtendedUserTypeReader());
_commandService.AddTypeReader(typeof(IRole), new ExtendedRoleTypeReader());
await _commandService.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
}
public async Task InitializeAsync(IServiceProvider provider)
{
_provider = provider;
_commands.AddTypeReader <ModuleInfo>(new ModuleInfoTypeReader());
_commands.AddTypeReader <CommandInfo>(new CommandInfoTypeReader());
await _commands.AddModulesAsync(Assembly.GetEntryAssembly());
}
public async Task Initialize()
{
_client.MessageReceived += HandleCommand;
_client.MessageUpdated += MessageUpdated;
_commands.CommandExecuted += CommandExecuted;
_commands.AddTypeReader <CodeSnippet>(new CodeSnippetTypeReader());
_commands.AddTypeReader <Size>(new SizeTypeReader());
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
}
public async Task InstallCommandsAsync()
{
_client.MessageReceived += HandleCommandAsync;
_commands.AddTypeReader(typeof(bool), new TypeReaders.BooleanTypeReader());
_commands.AddTypeReader(typeof(int), new TypeReaders.IntegerTypeReader());
await _commands.AddModulesAsync(assembly : Assembly.GetEntryAssembly(), services : null);
}
public async Task InitializeAsync(IServiceProvider provider)
{
_provider = provider;
_commands.AddTypeReader <IMentionable>(new MentionableTypeReader(), true);
_commands.AddTypeReader <Guid>(new GuidTypeReader(), true);
using var scope = _provider.CreateScope();
await _commands.AddModulesAsync(Assembly.GetExecutingAssembly(), scope.ServiceProvider);
// Add additional initialization code here...
}
/// <summary>
/// Installs the commands and subscribes to MessageReceived event.
/// </summary>
public async Task InstallCommandsAsync()
{
_commands.AddTypeReader(typeof(Globals.SkillType), new Addons.SkillTypeReader());
_commands.AddTypeReader(typeof(Globals.SpecialType), new Addons.SpecialTypeReader());
await _commands.AddModulesAsync(
assembly : Assembly.GetEntryAssembly(),
services : _services);
_client.MessageReceived += HandleCommandAsync;
_commands.CommandExecuted += OnCommandExecutedAsync;
}
/// <summary>
/// Install all the modules and sets up for command handling
/// </summary>
/// <returns></returns>
public async Task SetupCommandHandlingAsync()
{
//Add our custom type readers
_commands.AddTypeReader(typeof(string[]), new StringArrayTypeReader());
_commands.AddTypeReader(typeof(SocketGuildUser[]), new GuildUserArrayTypeReader());
_commands.AddTypeReader(typeof(Emoji), new EmojiTypeReader());
//Add our modules and setup the module manager so other classes can access module info
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
DiscordModuleManager.SetupModuleManager(_commands);
_client.MessageReceived += HandleMessage;
}
#pragma warning restore CA2211 // Non-constant fields should not be visible
public CommandHandler(
DiscordSocketClient discord,
CommandService commands,
IServiceProvider provider,
GitHubService git,
LoggingService logging,
InteractiveService interactiveService,
HttpClient client)
{
_discord = discord;
_commands = commands;
_provider = provider;
_git = git;
_logging = logging;
_interactive = interactiveService;
_client = client;
_discord.MessageReceived += Discord_MessageReceived; // Bind MessageReceived event
_discord.JoinedGuild += Discord_JoinedGuild; // Bind JoinedGuild event
_discord.UserVoiceStateUpdated += Discord_UserVoiceStateUpdated;
_discord.ReactionAdded += Discord_ReactionAdded;
_discord.ReactionRemoved += Discord_ReactionRemoved;
_discord.UserJoined += Discord_UserJoined;
_discord.Ready += async() =>
{
await LoggingService.OnLogAsync(new LogMessage(LogSeverity.Info, "Discord", $"Logged in as: {_discord.CurrentUser.Username}"));
_ = Task.Run(async() =>
{
var msg = new HttpRequestMessage(HttpMethod.Get, "https://api.github.com/repos/D3LT4PL/DygModBot/commits?per_page=1");
msg.Headers.UserAgent.ParseAdd("DygModBot by D3LT4PL/1.0");
var resp = await _client.SendAsync(msg);
var header = resp.Headers.GetValues("link").First();
var amount = int.Parse(new Regex("&page=([0-9]*)>; rel=\"last\"").Match(header).Groups[1].Value);
IActivity activity = new Game($"Build nr {amount}");
await _discord.SetActivityAsync(activity);
await _discord.SetStatusAsync(UserStatus.DoNotDisturb);
FinishedInit = true;
await Task.Delay(TimeSpan.FromMinutes(1));
await _discord.SetActivityAsync(new Game("db!new | db!oc | DM me"));
await _discord.SetStatusAsync(UserStatus.Online);
});
};
_commands.AddTypeReader <object>(new ObjectTypeReader());
_commands.AddTypeReader <Uri>(new UriTypeReader());
_commands.AddTypeReader <TimeSpan>(new CustomTimeSpanTypeReader(), true);
_commands.AddTypeReader <IEmote>(new IEmoteTypeReader());
_commands.AddTypeReader <IMessage>(new IMessageTypeReader());
}
public CommandHandlingService(IServiceProvider services)
{
_commands = services.GetRequiredService <CommandService>();
_discord = services.GetRequiredService <DiscordShardedClient>();
_services = services;
_commands.CommandExecuted += CommandExecutedAsync;
_commands.Log += LogAsync;
_discord.MessageReceived += MessageReceivedAsync;
// Add TypeReaders
_commands.AddTypeReader(typeof(ILiveBotUser), new LiveBotUserTypeReader());
_commands.AddTypeReader(typeof(bool), new EnhancedBoolTypeReader());
}
public CommandHandlingService(IServiceProvider services)
{
_commands = services.GetRequiredService<CommandService>();
_discord = services.GetRequiredService<DiscordSocketClient>();
_services = services;
_random = new Random();
_commands.AddTypeReader(typeof(BuffType), new BuffTypeReader());
_commands.AddTypeReader(typeof(DateTime), new DateTimeReader(), true);
_commands.AddTypeReader(typeof(AlertAction), new AlertActionReader());
_commands.CommandExecuted += CommandExecutedAsync;
_discord.MessageReceived += MessageReceivedAsync;
}
public CommandHandlingService(CommandService commands, DiscordSocketClient discord, IServiceProvider provider, IConfiguration config, ILogger <CommandHandlingService> log)
{
_commands = commands;
_discord = discord;
_provider = provider;
_config = config;
_logger = log;
_commands.CommandExecuted += CommandExecutedAsync;
_discord.MessageReceived += MessageReceivedAsync;
_commands.AddTypeReader <IGuild>(new GuildTypeReader <SocketGuild>());
_commands.AddTypeReader <Uri>(new UriTypeReader());
}
public async Task InitialiseAsync()
{
_client.MessageReceived += HandleCommandAsync;
_client.ChannelDestroyed += OnChannelDestroyedAsync;
_commands.CommandExecuted += OnCommandExecutedAsync;
_client.ReactionAdded += Client_ReactionAdded;
_commands.AddTypeReader <Item>(new ItemTypeReader());
_commands.AddTypeReader <MarbleBotUser>(new MarbleBotUserTypeReader());
_commands.AddTypeReader <Weapon>(new WeaponTypeReader());
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services).ConfigureAwait(false);
await _client.SetGameAsync("for mb/help!", type : ActivityType.Watching);
}
public static async Task <CommandService> InstallCommands(DiscordSocketClient client, IServiceProvider services)
{
// Hook the MessageReceived Event into our Command Handler
var commands = new CommandService();
commands.Log += Log;
client.MessageReceived += msg => HandleCommand(client, services, commands, msg);
// Discover all of the commands in this assembly and load them.
commands.AddTypeReader(typeof(IUser), new MainGuildUserTypeReader <IUser>());
commands.AddTypeReader(typeof(IGuildUser), new MainGuildUserTypeReader <IGuildUser>());
commands.AddTypeReader <IGupUser>(new MainGuildUserTypeReader <IGupUser>(GupUser.BehaviorOverrides), true);
await commands.AddModulesAsync(Assembly.GetEntryAssembly(), services);
return(commands);
}
public async Task InitializeAsync()
{
_commandService.AddTypeReader(typeof(MiunieUser), new MiunieUserTypeReader(_convertor));
_discord.Client.MessageReceived += HandleCommandAsync;
_ = await _commandService.AddModulesAsync(Assembly.GetExecutingAssembly(), _services);
}
public async Task StartAsync()
{
string discordToken = _config.DiscordToken;
if (string.IsNullOrWhiteSpace(discordToken))
{
throw new Exception("Please enter a valid bot's token.");
}
await _discord.LoginAsync(TokenType.Bot, discordToken);
await _discord.StartAsync();
_commands.AddTypeReader <List <string> >(new ListOfStringTypeReader());
await _commands.AddModuleAsync(typeof(CoinModule), _provider);
await _commands.AddModuleAsync(typeof(CoinWarModule), _provider);
await _commands.AddModuleAsync(typeof(PollModule), _provider);
await _commands.AddModuleAsync(typeof(MafiaModule), _provider);
await _commands.AddModuleAsync(typeof(InfoModule), _provider);
await _commands.AddModuleAsync(typeof(BetModule), _provider);
await _commands.AddModuleAsync(typeof(AwardModule), _provider);
}
public async Task InstallCommandsAsync()
{
// Hook the MessageReceived event into our command handler
_client.MessageReceived += HandleCommandAsync;
_client.MessageUpdated += HandleUpdatedCommandAsync;
//_client.ReactionAdded += HandleReactionAddedCommandAsync;
_commands.AddTypeReader <YoutubeVideoUrl>(new YoutubeVideoUrlTypeReader());
// Here we discover all of the command modules in the entry
// assembly and load them. Starting from Discord.NET 2.0, a
// service provider is required to be passed into the
// module registration method to inject the
// required dependencies.
//
// If you do not use Dependency Injection, pass null.
// See Dependency Injection guide for more information.
IEnumerable <ModuleInfo> modules = await _commands.AddModulesAsync(assembly : Assembly.GetEntryAssembly(),
services : this.serviceProvider);
StringBuilder sb = new StringBuilder();
StringBuilder help = new StringBuilder();
sb.AppendLine(Program.APPLICATION_NAME);
sb.AppendLine(Program.VERSION);
sb.AppendLine("Discord Modules loaded:");
help.AppendLine(Program.APPLICATION_NAME);
help.AppendLine(Program.VERSION);
foreach (ModuleInfo module in modules)
{
sb.AppendLine(module.Name);
sb.AppendLine(module.Summary);
sb.AppendLine("Commands: ");
foreach (CommandInfo cmd in module.Commands)
{
sb.AppendLine(" " + cmd.Name);
sb.AppendLine(" " + cmd.Summary);
}
sb.AppendLine("-----");
//only print description from allowed module
//in case you have some kind of hidden module like administration or debug
if (module.Name == DiscordModule.MODULE_NAME)
{
help.AppendLine("```");
help.AppendLine(module.Name);
help.AppendLine(module.Summary);
help.AppendLine("Commands: ");
foreach (CommandInfo cmd in module.Commands)
{
help.AppendLine(" " + cmd.Name + '\t' + cmd.Summary);
}
help.AppendLine("```");
}
DiscordModule.HELP_STRING = help.ToString();
}
logger.LogInformation(sb.ToString());
var changeLogsRaw = File.ReadAllText("changelog.json");
}
private IEnumerable <object> LoadTypeReaders(Assembly assembly)
{
Type[] allTypes;
try
{
allTypes = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
Log.Warning(ex.LoaderExceptions[0], "Error getting types");
return(Enumerable.Empty <object>());
}
var filteredTypes = allTypes
.Where(x => x.IsSubclassOf(typeof(TypeReader)) &&
x.BaseType.GetGenericArguments().Length > 0 &&
!x.IsAbstract);
var toReturn = new List <object>();
foreach (var ft in filteredTypes)
{
var x = (TypeReader)Activator.CreateInstance(ft, Client, CommandService);
var baseType = ft.BaseType;
var typeArgs = baseType.GetGenericArguments();
CommandService.AddTypeReader(typeArgs[0], x);
toReturn.Add(x);
}
return(toReturn);
}
public void Initialize()
{
_discord.MessageReceived += HandleCommandAsync;
_commands.CommandExecuted += OnCommandExecutedAsync;
_commands.AddTypeReader <GuildUserProxy>(new GuildUserProxyTypeReader());
}
public async Task StartAsync()
{
_discordClient.MessageReceived += OnMessageReceivedAsync;
_commandService.AddTypeReader(typeof(int), new IntTypeReader());
await _commandService.AddModulesAsync(Assembly.GetEntryAssembly(), _serviceProvider);
}
