private static async Task <Embed> BuildServerInfoEmbed(Server server, IDiscordClient client)
{
var ManualOrLaunched = server.IsManualServer ? " `📃Manual server`" : " `🚀Launched server`";
var serverInfo = server.ServerInfo;
var random = new Random();
var color = new Color(random.Next(255), random.Next(255), random.Next(255));
var user = await client.GetUserAsync(server.ServerInfo.OwnerId);
var username = user == null ? "Missing" : user.Username;
var Icon = user == null ? "" : user.GetAvatarUrl();
var builder = new EmbedBuilder()
.WithTitle(serverInfo.ServerName + ManualOrLaunched)
.WithDescription(serverInfo.Description)
.WithColor(color)
.WithImageUrl(serverInfo.Config.ThumbnailURL)
.WithAuthor(author =>
{
author.WithName(username);
author.IconUrl = Icon;
})
.AddField("Game:", serverInfo.Config.GameType)
.AddField("Version:", serverInfo.Config.GameVersion)
.AddField("Server IP:", serverInfo.ServerIP);
return(builder.Build());
}
public CommandServiceWrapper(IDiscordClient client, ILogger <CommandService> logger,
IOptions <CommandServiceConfig> cmdServiceConfig, IConfiguration config) : base(cmdServiceConfig.Value)
{
if (ulong.TryParse(config["LoggingChannelId"], out var loggingChannelId))
{
var channel = (IMessageChannel)client.GetChannelAsync(loggingChannelId).Result;
Log += async message =>
{
if (message.Exception is CommandException commandException)
{
await channel.SendMessageAsync(
$"```{commandException.Message}\n{commandException.InnerException}```");
}
};
}
Log += message =>
{
logger.Log(
(LogLevel)Math.Abs((int)message.Severity - 5),
eventId: 0,
message,
message.Exception,
delegate { return(message.ToString()); });
return(Task.CompletedTask);
};
}
public MessageHandler(IDiscordClient client, CommandService commandService, ILogger <MessageHandler> logger, IHotKeyHandler hotKeyHandler)
{
_client = client;
_commandService = commandService;
_logger = logger;
_hotKeyHandler = hotKeyHandler;
}
public MessageRewardService(IDiscordClient client, IBotConfigurationService config, JsonDatabaseService db, LoggingService logger)
{
m_client = client as DiscordSocketClient;
m_config = config;
m_db = db;
m_logger = logger;
}
public RandomlySendMessageBehavior(BotConfig config, IDiscordClient client, ILogger <RandomlySendMessageBehavior> logger, RandomlyConfig randomlyConfig)
{
_globalConfig = config;
_client = client as DiscordSocketClient;
_logger = logger;
_config = randomlyConfig;
}
public SegmentEditReactionHandler(IDiscordClient client, TicTacZapController ticTacZapController, ISegmentRepository segmentRepository, IInventoryRepository inventoryRepository)
{
_client = client;
_ticTacZapController = ticTacZapController;
_segmentRepository = segmentRepository;
_inventoryRepository = inventoryRepository;
}
public LogChannelService(IDiscordClient client, EmbedService embed, ILogger logger, IDataStore data)
{
_client = client;
_embed = embed;
_data = data;
_logger = logger.ForContext <LogChannelService>();
}
public GiveawayService(JsonDatabaseService db, IDiscordClient client, IBotConfigurationService config, SchedulerService scheduler)
{
m_db = db;
m_client = client;
m_config = config;
m_scheduler = scheduler;
}
public CommandModuleBase(IDiscordClient discordClient, IDiscordBot discordBot, IServiceProvider serviceProvider, IBotConfiguration botConfiguration)
{
DiscordClient = discordClient;
DiscordBot = discordBot;
BotConfiguration = botConfiguration;
ServiceProivder = serviceProvider;
}
/// <summary>
/// Creates a new <see cref="ModerationService"/>, with the given injected dependencies.
/// </summary>
public ModerationService(
IDiscordClient discordClient,
IAuthorizationService authorizationService,
IChannelService channelService,
IUserService userService,
IModerationActionRepository moderationActionRepository,
IDesignatedRoleMappingRepository designatedRoleMappingRepository,
IInfractionRepository infractionRepository,
IDeletedMessageRepository deletedMessageRepository,
IDeletedMessageBatchRepository deletedMessageBatchRepository,
IRoleService roleService,
IDesignatedChannelService designatedChannelService,
IDogStatsd stats = null)
{
DiscordClient = discordClient;
AuthorizationService = authorizationService;
ChannelService = channelService;
UserService = userService;
ModerationActionRepository = moderationActionRepository;
DesignatedRoleMappingRepository = designatedRoleMappingRepository;
InfractionRepository = infractionRepository;
DeletedMessageRepository = deletedMessageRepository;
DeletedMessageBatchRepository = deletedMessageBatchRepository;
RoleService = roleService;
DesignatedChannelService = designatedChannelService;
Stats = stats;
}
public ModerationService(
IDiscordClient discordClient,
IAuthorizationService authorizationService,
IChannelService channelService,
IUserService userService,
IModerationActionRepository moderationActionRepository,
IDesignatedRoleMappingRepository designatedRoleMappingRepository,
IInfractionRepository infractionRepository,
IDeletedMessageRepository deletedMessageRepository,
IDeletedMessageBatchRepository deletedMessageBatchRepository,
IRoleService roleService,
IDesignatedChannelService designatedChannelService,
IDogStatsd dogStatsd)
{
_discordClient = discordClient;
_authorizationService = authorizationService;
_channelService = channelService;
_userService = userService;
_moderationActionRepository = moderationActionRepository;
_designatedRoleMappingRepository = designatedRoleMappingRepository;
_infractionRepository = infractionRepository;
_deletedMessageRepository = deletedMessageRepository;
_deletedMessageBatchRepository = deletedMessageBatchRepository;
_roleService = roleService;
_designatedChannelService = designatedChannelService;
_dogStatsd = dogStatsd;
}
/// <summary>
/// Get the discord channel that is attached to the Facebook WebHook
/// </summary>
/// <param name="_discordClient">THe discord client</param>
/// <returns></returns>
public static async Task <IMessageChannel> GetFacebookFeedChannel(this IDiscordClient _discordClient)
{
// THe channel to post facebook-posts in
IMessageChannel channel = await _discordClient.GetChannelAsync(ulong.Parse(FacebookHook.FacebookHandler.Instance.FacebookFeedChannelID)) as IMessageChannel;
return(channel);
}
public static async Task Restore(MongoClient mongo, IDiscordClient client, SocketGuild guild)
{
var collection = mongo.GetCollection <Penalty>(client);
var penalties = await collection.GetPenaltiesAsync(guild.Id);
var newPenalties = new List <Penalty>();
if (penalties.All(p => p.PenaltyId != 1))
{
newPenalties.Add(new Penalty(guild.Id, 1, PenaltyType.Nothing, 1, autoDelete: true));
}
if (penalties.All(p => p.PenaltyId != 2))
{
newPenalties.Add(new Penalty(guild.Id, 2, PenaltyType.Warn, 3, autoDelete: true));
}
if (penalties.All(p => p.PenaltyId != 3))
{
newPenalties.Add(new Penalty(guild.Id, 3, PenaltyType.Kick, 5, autoDelete: true));
}
if (penalties.All(p => p.PenaltyId != 4))
{
newPenalties.Add(new Penalty(guild.Id, 4, PenaltyType.Ban, 6, autoDelete: true));
}
if (newPenalties.Any())
{
await collection.InsertManyAsync(newPenalties);
Logger.Info($"Added default penalties to guild {guild}");
}
}
/// <summary>
/// Check if user id exists.
/// </summary>
/// <param name="client">N/A</param>
/// <param name="userId">Id of user you want to check</param>
/// <returns>Name of user if exists otherwise returns "Unknown Role."</returns>
public static string CheckUser(this IDiscordClient client, ulong userId)
{
var clientDiscord = client as DiscordSocketClient;
var user = clientDiscord?.GetUser(userId);
return(user == null ? "Unknown User." : user.Username);
}
public DatadogRoutine(
AccountService accounts,
AchievementService achievements,
IAsyncEventingExecutor <IDiscordMessage> commandPipeline,
Config config,
IDiscordClient discordClient)
{
if (string.IsNullOrWhiteSpace(config.DatadogHost))
{
Log.Warning("Metrics are not being collected");
return;
}
DogStatsd.Configure(new StatsdConfig
{
StatsdServerName = config.DatadogHost,
StatsdPort = 8125,
Prefix = "miki"
});
CreateAchievementsMetrics(achievements);
CreateAccountMetrics(accounts);
CreateEventSystemMetrics(commandPipeline);
CreateDiscordMetrics(discordClient);
Log.Message("Datadog set up!");
}
/// <summary>
/// Sends the text to the specified guild's channel using a connected Discord client
/// </summary>
/// <param name="client">Connected Discord Client connection</param>
/// <param name="guildID">Id of the Discord guild</param>
/// <param name="channelID">Id of the Discord channel</param>
/// <param name="text">Text to post</param>
public static async Task <RestUserMessage> SendChannelMessageAsync(IDiscordClient client, ulong guildID, ulong channelID, string text, bool isTTS = false, Embed embed = null, RequestOptions options = null)
{
var guild = await(client?.GetGuildAsync(guildID)).ConfigureAwait(false);
var channel = await(guild?.GetChannelAsync(channelID)).ConfigureAwait(false) as SocketTextChannel;
return(await(channel?.SendMessageAsync(text, isTTS, embed, options)).ConfigureAwait(false));
}
/**
* -u = user's name
* -um = user's mention
* -s = server's name
* -o = owner's nickname
* -sc = server count
* -now = current time
* -uc = user count
*/
public LoggingModule(MikiApp app, IDiscordClient client, ISentryClient sentryClient = null)
{
this.app = app;
this.sentryClient = sentryClient;
client.Events.GuildMemberCreate.SubscribeTask(OnClientOnGuildMemberCreateAsync);
client.Events.GuildMemberDelete.SubscribeTask(OnClientOnGuildMemberDeleteAsync);
}
public static bool Check(IMessage message, AutoModerationConfig config, IDiscordClient _)
{
if (config.Limit == null)
{
return(false);
}
if (string.IsNullOrEmpty(config.CustomWordFilter))
{
return(false);
}
if (string.IsNullOrEmpty(message.Content))
{
return(false);
}
int matches = 0;
foreach (string word in config.CustomWordFilter.Split('\n'))
{
if (string.IsNullOrWhiteSpace(word))
{
continue;
}
try
{
matches += Regex.Matches(message.Content, word, RegexOptions.IgnoreCase).Count;
}
catch { }
if (matches > config.Limit)
{
break;
}
}
return(matches > config.Limit);
}
public async Task ExecuteCommandAsync(IDiscordClient client, SocketMessage socketMessage)
{
try
{
var command = GetCommand(socketMessage.Content);
var services = provider.GetServices <ICommandService>();
var filteredServices = services.Where(s => s.ImplementedCommands.Any(c => c.name == command)).ToArray();
var args = new ExecuteCommandArgs()
{
Command = command,
Client = client,
OurGuild = await client.GetGuildAsync(this.serverId),
Message = socketMessage
};
if (filteredServices.Length == 0)
{
args.IsCustom = true;
filteredServices = services.Where(s => s.CanExecuteCustomCommand).ToArray();
}
await Task.WhenAll(filteredServices.Select(s => s.ExecuteCommand(args)).ToArray());
}
catch (Exception ex)
{
(socketMessage.Channel as IMessageChannel)?.SendMessageAsync($"Произошла ошибка: {ex.Message}");
}
}
public AuthorizationService(IServiceProvider serviceProvider, IDiscordClient discordClient, IClaimMappingRepository claimMappingRepository)
{
DiscordClient = discordClient;
// Workaround for circular dependency.
_lazyUserService = new Lazy <IUserService>(() => serviceProvider.GetRequiredService <IUserService>());
ClaimMappingRepository = claimMappingRepository;
}
public AccountsModule(
MikiApp app,
Config config,
IDiscordClient discordClient,
AccountService accountsService,
AchievementService achievementService,
AchievementEvents achievementEvents,
TransactionEvents transactionEvents)
{
this.app = app;
this.achievementService = achievementService;
this.discordClient = discordClient;
if (!string.IsNullOrWhiteSpace(config.ImageApiUrl))
{
client = new HttpClient(config.ImageApiUrl);
}
else
{
Log.Warning("Image API can not be loaded in AccountsModule");
}
discordClient.Events.MessageCreate.SubscribeTask(OnMessageCreateAsync);
accountsService.OnLocalLevelUp += OnUserLevelUpAsync;
accountsService.OnLocalLevelUp += OnLevelUpAchievementsAsync;
transactionEvents.OnTransactionComplete += CheckCurrencyAchievementUnlocksAsync;
achievementEvents.OnAchievementUnlocked
.SubscribeTask(SendAchievementNotificationAsync);
achievementEvents.OnAchievementUnlocked
.SubscribeTask(CheckAchievementUnlocksAsync);
}
public async Task OnMessageDeleteEvent(MessageDeleteEvent e, IDiscordClient client)
{
if (!e.GuildId.HasValue)
{
return;
}
var channelId = await _consoleService.GetChannelId(e.GuildId.Value);
if (e.ChannelId != channelId)
{
return;
}
var warning = await _warningRepository.GetWarningByMessageId(e.GuildId.Value, e.MessageId);
if (warning == null)
{
return;
}
warning.ConsoleMessageId = null;
warning.ConsoleChannelId = null;
await _warningRepository.UpdateAsync(warning);
var user = await client.GetUserAsync(warning.UserId);
var moderator = await client.GetUserAsync(warning.ModeratorId);
await _consoleService.UpdateWarningMessageAsync(e.GuildId.Value, e.ChannelId, warning, user, moderator);
}
public EvalService(SendingService sender, DiscordSocketClient client,
IMongoDatabase db)
{
_sender = sender;
_client = client;
_db = db;
}
/// <summary>
/// Constructs a new <see cref="ModerationLoggingBehavior"/> object, with injected dependencies.
/// </summary>
public ModerationLoggingBehavior(IServiceProvider serviceProvider, IDiscordClient discordClient, IDesignatedChannelService designatedChannelService)
{
DiscordClient = discordClient;
DesignatedChannelService = designatedChannelService;
_lazyModerationService = new Lazy <IModerationService>(() => serviceProvider.GetRequiredService <IModerationService>());
}
/// <summary>
/// Constructs a new <see cref="PromotionLoggingHandler"/> object, with injected dependencies.
/// </summary>
public PromotionLoggingHandler(IServiceProvider serviceProvider, IDiscordClient discordClient, IDesignatedChannelService designatedChannelService)
{
DiscordClient = discordClient;
DesignatedChannelService = designatedChannelService;
_lazyPromotionsService = new Lazy <IPromotionsService>(() => serviceProvider.GetRequiredService <IPromotionsService>());
}
/// <summary>
/// Constructs a new <see cref="UserService"/> with the given injected dependencies.
/// </summary>
/// <param name="discordClient">The value to use for <see cref="DiscordClient"/>.</param>
/// <param name="authorizationService">The value to use for <see cref="AuthorizationService"/>.</param>
/// <param name="guildService">The value to use for <see cref="GuildService"/>.</param>
/// <param name="userRepository">The value to use for <see cref="UserRepository"/>.</param>
/// <exception cref="ArgumentNullException">Throws for all parameters.</exception>
public UserService(IDiscordClient discordClient, IAuthorizationService authorizationService, IGuildService guildService, IUserRepository userRepository)
{
DiscordClient = discordClient ?? throw new ArgumentNullException(nameof(discordClient));
AuthorizationService = authorizationService ?? throw new ArgumentNullException(nameof(authorizationService));
GuildService = guildService ?? throw new ArgumentNullException(nameof(guildService));
UserRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
}
public static string CheckUser(IDiscordClient client, ulong UserId)
{
var Client = client as DiscordSocketClient;
var User = Client.GetUser(UserId);
return(User == null ? "Unknown User." : User.Username);
}
public AdminList(IDiscordClient client)
{
_admins = new HashSet <User>(new UserEqualityComparer());
_client = client;
_lock = new object();
Message = "Admin list not initialized.";
}
public LogChannelService(IDiscordClient client, DbConnectionFactory conn, EmbedService embed, ILogger logger)
{
this._client = client;
this._conn = conn;
this._embed = embed;
_logger = logger.ForContext <LogChannelService>();
}
async Task NotifyAsync(IDiscordClient client, SyncDbContext db, CancellationToken cancellationToken = default)
{
var time = DateTimeOffset.UtcNow;
while (true)
{
var notifications = await db.Notifications.Include(n => n.User).Where(n => n.Time <= time).OrderBy(n => n.Time).Take(50).ToListAsync(cancellationToken);
if (notifications.Count == 0)
{
break;
}
await Task.WhenAll(notifications.Select(async notification =>
{
try
{
await SendAsync(client, notification);
}
catch (Exception e)
{
_logger.LogWarning(e, $"Could not send notification '{notification.Key}' to user {notification.User.DiscordUserId}.");
}
}));
db.RemoveRange(notifications);
await db.SaveChangesAsync(cancellationToken);
_logger.LogInformation($"Removed {notifications.Count} notifications from queue.");
}
}
private async Task SetupAsync(IDiscordClient client)
{
this._client = client;
foreach (var server in await client.GetGuildsAsync())
{
timedoutUsers.Add(server.Id, new List<TimedoutUser>());
}
}
public Timeout(IDiscordClient client)
{
SetupAsync(client).Wait();
}
