public async Task Update(
[Name("Queue name")] string queueName,
[Remainder, Name("Operator flags")] string operators = "")
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
var queue = await _listCommandService.UpdateOperators(queueName, operators, (SocketGuildUser)Context.User);
if (queue == null)
{
await Context.Channel.SendMessageAsync(
$"`Queue with the name '{queueName}' doesn't exists!`",
messageReference : new MessageReference(Context.Message.Id))
.AutoRemoveMessage(10);
return;
}
await Context.Channel
.SendMessageAsync($"`Queue '{queue.Name}' was updated by {PickupHelpers.GetNickname(Context.User)}`");
}
public async Task Subscribe()
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
var role = Context.Guild.Roles.FirstOrDefault(w => w.Name == RoleNames.PickupPromote);
if (role == null)
{
return; //Failed to get or create role;
}
var user = (IGuildUser)Context.User;
if (user.RoleIds.Any(w => w == role.Id))
{
await user.RemoveRoleAsync(role);
await Context.Message.ReplyAsync($"{PickupHelpers.GetMention(user)} - you are no longer subscribed to get notifications on `!promote`")
.AutoRemoveMessage(10);
}
else
{
await user.AddRoleAsync(role);
await Context.Message.ReplyAsync(
$"{PickupHelpers.GetMention(user)} - you are now subscribed to get notifications on `!promote`")
.AutoRemoveMessage(10);
}
}
public async Task Accept(IGuildUser challenger)
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel))
{
return;
}
_logger.LogInformation($"{nameof(Accept)} called for user '{challenger.Username}'");
var challenge = await _duelChallengeRepository.Find(challenger, (IGuildUser)Context.User);
if (challenge != null)
{
//On accept start match
await _duelChallengeRepository.Delete(challenge);
var match = new DuelMatch(Context.Guild.Id, challenger.Id, Context.User.Id)
{
Started = true,
ChallengeDate = challenge.ChallengeDate,
MatchDate = DateTime.UtcNow
};
await _duelMatchRepository.Save(match);
await ReplyAsync($"{Context.User.Mention} has accepted the challenge from {challenger.Mention}!");
}
}
public async Task <PickupQueue> Leave(PickupQueue queue, ISocketMessageChannel channel, IGuildUser user, bool notify = true)
{
var guild = (SocketGuild)user.Guild;
var subscriber = queue.Subscribers.FirstOrDefault(s => s.Id == user.Id);
if (subscriber != null)
{
queue.Updated = DateTime.UtcNow;
queue.Subscribers.Remove(subscriber);
await MoveUserFromWaitingListToSubscribers(queue, subscriber, channel, guild);
if (!queue.Subscribers.Any() && !queue.WaitingList.Any())
{
notify = await _listCommandService.DeleteEmptyQueue(queue, guild, channel, notify);
}
else
{
queue = await _listCommandService.SaveStaticQueueMessage(queue, guild);
await _queueRepository.UpdateQueue(queue);
queue = await _queueRepository.FindQueue(queue.Name, queue.GuildId);
}
}
if (notify)
{
await channel.SendMessageAsync($"`{queue.Name} - {PickupHelpers.ParseSubscribers(queue)}`").AutoRemoveMessage(10);
}
return(queue);
}
private static async Task MoveUserFromWaitingListToSubscribers(PickupQueue queue, Subscriber subscriber, ISocketMessageChannel channel, SocketGuild guild)
{
if (queue.WaitingList.Any())
{
var next = queue.WaitingList.First();
queue.WaitingList.RemoveAt(0);
queue.Subscribers.Add(next);
var nextUser = guild.GetUser(next.Id);
if (nextUser != null)
{
await channel.SendMessageAsync($"{PickupHelpers.GetMention(nextUser)} - you have been added to '{queue.Name}' since {subscriber.Name} has left.").AutoRemoveMessage();
if (queue.Started)
{
var team = queue.Teams.FirstOrDefault(w => w.Subscribers.Exists(s => s.Id == subscriber.Id));
if (team != null)
{
team.Subscribers.Remove(team.Subscribers.Find(s => s.Id == subscriber.Id));
team.Subscribers.Add(new Subscriber {
Name = PickupHelpers.GetNickname(nextUser), Id = nextUser.Id
});
await channel.SendMessageAsync($"{PickupHelpers.GetMention(nextUser)} - you are on the {team.Name}")
.AutoRemoveMessage()
;
}
}
await PickupHelpers.NotifyUsers(queue, guild.Name, nextUser);
}
}
}
public async Task Loss(IGuildUser opponent)
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel) || opponent.Id == Context.User.Id)
{
return;
}
var matches = (await _duelMatchRepository.FindByChallengerIdOrChallengeeId((IGuildUser)Context.User)).ToList();
matches = matches.Where(w => IsValidMatch(w, opponent)).ToList();
if (matches.Any())
{
var match = matches.First();
if (!string.IsNullOrEmpty(match.WinnerId))
{
await ReplyAsync($"{match.LooserName} has lost against {match.WinnerName}").AutoRemoveMessage(10);
return;
}
;
var winner = await _duelPlayerRepository.Find(opponent);
var looser = await _duelPlayerRepository.Find((IGuildUser)Context.User);
await UpdateMatchAndMMR(winner, looser, match);
}
}
public async Task Rename([Name("Queue name")] string queueName, [Name("New name")] string newName)
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
newName = newName.Trim(' ', '"').Trim();
var queue = await _miscCommandService.VerifyQueueByName(queueName, (IGuildChannel)Context.Channel);
if (queue == null)
{
return;
}
var isAdmin = (Context.User as IGuildUser)?.GuildPermissions.Has(GuildPermission.Administrator) ?? false;
if (isAdmin || queue.OwnerId == Context.User.Id.ToString())
{
var newQueueCheck = await _queueRepository.FindQueue(newName, Context.Guild.Id.ToString());
if (newQueueCheck != null)
{
await Context.Message.ReplyAsync($"`A queue with the name '{newName}' already exists.`").AutoRemoveMessage(10);
return;
}
var newQueue = (PickupQueue)queue.Clone();
newQueue.RowKey = newName.ToLowerInvariant();
newQueue.Name = newName;
var result = await _queueRepository.AddQueue(newQueue);
if (result)
{
await _queueRepository.RemoveQueue(queue);
await Context.Message.ReplyAsync($"The queue '{queue.Name}' has been renamed to '{newQueue.Name}'");
await Context.Message.ReplyAsync($"`{newQueue.Name} - {PickupHelpers.ParseSubscribers(newQueue)}`");
if (!string.IsNullOrEmpty(queue.StaticMessageId))
{
await _listCommandService.SaveStaticQueueMessage(newQueue, Context.Guild);
}
return;
}
await Context.Message.ReplyAsync("An error occured when trying to update the queue name, try again.")
.AutoRemoveMessage(10);
}
else
{
await Context.Message.ReplyAsync("`You do not have permission to rename this queue, you have to be either the owner or a server admin`")
.AutoRemoveMessage(10);
}
}
public async Task ClientInfo(string player)
{
_logger.LogInformation("clientinfo called");
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
if (string.IsNullOrWhiteSpace(_rconPassword) || string.IsNullOrWhiteSpace(_rconHost) || _rconPort == 0)
{
return;
}
var userdata = await RCON.UDPSendCommand($"dumpuser {player}", _rconHost, _rconPassword, _rconPort).ConfigureAwait(false);
if (userdata.IndexOf("is not on the server", StringComparison.OrdinalIgnoreCase) != -1)
{
await Context.Message.ReplyAsync(
$"```{Environment.NewLine}" +
$"{userdata}" +
$"{Environment.NewLine}```");
return;
}
var clientInfo = new ClientInfo(userdata);
await Context.Message.ReplyAsync(
$"```{Environment.NewLine}" +
$"{clientInfo.ToTable()}" +
$"{Environment.NewLine}```");
}
public async Task Register([Name("skill level (low, medium, high)"), Remainder] string level = "")
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel))
{
return;
}
var duellistRole = await GetDuellistRole();
var skillLevel = Parse(level);
var user = (IGuildUser)Context.User;
_logger.LogInformation($"{nameof(Register)} called for user '{user.Username}' with skill level '{skillLevel}'");
var result = await _duelPlayerRepository.Save(user, Parse(level));
if (user.RoleIds.All(r => r != duellistRole.Id))
{
await user.AddRoleAsync(duellistRole);
}
_logger.LogInformation($"Duel player saved result: {result}");
await ReplyAsync($"You have been registered for duels with skill level [{skillLevel}]").AutoRemoveMessage(10);
}
public async Task UnRegister()
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel))
{
return;
}
var user = (IGuildUser)Context.User;
_logger.LogInformation($"{nameof(UnRegister)} called for user '{user.Username}'");
var duelPlayer = await _duelPlayerRepository.Find(user);
if (duelPlayer != null)
{
var duellistRole = await GetDuellistRole();
duelPlayer.Active = false;
if (user.RoleIds.Any(r => r == duellistRole.Id))
{
await user.RemoveRoleAsync(duellistRole);
}
var result = await _duelPlayerRepository.Save(duelPlayer);
_logger.LogInformation($"Duel player updated to inactive result: {result}");
await ReplyAsync("You have been unregistered for duels.").AutoRemoveMessage(10);
}
}
public async Task Promote([Name("Queue name"), Summary("Queue name"), Remainder] string queueName = "")
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
PickupQueue queue = null;
if (!string.IsNullOrWhiteSpace(queueName))
{
queue = await _queueRepository.FindQueue(queueName, Context.Guild.Id.ToString());
if (queue == null)
{
await Context.Channel.SendMessageAsync($"`Queue with the name '{queueName}' doesn't exists!`").AutoRemoveMessage(10);
return;
}
if (queue.MaxInQueue <= queue.Subscribers.Count)
{
await ReplyAsync("Queue is full, why the spam?").AutoRemoveMessage(10);
return;
}
}
await _listCommandService.Promote(queue, (ITextChannel)Context.Channel, (IGuildUser)Context.User);
}
public async Task Opponents()
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel))
{
return;
}
var challenges = (await _duelChallengeRepository.FindByChallengerId((IGuildUser)Context.User)).ToArray();
if (challenges.Any())
{
var challengerIds = challenges.Select(c => Convert.ToUInt64(c.ChallengeeId));
var users = Context.Guild.Users.Where(u => challengerIds.Contains(u.Id)).ToArray();
var sb = new StringBuilder();
foreach (var duelMatch in challenges.OrderBy(m => m.ChallengeDate))
{
var challengee = users.FirstOrDefault(u => u.Id == Convert.ToUInt64(duelMatch.ChallengeeId));
if (challengee == null)
{
continue;
}
sb.AppendLine($" - {PickupHelpers.GetNickname(challengee)} `{duelMatch.ChallengeDate:yyyy-MM-dd HH:mm:ss 'UTC'}`");
}
await ReplyAsync($"**These are the foolish mortals you have challenged**\n{sb}").AutoRemoveMessage();
}
else
{
await ReplyAsync("You have not challenged anyone").AutoRemoveMessage(10);
}
}
public async Task WaitList([Name("Queue name"), Summary("Queue name"), Remainder] string queueName)
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
var queue = await _queueRepository.FindQueue(queueName, Context.Guild.Id.ToString());
if (queue == null)
{
await Context.Channel.SendMessageAsync($"`Queue with the name '{queueName}' doesn't exists!`").AutoRemoveMessage(10);
return;
}
var waitlist = string.Join($"{Environment.NewLine} ", queue.WaitingList.Select((w, i) => $"{i + 1}: {w.Name}"));
if (string.IsNullOrWhiteSpace(waitlist))
{
waitlist = "No players in the waiting list";
}
var embed = new EmbedBuilder
{
Title = $"Players in waiting list for queue {queue.Name}",
Description = waitlist,
Color = Color.Orange
}.Build();
await Context.Channel.SendMessageAsync(embed : embed).AutoRemoveMessage(15);
}
private static StringBuilder BuildListResponse(PickupQueue queue)
{
var sb = new StringBuilder();
sb.AppendLine($"`!add \"{queue.Name}\"` to join!")
.AppendLine("")
.AppendLine($"Created by _{queue.OwnerName}_ {(queue.IsCoop ? "(_coop_)" : "")}")
.AppendLine("```")
.AppendLine($"[{queue.Subscribers.Count}/{queue.MaxInQueue}] - {PickupHelpers.ParseSubscribers(queue)}")
.AppendLine("```");
if (!queue.WaitingList.IsNullOrEmpty())
{
sb.AppendLine($"In waitlist: **{queue.WaitingList.Count}**");
}
if (!queue.Games.IsNullOrEmpty())
{
sb.AppendLine($"**Game(s): ** _{string.Join(", ", queue.Games)}_");
}
if (!string.IsNullOrWhiteSpace(queue.Host))
{
sb.AppendLine($"**Server**: _{queue.Host ?? "ra3.se"}:{(queue.Port > 0 ? queue.Port : 27960)}_");
}
return(sb);
}
public async Task Remove([Name("Queue name"), Summary("Optional, if empty the !clear command will be used."), Remainder] string queueName = "")
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
if (string.IsNullOrWhiteSpace(queueName))
{
await Clear();
return;
}
//find queue with name {queueName}
var queue = await _miscCommandService.VerifyQueueByName(queueName, (IGuildChannel)Context.Channel);
if (queue == null)
{
return;
}
await _subscriberCommandService.Leave(queue, Context.Channel, (IGuildUser)Context.User, messageReference : Context.Message.Reference);
}
public async Task Stats(IGuildUser user = null)
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel))
{
return;
}
user ??= (IGuildUser)Context.User;
var duelPlayer = await _duelPlayerRepository.Find(user);
if (duelPlayer == null)
{
await ReplyAsync($"{PickupHelpers.GetNickname(user)} is not a duellist.").AutoRemoveMessage(10);
}
else
{
var games = (await _duelMatchRepository.FindByChallengerIdOrChallengeeId(user)).ToList();
games = games.Where(w => w.Started && !string.IsNullOrEmpty(w.WinnerId)).ToList();
var last10 = duelPlayer.MatchHistory.Select(g =>
$"{(Convert.ToUInt64(g.WinnerId) == user.Id ? $":first_place: Won against {g.LooserName} MMR +{g.MMR}" : $":cry: Lost against {g.WinnerName} MMR -{g.MMR}")}")
.ToArray();
var embed = new EmbedBuilder
{
Title = $"{PickupHelpers.GetNickname(user)} stats [{((SkillLevel)duelPlayer.Skill)}] MMR: {duelPlayer.MMR}",
Timestamp = duelPlayer.Timestamp
};
embed.WithFields(new List <EmbedFieldBuilder>
{
new EmbedFieldBuilder {
Name = ":first_place: **Wins**", Value = games.Count(w => w.WinnerId == duelPlayer.Id.ToString()), IsInline = true
},
new EmbedFieldBuilder {
Name = "\u200b", Value = "\u200b", IsInline = true
},
new EmbedFieldBuilder {
Name = ":cry: **Losses**", Value = games.Count(w => w.LooserId == duelPlayer.Id.ToString()), IsInline = true
},
new EmbedFieldBuilder {
Name = "\u200b", Value = "\u200b"
},
new EmbedFieldBuilder
{
Name = "**Last matches**",
Value = last10.IsNullOrEmpty() ? "No matches recorded" : string.Join(Environment.NewLine, last10)
}
});
await ReplyAsync(embed : embed.Build()).AutoRemoveMessage();
}
}
public async Task Create(
[Name("Queue name")] string queueName,
[Name("Team size")]
int?teamSize = null,
[Remainder, Name("Operator flags")] string operators = "")
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
if (!teamSize.HasValue)
{
teamSize = 4;
}
if (teamSize > 16)
{
teamSize = 16;
}
if (!await _miscCommandService.VerifyUserFlaggedStatus((IGuildUser)Context.User, Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
//find queue with name {queueName}
var queue = await _queueRepository.FindQueue(queueName, Context.Guild.Id.ToString());
if (queue != null)
{
await Context.Channel.SendMessageAsync(
$"`Queue with the name '{queueName}' already exists!`",
messageReference : new MessageReference(Context.Message.Id))
.AutoRemoveMessage(10);
return;
}
var activity = await _activitiesRepository.Find((IGuildUser)Context.User);
activity.PickupCreate += 1;
activity.PickupAdd += 1;
await _activitiesRepository.Update(activity);
queue = await _listCommandService.Create(queueName, teamSize, operators, (SocketGuildUser)Context.User);
await Context.Channel.SendMessageAsync(
$"`Queue '{queue.Name}' was added by {PickupHelpers.GetNickname(Context.User)}`",
messageReference : new MessageReference(Context.Message.Id));
}
public async Task Add([Name("Queue name"), Summary("Queue name"), Remainder] string queueName = "")
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
//find queue with name {queueName}
await _subscriberCommandService.Add(queueName, Context.Channel, (IGuildUser)Context.User, Context.Message.Reference);
}
public async Task Delete([Name("Queue name"), Summary("Queue name"), Remainder] string queueName)
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
var queue = await _miscCommandService.VerifyQueueByName(queueName, (IGuildChannel)Context.Channel);
if (queue == null)
{
return;
}
var isAdmin = (Context.User as IGuildUser)?.GuildPermissions.Has(GuildPermission.Administrator) ?? false;
if (!isAdmin && queue.OwnerId != Context.User.Id.ToString())
{
await Context.Channel.SendMessageAsync(
"You do not have permission to remove the queue.",
messageReference : new MessageReference(Context.Message.Id))
.AutoRemoveMessage(10);
return;
}
if (!queue.Started)
{
var queuesChannel = await PickupHelpers.GetPickupQueuesChannel(Context.Guild);
var result = await _queueRepository.RemoveQueue(queueName, Context.Guild.Id.ToString());
var message = result
? $"`Queue '{queueName}' has been canceled`"
: $"`Queue with the name '{queueName}' doesn't exists or you are not the owner of the queue!`";
await Context.Channel.SendMessageAsync(message).AutoRemoveMessage(10);
if (!string.IsNullOrEmpty(queue.StaticMessageId))
{
await queuesChannel.DeleteMessageAsync(Convert.ToUInt64(queue.StaticMessageId));
}
}
else
{
await Context.Channel.SendMessageAsync(
"Queue is started, you have to run `!stop` to clean up efter yourself first",
messageReference : new MessageReference(Context.Message.Id))
.AutoRemoveMessage(15);
}
}
public async Task Clear()
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
//find queues with user in it
var allQueues = await _queueRepository.AllQueues(Context.Guild.Id.ToString());
var matchingQueues = allQueues.Where(q => q.Subscribers.Any(s => s.Id == Context.User.Id) || q.WaitingList.Any(w => w.Id == Context.User.Id));
var pickupQueues = matchingQueues as PickupQueue[] ?? matchingQueues.ToArray();
if (pickupQueues.Any())
{
foreach (var queue in pickupQueues)
{
queue.WaitingList.RemoveAll(w => w.Id == Context.User.Id);
queue.Updated = DateTime.UtcNow;
var updatedQueue = await _subscriberCommandService.Leave(queue, Context.Channel, (IGuildUser)Context.User, false);
updatedQueue ??= queue;
if (!updatedQueue.Subscribers.Any() && !updatedQueue.WaitingList.Any())
{
await _queueRepository.RemoveQueue(updatedQueue.Name, updatedQueue.GuildId); //Try to remove queue if its empty.
if (string.IsNullOrEmpty(queue.StaticMessageId))
{
continue;
}
var queuesChannel = await PickupHelpers.GetPickupQueuesChannel(Context.Guild);
await queuesChannel.DeleteMessageAsync(Convert.ToUInt64(queue.StaticMessageId));
}
else
{
await _queueRepository.UpdateQueue(updatedQueue);
}
}
//if queues found and user is in queue
await Context.Channel.SendMessageAsync(
$"{PickupHelpers.GetMention(Context.User)} - You have been removed from all queues",
messageReference : new MessageReference(Context.Message.Id))
.AutoRemoveMessage(10);
}
}
private static EmbedBuilder CreateStaticQueueMessageEmbed(PickupQueue queue, IUser user)
{
var embed = new EmbedBuilder
{
Title = queue.Name,
Author = new EmbedAuthorBuilder {
Name = PickupHelpers.GetNickname(user), IconUrl = user.GetAvatarUrl() ?? user.GetDefaultAvatarUrl()
},
Color = Color.Gold,
Fields = new List <EmbedFieldBuilder>
{
new EmbedFieldBuilder {
Name = "**Created by**", Value = PickupHelpers.GetNickname(user), IsInline = true
},
new EmbedFieldBuilder
{
Name = "**Game(s)**",
Value = string.Join(", ", queue.Games.IsNullOrEmpty() ? new[] { "No game defined" } : queue.Games),
IsInline = true
},
new EmbedFieldBuilder {
Name = "**Started**", Value = queue.Started ? "Yes" : "No", IsInline = true
},
new EmbedFieldBuilder {
Name = "**Host**", Value = queue.Host ?? "No host defined", IsInline = true
},
new EmbedFieldBuilder
{
Name = "**Port**",
Value = queue.Port == 0 ? "No port defined" : queue.Port.ToString(),
IsInline = true
},
new EmbedFieldBuilder {
Name = "**Team size**", Value = queue.TeamSize, IsInline = true
},
new EmbedFieldBuilder {
Name = "**Coop**", Value = queue.IsCoop ? "Yes" : "No", IsInline = true
},
new EmbedFieldBuilder {
Name = "**Created**", Value = queue.Created.ToString("yyyy-MM-dd\r\nHH:mm:ss 'UTC'"), IsInline = true
},
new EmbedFieldBuilder {
Name = "**Last updated**", Value = queue.Updated.ToString("yyyy-MM-dd\r\nHH:mm:ss 'UTC'"), IsInline = true
}
}
};
return(embed);
}
public async Task Decline(IGuildUser challenger)
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel))
{
return;
}
_logger.LogInformation($"{nameof(Decline)} called for user '{challenger.Username}'");
var challenge = await _duelChallengeRepository.Find(challenger, (IGuildUser)Context.User);
if (challenge != null)
{
await _duelChallengeRepository.Delete(challenge);
await ReplyAsync($"{Context.User.Mention} has declined the challenge from {challenger.Mention}!");
}
}
public async Task Stop([Name("Queue name"), Summary("Queue name")] string queueName)
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
var queue = await _miscCommandService.VerifyQueueByName(queueName, (IGuildChannel)Context.Channel);
if (queue == null)
{
return;
}
var voiceIds = queue.Teams.Select(w => w.VoiceChannel.Value).ToList();
if (voiceIds.Any())
{
foreach (var voiceId in voiceIds)
{
if (!voiceId.HasValue)
{
continue;
}
var vc = (IVoiceChannel)Context.Guild.GetVoiceChannel(voiceId.Value);
if (vc == null)
{
continue;
}
await vc.DeleteAsync();
}
}
queue.Started = false;
queue.Updated = DateTime.UtcNow;
queue.Teams.Clear();
queue = await _listCommandService.SaveStaticQueueMessage(queue, Context.Guild);
await _queueRepository.UpdateQueue(queue);
await Delete(queueName);
}
public async Task SetSkill([Name("skill level (low, medium, high)"), Remainder] string level = "")
{
if (!PickupHelpers.IsInDuelChannel(Context.Channel))
{
return;
}
var user = (IGuildUser)Context.User;
_logger.LogInformation($"{nameof(SetSkill)} called for user '{user.Username}' with skill level '{level}'");
var skillLevel = Parse(level);
var result = await _duelPlayerRepository.Save(user, skillLevel);
_logger.LogInformation($"Duel player saved result: {result}");
await ReplyAsync($"Your skill level has been set to [{skillLevel}]").AutoRemoveMessage(10);
}
public async Task <PickupQueue> Create(string queueName, int?teamSize, string operators, SocketGuildUser user)
{
var ops = OperatorParser.Parse(operators);
var rconEnabled = ops?.ContainsKey("-rcon") ?? true;
if (ops?.ContainsKey("-norcon") == true)
{
rconEnabled = false;
}
var queue = new PickupQueue(user.Guild.Id.ToString(), queueName)
{
Name = queueName,
GuildId = user.Guild.Id.ToString(),
OwnerName = PickupHelpers.GetNickname(user),
OwnerId = user.Id.ToString(),
Created = DateTime.UtcNow,
Updated = DateTime.UtcNow,
TeamSize = teamSize ?? 4,
IsCoop = ops?.ContainsKey("-coop") ?? false,
Rcon = rconEnabled,
Subscribers = new List <Subscriber>
{
new Subscriber {
Id = user.Id, Name = PickupHelpers.GetNickname(user)
}
},
Host = ops?.ContainsKey("-host") ?? false ? ops["-host"]?.FirstOrDefault() : null,
Port = int.Parse((ops?.ContainsKey("-port") ?? false ? ops["-port"]?.FirstOrDefault() : null) ?? "0"),
Games = ops?.ContainsKey("-game") ?? false ? ops["-game"] : Enumerable.Empty <string>(),
};
await _queueRepository.AddQueue(queue);
queue = await _queueRepository.FindQueue(queue.Name, user.Guild.Id.ToString());
queue = await SaveStaticQueueMessage(queue, user.Guild);
await _queueRepository.UpdateQueue(queue);
return(queue);
}
public async Task List()
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
//find all active queues
var queues = await _queueRepository.AllQueues(Context.Guild.Id.ToString());
Embed embed;
//if queues found
var pickupQueues = queues as PickupQueue[] ?? queues.ToArray();
if (!pickupQueues.Any())
{
embed = new EmbedBuilder
{
Title = "Active queues",
Description = "There are no active pickup queues at this time, maybe you should `!create` one \uD83D\uDE09",
Color = Color.Orange
}.Build();
await Context.Channel.SendMessageAsync(embed : embed).AutoRemoveMessage(10);
return;
}
var ordered = pickupQueues.OrderByDescending(w => w.Readiness);
foreach (var q in ordered)
{
embed = new EmbedBuilder
{
Title = $"{q.Name}{(q.Started ? " - Started" : "")}",
Description = BuildListResponse(q).ToString(),
Color = Color.Orange
}.Build();
await Context.Channel.SendMessageAsync(embed : embed).AutoRemoveMessage();
}
}
public async Task <PickupQueue> SaveStaticQueueMessage(PickupQueue queue, SocketGuild guild)
{
var queuesChannel = await PickupHelpers.GetPickupQueuesChannel(guild);
var user = guild.GetUser(Convert.ToUInt64(queue.OwnerId));
var embed = CreateStaticQueueMessageEmbed(queue, user);
AddSubscriberFieldsToStaticQueueMessageFields(queue, embed);
AddWaitingListFieldsToStaticQueueMessageFields(queue, embed);
embed.WithFields(
new EmbedFieldBuilder {
Name = "\u200b", Value = "\u200b"
},
new EmbedFieldBuilder
{
Name = "**Available actions**",
Value = $"\u2705 - Add to pickup / remove from pickup\r\n" +
$"\uD83D\uDCE2 - Promote pickup"
}
);
if (string.IsNullOrEmpty(queue.StaticMessageId))
{
var message = await queuesChannel.SendMessageAsync(embed : embed.Build());
await message.AddReactionsAsync(new IEmote[] { new Emoji("\u2705"), new Emoji("\uD83D\uDCE2") }); // timer , new Emoji("\u23F2")
queue.StaticMessageId = message.Id.ToString();
}
else
{
if (await queuesChannel.GetMessageAsync(Convert.ToUInt64(queue.StaticMessageId)) is IUserMessage message)
{
await message.ModifyAsync(m => { m.Embed = embed.Build(); });
}
}
return(queue);
}
public async Task Teams([Name("Queue name"), Remainder] string queueName)
{
if (!PickupHelpers.IsInPickupChannel((IGuildChannel)Context.Channel))
{
return;
}
queueName = queueName.Trim(' ', '"').Trim();
var queue = await _miscCommandService.VerifyQueueByName(queueName, (IGuildChannel)Context.Channel);
if (queue == null)
{
return;
}
using (Context.Channel.EnterTypingState())
{
await _listCommandService.PrintTeams(queue, Context.Channel, Context.Guild);
await _miscCommandService.TriggerRconNotification(queue);
}
}
public async Task <bool> DeleteEmptyQueue(PickupQueue queue, SocketGuild guild, ISocketMessageChannel channel, bool notify)
{
var result = await _queueRepository.RemoveQueue(queue.Name, queue.GuildId); //Try to remove queue if its empty
if (result)
{
var queuesChannel = await PickupHelpers.GetPickupQueuesChannel(guild);
if (!string.IsNullOrEmpty(queue.StaticMessageId))
{
await queuesChannel.DeleteMessageAsync(Convert.ToUInt64(queue.StaticMessageId));
}
}
if (!notify)
{
return(false);
}
await channel.SendMessageAsync($"`{queue.Name} has been removed since everyone left.`").AutoRemoveMessage(10);
return(false);
}
private static StringBuilder BuildPromoteMessage(PickupQueue queue, IGuildChannel pickupChannel)
{
var sb = new StringBuilder()
.AppendLine("**Current queue**")
.AppendLine($"`{PickupHelpers.ParseSubscribers(queue)}`")
.AppendLine("")
.AppendLine($"**Spots left**: {queue.MaxInQueue - queue.Subscribers.Count}")
.AppendLine($"**Team size**: {queue.TeamSize}")
.AppendLine("")
.AppendLine($"Just run `!add \"{queue.Name}\"` in channel <#{pickupChannel.Id}> on the **{pickupChannel.Guild.Name}** server to join!")
.AppendLine("");
if (!queue.Games.IsNullOrEmpty())
{
sb.AppendLine($"**Game(s): ** _{string.Join(", ", queue.Games)}_");
}
if (!string.IsNullOrWhiteSpace(queue.Host))
{
sb.AppendLine($"**Server**: _{queue.Host ?? "ra3.se"}:{(queue.Port > 0 ? queue.Port : 27960)}_");
}
return(sb);
}
