public async IAsyncEnumerable <Message> GetMessages(DiscordServerContext server, ChannelContext channel, int limit, ulong fromMessageId = 0, bool goBefore = true) { var textChannel = (ITextChannel)this.GetChannel(channel.Id, server.Id); if (!await this.CanBotReadTheChannelAsync(textChannel)) { yield break; } var channelMessages = fromMessageId == 0 ? textChannel.GetMessagesAsync(limit) : textChannel.GetMessagesAsync(fromMessageId, goBefore ? Direction.Before : Direction.After, limit); await foreach (var message in channelMessages.Flatten()) { var user = this._userContextsFactory.Create(message.Author); var contexts = new Contexts(server, channel, user); DiscordRequest request; try { request = this._commandParser.Parse(message.Content, message.Timestamp.UtcDateTime); } catch // should almost never go to catch block, but in rare cases Parse() can throw an exception { request = new DiscordRequest { OriginalMessage = message.Content, SentAt = message.Timestamp.UtcDateTime }; } yield return(new Message(message.Id, request, contexts)); } }
public Task AddRole(UserRole role, UserContext user, DiscordServerContext server) { var socketUser = GetUser(user, server); var socketRole = GetRole(role.Id, server); return(socketUser.AddRoleAsync(socketRole)); }
public Task RemoveRole(UserRole role, UserContext user, DiscordServerContext server) { var socketUser = this.GetRestUser(user, server); var socketRole = this.GetRole(role.Id, server); return(socketUser.RemoveRoleAsync(socketRole)); }
private MuteEvent GetNotUnmutedUserMuteEvent(DiscordServerContext server, UserContext userContext) { var userMuteEvents = GetMuteEvents(server, userContext.Id); // in the same time there should exists only one MUTED MuteEvent per user per server return(userMuteEvents.FirstOrDefault(x => x.Unmuted == false)); }
public async Task RemoveRoleAsync(UserRole role, UserContext user, DiscordServerContext server) { var socketUser = await this.GetRestUser(user, server); var socketRole = this.GetRole(role.Id, server); await socketUser.RemoveRoleAsync(socketRole); }
public async Task GenerateStatsForDaysBefore(DiscordServerContext server, DateTime?lastInitDate) { var dayStatisticsQuery = new GetServerDayStatisticsQuery(server.Id); var allServerDaysStatistics = (await this._queryBus.ExecuteAsync(dayStatisticsQuery)).ServerDayStatistics.ToList(); var startDate = lastInitDate ?? DateTime.UnixEpoch; var messagesQuery = new GetMessagesQuery(server.Id) { SentDate = new TimeRange(startDate, DateTime.Today) // it will exclude today - it should generate today's stats tomorrow }; var messages = this._queryBus.Execute(messagesQuery).Messages; var messagesNotCachedForStats = messages .Where(message => allServerDaysStatistics.All(s => message.SentAt.Date != s.Date)); var serverStatistics = messagesNotCachedForStats .GroupBy(x => x.SentAt.Date) .Select(x => new ServerDayStatistic(x.ToList(), server.Id, x.Key)); var commands = serverStatistics.Select(x => new AddServerDayStatisticCommand(x)); foreach (var command in commands) { await this._commandBus.ExecuteAsync(command); } }
public async IAsyncEnumerable <Message> ReadMessagesAsync(DiscordServerContext server, ChannelContext channelContext, int limit) { await foreach (var message in Server.GetMessages(server, channelContext, limit)) { yield return(message); } }
public void UnmuteUsersInit(DiscordServerContext server) { var users = this._usersService.GetUsers(server).ToList(); var muteRole = this._usersRolesService.GetRoleByName(UsersRolesService.MUTED_ROLE_NAME, server); if (!users.Any() || muteRole == null) { return; } var query = new GetMuteEventsQuery(server.Id); var notUnmutedEvents = this._queryBus.Execute(query).MuteEvents .Where(x => x.Unmuted == false) .ToList(); foreach (var muteEvent in notUnmutedEvents) { if (muteEvent.TimeRange.End < DateTime.UtcNow) { this.RemoveMuteRole(muteEvent, server, users, muteRole); } else { this.RemoveInFuture(muteEvent, server, users, muteRole); } } }
public UserContext GetUserByMention(DiscordServerContext server, string mention) { var user = this.GetUsers(server) .FirstOrDefault(x => x.Mention == mention); return(user); }
private List <Message> ReadMessages(DiscordServerContext server, ChannelContext channel, int limit, ulong lastMessageId = 0) { var messages = lastMessageId == 0 ? this._messagesHistoryService.ReadMessagesAsync(server, channel, limit).Result.ToList() : this._messagesHistoryService.ReadMessagesAsync(server, channel, limit, lastMessageId, goBefore: true).Result.ToList(); return(messages); }
public Task SetRolePermissions(ChannelContext channel, DiscordServerContext server, ChangedPermissions permissions, UserRole role) { Log.Information("Setting role {roleName} for {channel}", role.Name, channel.Name); var channelPermissions = new OverwritePermissions(permissions.AllowPermissions?.GetRawValue() ?? 0, permissions.DenyPermissions?.GetRawValue() ?? 0); var socketRole = this.GetSocketRole(server, role); return(this.SetRolePermissions(channel, server, channelPermissions, socketRole)); }
public MuteEvent GetNotUnmutedMuteEvent(DiscordServerContext server, UserContext userContext) { var getMuteEvents = new GetMuteEventsQuery(server.Id); var allServerMuteEvents = _queryBus.Execute(getMuteEvents).MuteEvents; var userMuteEvents = allServerMuteEvents.Where(x => x.UserId == userContext.Id); return(userMuteEvents.FirstOrDefault(x => x.Unmuted == false)); }
private async Task ReadServerMessagesHistory(DiscordServerContext server, DateTime lastInitDate) { foreach (var textChannel in server.GetTextChannels()) { await this._serverScanningService.ScanChannelHistory(server, textChannel, lastInitDate); } Log.Information("Read messages history: {server}", server.Name); }
private string GetExampleArgument(ArgumentInformation argumentInformation, DiscordServerContext server) { var exampleValue = this.GetExampleValue(argumentInformation, server); return(string.IsNullOrWhiteSpace(exampleValue) ? argumentInformation.Name.ToLowerInvariant() : $"{argumentInformation.Name.ToLowerInvariant()} {exampleValue}"); }
public async Task InitForServer(DiscordServerContext server) { var changedPermissions = this.CreateChangedPermissions(); var mutedRole = this.CreateMuteRole(changedPermissions.AllowPermissions); var createdRole = await this.SetRoleToServer(server, mutedRole); await this.SetChannelsPermissions(server, createdRole, changedPermissions); }
public async Task RemoveRolePermissions(ChannelContext channel, DiscordServerContext server, UserRole role) { Log.Information("Removing role {roleName} for {channel}", role.Name, channel.Name); var socketRole = this.GetSocketRole(server, role); var guild = this._client.GetGuild(server.Id); var channelSocket = (IGuildChannel)await this.GetChannel(channel.Id, guild); await channelSocket.RemovePermissionOverwriteAsync(socketRole); }
public IEnumerable <UserContext> GetUsers(DiscordServerContext server) { var guildUsers = Server.GetGuildUsers(server.Id).Result; var userContextFactory = new UserContextsFactory(); var userContexts = guildUsers.Select(x => userContextFactory.Create(x)); return(userContexts); }
public async IAsyncEnumerable <UserContext> GetUsersAsync(DiscordServerContext server) { var guildUsers = Server.GetGuildUsers(server.Id); await foreach (var user in guildUsers) { yield return(this._userContextsFactory.Create(user)); } }
private async Task UnmuteUser(UserContext mutedUser, MuteEvent muteEvent, DiscordServerContext serverContext) { var muteRole = GetMuteRole(serverContext); await RemoveMuteRoleAsync(muteRole, mutedUser, serverContext); await MarkAsUnmuted(muteEvent); Log.Information("User {user} has been unmuted on server {server}", mutedUser.ToString(), serverContext.Name); }
private IEnumerable <MuteEvent> GetMuteEvents(DiscordServerContext server, ulong userId) { var getMuteEvents = new GetMuteEventsQuery(server.Id); var allServerMuteEvents = _queryBus.Execute(getMuteEvents).MuteEvents; var userMuteEvents = allServerMuteEvents.Where(x => x.UserId == userId); return(userMuteEvents); }
public Task InitForServer(DiscordServerContext server) { var changedPermissions = CreateChangedPermissions(); var mutedRole = CreateMuteRole(changedPermissions.AllowPermissions); var createdRole = SetRoleToServer(server, mutedRole); SetChannelsPermissions(server, createdRole, changedPermissions); return(Task.CompletedTask); }
private UserRole GetMuteRole(DiscordServerContext server) { var muteRole = _usersRolesService.GetRoleByName(UsersRolesService.MUTED_ROLE_NAME, server); if (muteRole == null) { throw new RoleNotFoundException(UsersRolesService.MUTED_ROLE_NAME); } return(muteRole); }
private SocketRole GetSocketRole(DiscordServerContext server, UserRole role) { var socketRole = Server.GetSocketRoles(server.Id).FirstOrDefault(x => x.Id == role.Id); if (socketRole == null) { Log.Error("Role {roleName} was null", role.Name); } return(socketRole); }
private async Task MuteRoleInit(DiscordServerContext server) { var mutedRole = _usersRolesService.GetRoleByName(UsersRolesService.MUTED_ROLE_NAME, server); if (mutedRole == null) { await _muteRoleInitService.InitForServer(server); } Log.Information($"Mute role initialized: {server.Name}"); }
public async Task <UserContext> GetUserByIdAsync(DiscordServerContext server, ulong userId) { var user = await Server.GetGuildUser(userId, server.Id); if (user == null) { Log.Warning("Cannot get user by id {userId}", userId); return(null); } return(this._userContextsFactory.Create(user)); }
public async Task InitForServer(DiscordServerContext server) { var mutedRole = this._usersRolesService.GetRoleByName(UsersRolesService.MUTED_ROLE_NAME, server); var changedPermissions = this.CreateChangedPermissions(); if (mutedRole == null) { var createdMutedRole = this.CreateMuteRole(changedPermissions.AllowPermissions); mutedRole = await this.SetRoleToServer(server, createdMutedRole); } await this.SetChannelsPermissions(server, mutedRole, changedPermissions); }
public async Task InitServer(DiscordServerContext server) { await MuteRoleInit(server); var lastInitDate = GetLastInitDate(server); await ReadServerMessagesHistory(server, lastInitDate); await _cyclicStatisticsGeneratorService.GenerateStatsForDaysBefore(server, lastInitDate); await NotifyDomainAboutInit(server); }
public async Task <UserRole> CreateNewRole(NewUserRole role, DiscordServerContext discordServer) { var permissionsValue = role.Permissions.GetRawValue(); var guild = await this._restClient.GetGuildAsync(discordServer.Id); var restRole = await guild.CreateRoleAsync(role.Name, new GuildPermissions(permissionsValue), isMentionable : false); var userRole = new UserRoleFactory().Create(restRole); return(userRole); }
public async Task <bool> UnmuteIfNeeded(DiscordServerContext server, UserContext userToUnmute) { var userMuteEvents = GetMuteEvents(server, userToUnmute.Id); var eventToUnmute = GetNotUnmutedEvent(userMuteEvents); if (eventToUnmute == null) { return(false); } await UnmuteUser(userToUnmute, eventToUnmute, server); return(true); }
public async Task InitServer(DiscordServerContext server) { Log.Information("Initializing server: {server}", server.ToJson()); await this.MuteRoleInit(server); var lastInitDate = this.GetLastInitDate(server); await this.ReadServerMessagesHistory(server, lastInitDate); await this.NotifyDomainAboutInit(server); Log.Information("Done server: {server}", server.ToJson()); }