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());
}
