private async void CheckForTimeout(object?state)
{
if (timerRunning)
{
return;
}
timerRunning = true;
try
{
using (var waitingListDataContext = new WaitingListDataContext())
{
foreach (var invitedUser in waitingListDataContext.InvitedUsers
.Include(iu => iu.User).ThenInclude(iu => iu.Guild).Include(iu => iu.Invite).ToList())
{
if (invitedUser.InviteAccepted == null)
{
if (invitedUser.InviteTime + TimeSpan.FromMinutes(1) < DateTime.Now)
{
var guild = client.GetGuild(invitedUser.User.Guild.GuildId);
if (guild != null)
{
var waitingList = new CommandWaitingList(waitingListDataContext !, client.Rest, guild.Id);
try
{
await DeclineInviteAsync(client.Rest, guild, waitingList, invitedUser);
var dmChannel = await(await client.Rest.GetUserAsync(invitedUser.User.UserId)).CreateDMChannelAsync();
var message = await dmChannel.GetMessageAsync(invitedUser.DmQuestionMessageId);
await message.DeleteAsync();
await dmChannel.SendMessageAsync("Time ran out. Invite has been declined");
}
catch (Exception ex)
{
logger.LogError("Error declining invite", ex);
}
waitingListDataContext.Update(invitedUser);
waitingListDataContext.SaveChanges();
await CommandWaitingListModule.UpdateInviteMessageAsync(guild, invitedUser.Invite);
}
}
}
}
}
}
catch (Exception ex)
{
logger.LogError(ex, "Timeout timer failed to run");
}
timerRunning = false;
}
protected override void AfterExecute(CommandInfo command)
{
dataContext.SaveChanges();
dataContext.Dispose();
base.AfterExecute(command);
}
public async Task <(CommandResult commandResult, Invite?invite)> GetInvite(string[] arguments, int numberOfPlayers, ulong?inviteRole = null, bool?isInviteRolePositive = null, bool removeFromList = true)
{
IAsyncEnumerable <UserInGuild> asyncList = guildData.GetSortedList().ToAsyncEnumerable();
if (inviteRole is ulong roleId)
{
asyncList = asyncList.WhereAwait(async x =>
{
var restGuildUser = await restClient.GetGuildUserAsync(guildId, x.UserId);
var hasRole = restGuildUser.RoleIds.Contains(roleId);
return(hasRole == isInviteRolePositive);
});
}
var list = await asyncList.ToListAsync();
if (list.Count < numberOfPlayers)
{
return(CommandResult.FromError($"Did not send invites. There are only {list.Count} players in the list."), null);
}
string message;
try
{
message = string.Format(guildData.DMMessageFormat, arguments);
}
catch (Exception)
{
return(CommandResult.FromError("The arguments had the wrong format"), null);
}
var invite = new Invite
{
FormatData = arguments,
Guild = guildData,
InvitedUsers = new List <InvitedUser>(),
InviteTime = DateTime.Now,
NumberOfInvitedUsers = numberOfPlayers,
InviteRole = inviteRole,
IsInviteRolePositive = isInviteRolePositive
};
dataContext.Invites.Add(invite);
dataContext.SaveChanges();
StringBuilder warnings = new StringBuilder();
// Send invites
for (int i = 0; i < numberOfPlayers; i++)
{
var player = list[i];
player.IsInWaitingList = false;
player.PlayCount++;
dataContext.Update(player);
dataContext.SaveChanges();
var restGuildUser = await restClient.GetGuildUserAsync(guildId, player.UserId);
try
{
ComponentBuilder componentBuilder = new ComponentBuilder();
componentBuilder.WithButton("Yes", customId: $"joinYes;{invite.Id}");
componentBuilder.WithButton("No", customId: $"joinNo;{invite.Id}");
var userMessage = await restGuildUser.SendMessageAsync($"Are you ready to join? You have 1 minute to respond.", component : componentBuilder.Build());
InvitedUser invitedUser = new InvitedUser
{
Invite = invite,
InviteTime = DateTime.Now,
DmQuestionMessageId = userMessage.Id,
User = player
};
dataContext.InvitedUsers.Add(invitedUser);
}
catch (Exception ex)
{
warnings.AppendLine($"Could not invite {restGuildUser?.Mention ?? player.Name}. Exception: {ex.Message}");
}
}
this.dataContext.Update(invite);
await this.dataContext.SaveChangesAsync();
return(CommandResult.FromSuccess("Players have been invited." + (warnings.Length > 0 ? "\r\n" + warnings.ToString() : "")), invite);
}
private async Task Client_InteractionCreated(SocketInteraction arg)
{
try
{
using (var waitingListDataContext = new WaitingListDataContext())
{
if (arg.Type == InteractionType.MessageComponent)
{
var parsedArg = (SocketMessageComponent)arg;
var customId = parsedArg.Data.CustomId;
var guild = (parsedArg.Channel as IGuildChannel)?.Guild;
var guildData = guild != null?waitingListDataContext.GetGuild(guild.Id) : null;
var waitingList = guild != null ? new CommandWaitingList(waitingListDataContext, client.Rest, guild.Id) : null;
if (arg.User.IsBot)
{
return;
}
if (parsedArg.Message.Id == guildData?.PublicMessageId)
{
if (guild == null || guildData == null)
{
logger.LogCritical("Guild or guildData was null in InteractionCreated");
return;
}
if (customId == "join")
{
if ((await waitingList !.AddUserAsync((IGuildUser)parsedArg.User)).Success)
{
// await parsedArg.RespondAsync("Joined Waiting list.", ephemeral: true);
}
else
{
// await arg.RespondAsync("Failed");
logger.LogError("Failed to join " + parsedArg.User);
}
}
else if (customId == "leave")
{
await waitingList !.RemoveUserAsync(parsedArg.User.Id);
//await parsedArg.RespondAsync("Left waiting list.", ephemeral: true);
}
waitingListDataContext.SaveChanges();
guildData = waitingListDataContext.GetGuild(guild.Id);
await ButtonWaitingListModule.UpdatePublicMessageAsync(waitingList !, guild !, guildData);
await parsedArg.AcknowledgeAsync();
}
else
{
if (customId == "unpause")
{
guildData !.IsPaused = false;
waitingListDataContext.Update(guildData);
waitingListDataContext.SaveChanges();
await ButtonWaitingListModule.UpdatePublicMessageAsync(waitingList, guild !, guildData);
await parsedArg.AcknowledgeAsync();
await parsedArg.Message.DeleteAsync();
}
else if (customId == "clearcounters")
{
foreach (var user in guildData !.UsersInGuild)
{
user.PlayCount = 0;
waitingListDataContext.Update(user);
}
waitingListDataContext.SaveChanges();
await ButtonWaitingListModule.UpdatePublicMessageAsync(waitingList !, guild !, guildData);
await parsedArg.RespondAsync("Counters have been cleared");
}
else if (customId.StartsWith("joinYes") || customId.StartsWith("joinNo"))
{
var parts = customId.Split(new[] { ';' }, 2);
var inviteId = int.Parse(parts[1]);
var invite = waitingListDataContext.Invites.Include(i => i.Guild).Include(i => i.InvitedUsers).ThenInclude(iu => iu.User).Single(i => i.Id == inviteId);
var invitedUser = invite.InvitedUsers.Last(x => x.User.UserId == parsedArg.User.Id);
guildData = invite.Guild;
waitingList = new CommandWaitingList(waitingListDataContext !, client.Rest, guildData.GuildId);
guild = client.GetGuild(guildData.GuildId);
if (invitedUser.InviteAccepted != null)
{
return;
}
if (parts[0] == "joinYes")
{
await parsedArg.Message.DeleteAsync();
await parsedArg.Channel.SendMessageAsync(string.Format(guildData.DMMessageFormat, invite.FormatData));
invitedUser.InviteAccepted = true;
waitingListDataContext.Update(invitedUser);
waitingListDataContext.SaveChanges();
await CommandWaitingListModule.UpdateInviteMessageAsync(guild, invite);
}
else
{
await parsedArg.Message.DeleteAsync();
await parsedArg.Channel.SendMessageAsync("Invite has been declined");
await DeclineInviteAsync(client.Rest, guild, waitingList, invitedUser);
waitingListDataContext.Update(invitedUser);
waitingListDataContext.SaveChanges();
await CommandWaitingListModule.UpdateInviteMessageAsync(guild, invite);
}
}
}
}
}
}
