public async Task Create(CommandContext ctx)
{
var message = new Entities.ClientMessage
{
ChannelId = ctx.Channel.Id.ToString(),
ServerId = ctx.Guild.Id.ToString()
};
var teamoEntry = new Entities.TeamoEntry
{
EndDate = DateTime.Now + new TimeSpan(0, 0, 20),
Game = "League of LoL",
MaxPlayers = 5,
Message = message
};
try
{
await _playService.CreateAsync(teamoEntry);
}
catch (Exception e)
{
await PostExceptionMessageAsync(ctx.Channel, _logger, e, "Could not create a new teamo :(");
return;
}
}
public static Models.Post AsModelType(this Entities.TeamoEntry entityEntry)
{
var members = entityEntry.Members.ConvertAll((entityMember) => entityMember.AsModelType());
return(new Models.Post
{
PostId = entityEntry.Id.GetValueOrDefault(0),
Message = entityEntry.Message.AsModelType(),
Game = entityEntry.Game,
Members = members,
EndDate = entityEntry.EndDate,
MaxPlayers = entityEntry.MaxPlayers
});
}
public async Task <Entities.ClientMessage> CreateMessageAsync(Entities.TeamoEntry entry)
{
_logger.LogInformation("Creating new Discord message");
var embed = await CreateEmbedAsync(entry);
var channel = await _client.GetChannelAsync(ulong.Parse(entry.Message.ChannelId));
var dMessage = await channel.SendMessageAsync(embed : embed);
//var numReactions = numPlayers < 11 ? numPlayers : 10;
//for (int i = 1; i < numReactions; i++)
//{
// await message.CreateReactionAsync(CreateEmojiFromNumber(i));
//}
//await message.CreateReactionAsync(GetCancelEmoji());
return(dMessage.AsEntityType());
}
public async Task <Entities.TeamoEntry> CreateAsync(Entities.TeamoEntry entry)
{
return(await ExclusiveAsync(async() =>
{
if (entry.Id != null)
{
// TODO: Better exception
throw new Exception("Cannot create a new database post with non-zero ID");
}
var post = await Posts.AddAsync(entry.AsModelType());
await SaveChangesAsync();
_logger.LogDebug($"Database entry " +
$"{entry.Message.ChannelId} : " +
$"{entry.Message.MessageId} : " +
$"{entry.Message.ServerId} created. " +
$"Post id: {post.Entity.PostId}");
return post.Entity.AsEntityType();
}));
}
public async Task <Entities.TeamoEntry> CreateAsync(Entities.TeamoEntry entry)
{
// Create Discord message
var message = await _clientService.CreateMessageAsync(entry);
entry.Message = message;
// Create database entry
try
{
entry = await _dbContext.CreateAsync(entry);
await _clientService.UpdateMessageAsync(entry);
}
catch
{
await _clientService.DeleteMessageAsync(message);
throw;
}
if (entry.Id == null)
{
// TODO: Error handling
throw new Exception("Newly created Discord message got a null Id!");
}
// Create timers
double updateInterval = 5000.0;
var timers = new Timers(updateInterval, entry, _dbContext, _clientService, _logger);
timers.TimerFinished += (sender, e) => _timers.Remove(entry.Id.Value);
timers.Start();
_timers.Add(entry.Id.Value, timers);
return(entry);
}
// ------------ Internal utility methods ------------
private async Task <DiscordEmbed> CreateEmbedAsync(Entities.TeamoEntry entry)
{
var game = entry.Game;
var date = entry.EndDate;
var maxPlayers = entry.MaxPlayers;
var members = entry.Members;
var id = entry.Id;
var builder = new DiscordEmbedBuilder
{
Title = $"Dags för **{game}**!!",
Description = $"**Start: {date}** - För anmälan, tryck emotes nedan med antal som vill spela."
};
builder.Color = DiscordColor.Purple;
builder.AddField("Tid kvar", $"{date - DateTime.Now}");
builder.AddField("Spelare per lag", $"{maxPlayers}");
builder.AddField("Anmälda", $"Inga anmälda än");
if (members != null)
{
foreach (var member in members)
{
var discordUser = await _client.GetUserAsync(ulong.Parse(member.ClientUserId));
builder.AddField($"Member: {discordUser.Username}", $"{member.NumPlayers}");
}
}
if (!(id is null))
{
builder.AddField("Id", $"{id}");
}
builder.Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = $"Uppdateras var 15:e sekund. Senast uppdaterad {DateTime.Now}"
};
return(builder.Build());
}
public async Task UpdateMessageAsync(Entities.TeamoEntry entry)
{
ulong messageId = ulong.Parse(entry.Message.MessageId);
ulong channelId = ulong.Parse(entry.Message.ChannelId);
var channel = await _client.GetChannelAsync(channelId);
var message = await channel.GetMessageAsync(messageId);
var embed = await CreateEmbedAsync(entry);
await message.ModifyAsync(embed : embed);
var maxPlayers = entry.MaxPlayers;
//_logger.LogInformation($"Number of reactions: {message.Reactions.Count}");
//var reactions = message.Reactions;
//var reaction = reactions.First();
for (int i = 0; i < NumberEmojiNames.Length; i++)
{
var emoji = CreateEmojiFromNumber(i + 1);
var emojiUsers = await message.GetReactionsAsync(CreateEmojiFromNumber(i + 1));
var emojiNumber = emoji.GetAsNumber();
if (i < maxPlayers)
{
if (emojiUsers.Count == 0)
{
await message.CreateReactionAsync(emoji);
}
else if (!emojiUsers.Contains(_client.CurrentUser))
{
_logger.LogWarning($"Number emoji {emoji} exists without bot reaction. Removing and readding emoji.");
await message.DeleteReactionsEmojiAsync(emoji);
await message.CreateReactionAsync(emoji);
}
}
if (i > maxPlayers - 1 && emojiUsers.Count > 0)
{
await message.DeleteReactionsEmojiAsync(emoji);
}
foreach (var member in entry.Members)
{
ulong memberId = ulong.Parse(member.ClientUserId);
if (emojiUsers.Any((u) => u.Id == memberId))
{
if (emojiNumber != member.NumPlayers)
{
await message.DeleteReactionAsync(emoji, emojiUsers.Single((u) => u.Id == memberId));
}
}
else if (emojiNumber == member.NumPlayers)
{
_logger.LogWarning($"Mismatch between number of players in database and discord reactions for member {memberId}." +
$"Number of players according to database: {member.NumPlayers}");
}
}
}
// TODO: Update number of emojis
}
public Task CreateStartMessageAsync(Entities.TeamoEntry entry)
{
_logger.LogError("Method to create start message not implemented!");
return(Task.CompletedTask);
}
public async void TestEverything()
{
//var connection = new SqliteConnection("DataSource=:memory:");
var connection = new SqliteConnection("DataSource=myshareddb;mode=memory;cache=shared");
connection.Open();
try
{
var deps = new ServiceCollection()
.AddLogging((logging) =>
{
logging.AddProvider(new XUnitLoggerProvider(_testOutputHelper));
})
.AddDbContext <TeamoContext>((options) =>
{
_testOutputHelper.WriteLine("Configuring options from test");
options.UseSqlite(connection);
})
.AddSingleton <IClientService, TestClientService>()
.AddSingleton <IMainService, MainService>();
var serviceProvider = deps.BuildServiceProvider();
var context = serviceProvider.GetService <TeamoContext>();
context.Database.EnsureCreated();
var mainService = serviceProvider.GetService <IMainService>();
var entry1 = new Entities.TeamoEntry
{
EndDate = DateTime.Now + TimeSpan.FromSeconds(20),
Game = "Test Game 1",
MaxPlayers = 7,
Message = new Entities.ClientMessage
{
ServerId = "1",
ChannelId = "1"
}
};
var entry2 = new Entities.TeamoEntry
{
EndDate = DateTime.Now + TimeSpan.FromSeconds(20),
Game = "Test Game 2",
MaxPlayers = 3,
Message = new Entities.ClientMessage
{
ServerId = "1",
ChannelId = "1"
}
};
var entry1WithId = await mainService.CreateAsync(entry1);
var entry2WithId = await mainService.CreateAsync(entry2);
Assert.NotEqual(entry1WithId.Id, entry2WithId.Id);
Assert.NotEqual(entry1WithId.Message.MessageId, entry2WithId.Message.MessageId);
}
finally
{
connection.Close();
}
}
