public async Task OnGet(string teamId)
{
var teamIdToUpper = teamId.ToUpper();
var team = await _teamRepo.GetTeam(teamIdToUpper);
Team = team;
LeagueName = "Unknown league / league not found!";
try
{
LeagueName = (await _leagueClient.GetClassicLeague((int)team.FplbotLeagueId)).Properties.Name;
}
catch (Exception)
{
}
}
public async Task <SlashCommandResponse> Handle(SlashCommandContext context)
{
var leagueId = int.Parse(context.CommandInput.Value);
var league = await _leagueClient.GetClassicLeague(leagueId, tolerate404 : true);
if (league == null)
{
return(Respond($"Could not find a classic league of id '{leagueId}'", success: false));
}
var existingSub = await _repo.GetGuildSubscription(context.GuildId, context.ChannelId);
if (existingSub == null)
{
await _repo.InsertGuildSubscription(new GuildFplSubscription(context.GuildId, context.ChannelId, leagueId, new []
{
EventSubscription.All
}));
return(Respond($"Now following the '{$"{league.Properties.Name}"}' FPL league. (Auto-subbed to all events) "));
}
await _repo.UpdateGuildSubscription(existingSub with {
LeagueId = leagueId
});
return(Respond($"Now following the '{$"{league.Properties.Name}"}' FPL league. "));
}
public async Task <EventHandledResponse> Handle(BlockActionInteraction blockActionEvent)
{
var actionsBlock = blockActionEvent.Actions.FirstOrDefault(x => x.action_id.Equals("fpl_league_id_action"));
if (actionsBlock == null)
{
return(new EventHandledResponse("IGNORE. THIS IS NOT FOR ME"));
}
var leagueId = actionsBlock.value;
if (!int.TryParse(leagueId, out var newLeagueID))
{
return(new EventHandledResponse("VALIDATION_ERRORS"));
}
try
{
await _leagueClient.GetClassicLeague(newLeagueID);
}
catch (Exception)
{
return(new EventHandledResponse("VALIDATION_ERRORS"));
}
await _teamRepo.UpdateLeagueId(blockActionEvent.Team.Id, newLeagueID);
return(new EventHandledResponse("League ID updated"));
}
public async Task Handle(PublishGameweekFinishedToGuild message, IMessageHandlerContext context)
{
var sub = await _repo.GetGuildSubscription(message.GuildId, message.ChannelId);
if (sub != null && message.LeagueId.HasValue && sub.Subscriptions.ContainsSubscriptionFor(EventSubscription.Standings))
{
var settings = await _settingsClient.GetGlobalSettings();
var gameweeks = settings.Gameweeks;
var gw = gameweeks.SingleOrDefault(g => g.Id == message.GameweekId);
ClassicLeague league = await _leagueClient.GetClassicLeague(message.LeagueId.Value, tolerate404 : true);
if (league != null)
{
var messages = new List <RichMesssage>();
var intro = Formatter.FormatGameweekFinished(gw, league);
var standings = Formatter.GetStandings(league, gw, includeExternalLinks: false);
var topThree = Formatter.GetTopThreeGameweekEntries(league, gw, includeExternalLinks: false);
var worst = Formatter.GetWorstGameweekEntry(league, gw, includeExternalLinks: false);
messages.AddRange(new RichMesssage[]
{
new ("ℹ️ Gameweek finished!", intro),
new ("ℹ️ Standings", standings),
new ("ℹ️ Top 3", topThree),
new ("ℹ️ Lantern beige", worst)
});
public async Task <IEnumerable <GameweekEntry> > GetEntriesForGameweek(int gw, int leagueId)
{
try
{
var league = await _leagueClient.GetClassicLeague(leagueId);
var entries = league.Standings.Entries;
var entryDictionary = new ConcurrentBag <GameweekEntry>();
await Task.WhenAll(entries.Select(async entry =>
{
var gameweekEntries = await _entryForGameweek.GetEntryForGameweek((ClassicLeagueEntry)entry, gw);
entryDictionary.Add(gameweekEntries);
}));
return(entryDictionary);
}
catch (HttpRequestException hre) when(LogWarning(hre, gw, leagueId))
{
return(Enumerable.Empty <GameweekEntry>());
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(Enumerable.Empty <GameweekEntry>());
}
}
public async Task OnGet(string teamId)
{
var teamIdToUpper = teamId.ToUpper();
var team = await _teamRepo.GetTeam(teamIdToUpper);
if (team != null)
{
Team = team;
if (team.FplbotLeagueId.HasValue)
{
var league = await _leagueClient.GetClassicLeague(team.FplbotLeagueId.Value, tolerate404 : true);
League = league;
}
var slackClient = await CreateSlackClient(teamIdToUpper);
try
{
var channels = await slackClient.ConversationsListPublicChannels(500);
ChannelStatus = channels.Channels.FirstOrDefault(c => team.FplBotSlackChannel == $"#{c.Name}" || team.FplBotSlackChannel == c.Id) != null;
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
}
}
}
public async Task <IEnumerable <EntryCaptainPick> > GetEntryCaptainPicks(int gameweek, int leagueId)
{
var leagueTask = _leagueClient.GetClassicLeague(leagueId);
var playersTask = _globalSettingsClient.GetGlobalSettings();
var league = await leagueTask;
var players = await playersTask;
var entries = new List <GenericEntry>();
if (league.Standings.Entries.Any())
{
entries = league.Standings.Entries.OrderBy(x => x.Rank).ToList().Select(e => new GenericEntry
{
Entry = e.Entry,
EntryName = e.EntryName
}).ToList();
}
else
{
entries = league.NewEntries.Entries.ToList().Select(e => new GenericEntry
{
Entry = e.Entry,
EntryName = e.EntryName
}).ToList();
}
var entryCaptainPicks = await Task.WhenAll(entries.Select(entry => GetEntryCaptainPick(entry, gameweek, players.Players)));
return(entryCaptainPicks.WhereNotNull());
}
public async Task <IActionResult> Install(string channel, string leagueId)
{
_logger.LogInformation($"Installing using channel {channel} and league {leagueId}!");
try
{
await _leagueClient.GetClassicLeague(int.Parse(leagueId));
}
catch (Exception)
{
var msg = $"Could not find FPL league with id `{leagueId}`. Only classic leagues are currently supported (not draft leagues)";
return(Redirect($"/error?msg={msg}"));
}
var urlencodedState = WebUtility.UrlEncode($"{channel},{leagueId}");
var original = new Uri(HttpContext.Request.GetDisplayUrl());
var redirect_uri = new Uri(original, "/oauth/authorize");
return(Redirect($"https://slack.com/oauth/v2/authorize?&user_scope=&scope=app_mentions:read,chat:write,chat:write.customize,chat:write.public,users.profile:read,users:read,users:read.email,groups:read,channels:read&client_id={_options.Value.CLIENT_ID}&state={urlencodedState}&redirect_uri={redirect_uri}"));
}
public async Task Handle(PublishStandingsCommand command, CancellationToken cancellationToken)
{
var league = await _leagueClient.GetClassicLeague((int)command.Team.FplbotLeagueId);
var intro = Formatter.FormatGameweekFinished(command.FinishedGameweek, league);
var standings = Formatter.GetStandings(league, command.FinishedGameweek);
var topThree = Formatter.GetTopThreeGameweekEntries(league, command.FinishedGameweek);
var worst = Formatter.GetWorstGameweekEntry(league, command.FinishedGameweek);
await _publisher.PublishToWorkspace(command.Team.TeamId, command.Team.FplBotSlackChannel, intro, standings, topThree, worst);
}
public async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, MemberJoinedChannelEvent joinedEvent)
{
var team = await _teamRepo.GetTeam(eventMetadata.Team_Id);
var slackClient = _slackClientService.Build(team.AccessToken);
var userProfile = await slackClient.UserProfile(joinedEvent.User);
if (userProfile.Profile.Api_App_Id == _slackAppId)
{
var introMessage = ":wave: Hi, I'm fplbot. Type `@fplbot help` to see what I can do.";
var setupMessage = "";
if (team.FplbotLeagueId.HasValue)
{
try
{
var league = await _leagueClient.GetClassicLeague(team.FplbotLeagueId.Value);
if (!string.IsNullOrEmpty(team.FplBotSlackChannel))
{
setupMessage = $"I'm pushing notifications relevant to {league.Properties.Name} into {ChannelName()}. ";
if (team.FplBotSlackChannel != joinedEvent.Channel)
{
setupMessage += "If you want to have notifications in this channel instead, use the `@fplbot follow` command in this channel.";
}
// Back-compat as we currently have a mix of:
// - display names (#name)
// - channel_ids (C12351)
// Man be removed next season when we require updates to leagueids
string ChannelName()
{
return(team.FplBotSlackChannel.StartsWith("#") ? team.FplBotSlackChannel : $"<#{team.FplBotSlackChannel}>");
}
}
}
catch (HttpRequestException e) when(e.Message.Contains("404"))
{
setupMessage = $"I'm currently following no valid league. The invalid leagueid is `{team.FplbotLeagueId}`. Use `@fplbot follow` to setup a new valid leagueid.";
}
}
else
{
setupMessage = "To get notifications for a league, use my `@fplbot follow` command";
}
await _publisher.PublishToWorkspace(eventMetadata.Team_Id, joinedEvent.Channel, introMessage, setupMessage);
return(new EventHandledResponse("OK"));
}
return(new EventHandledResponse($"IGNORED FOR {userProfile.Profile.Real_Name}"));
}
private async Task <string> GetStandings()
{
try
{
var leagueTask = _leagueClient.GetClassicLeague(_options.Value.LeagueId);
var gameweeksTask = _gameweekClient.GetGameweeks();
var standings = Formatter.GetStandings(await leagueTask, await gameweeksTask);
return(standings);
}
catch (Exception e)
{
return($"Oops: {e.Message}");
}
}
public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent message)
{
var newLeagueId = ParseArguments(message);
if (string.IsNullOrEmpty(newLeagueId))
{
var help = $"No leagueId provided. Usage: `@fplbot updateleagueid 123`";
await _publisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, help);
return(new EventHandledResponse(help));
}
var couldParse = int.TryParse(newLeagueId, out var theLeagueId);
if (!couldParse)
{
var res = $"Could not update league to id '{newLeagueId}'. Make sure it's a valid number.";
await _publisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, res);
return(new EventHandledResponse(res));
}
var failure = $"Could not find league {newLeagueId} :/ Could you find it at https://fantasy.premierleague.com/leagues/{newLeagueId}/standings/c ?";
try
{
var league = await _leagueClient.GetClassicLeague(theLeagueId);
if (league?.Properties != null)
{
await _slackTeamRepository.UpdateLeagueId(eventMetadata.Team_Id, theLeagueId);
var success = $"Thanks! You're now following the '{league.Properties.Name}' league (leagueId: {theLeagueId})";
await _publisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, success);
return(new EventHandledResponse(success));
}
await _publisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, failure);
return(new EventHandledResponse(failure));
}
catch (HttpRequestException e)
{
_logger.LogError(e.Message, e);
await _publisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, failure);
return(new EventHandledResponse(failure));
}
}
public async Task <string> GetCaptainsByGameWeek(int gameweek)
{
try
{
var league = await _leagueClient.GetClassicLeague(_options.Value.LeagueId);
var players = await _playerClient.GetAllPlayers();
var sb = new StringBuilder();
sb.Append($":boom: *Captain picks for gameweek {gameweek}*\n");
foreach (var team in league.Standings.Entries)
{
try
{
var entry = await _entryClient.GetPicks(team.Entry, gameweek);
var hasUsedTripleCaptainForGameWeek = await _chipsPlayed.GetHasUsedTripleCaptainForGameWeek(gameweek, team.Entry);
var captainPick = entry.Picks.SingleOrDefault(pick => pick.IsCaptain);
var captain = players.SingleOrDefault(player => player.Id == captainPick.PlayerId);
var viceCaptainPick = entry.Picks.SingleOrDefault(pick => pick.IsViceCaptain);
var viceCaptain = players.SingleOrDefault(player => player.Id == viceCaptainPick.PlayerId);
sb.Append($"*{team.GetEntryLink(gameweek)}* - {captain.FirstName} {captain.SecondName} ({viceCaptain.FirstName} {viceCaptain.SecondName}) ");
if (hasUsedTripleCaptainForGameWeek)
{
sb.Append("TRIPLECAPPED!! :rocket::rocket::rocket::rocket:");
}
sb.Append("\n");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
return(sb.ToString());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return($"Oops: {e.Message}");
}
}
public async Task <IEnumerable <Transfer> > GetTransfersByGameweek(int gw, int leagueId)
{
if (gw < 2)
{
return(Enumerable.Empty <Transfer>());
}
try
{
var league = await _leagueClient.GetClassicLeague(leagueId);
var playerTransfers = new ConcurrentBag <Transfer>();
var entries = league.Standings.Entries;
await Task.WhenAll(entries.Select(async entry =>
{
var transfers = (await _transfersClient.GetTransfers(entry.Entry)).Where(x => x.Event == gw).Select(x =>
{
var e = entries.Single(e => e.Entry == x.Entry);
return(new Transfer
{
EntryId = x.Entry,
EntryName = e.PlayerName,
EntryRealName = e.EntryName,
PlayerTransferredIn = x.ElementIn,
PlayerTransferredOut = x.ElementOut
});
});
foreach (var transfer in transfers)
{
playerTransfers.Add(transfer);
}
}));
return(playerTransfers.ToArray());
}
catch (HttpRequestException hre) when(LogWarning(hre, gw, leagueId))
{
return(Enumerable.Empty <Transfer>());
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(Enumerable.Empty <Transfer>());
}
}
public async Task <SlashCommandResponse> Handle(SlashCommandContext context)
{
var content = "";
var sub = await _store.GetGuildSubscription(context.GuildId, context.ChannelId);
if (sub != null)
{
if (sub.LeagueId.HasValue)
{
var league = await _client.GetClassicLeague(sub.LeagueId.Value, tolerate404 : true);
if (league != null)
{
content += $"\n**League:**\nCurrently following the '{league.Properties.Name}' league";
}
}
else
{
content += $"\n ⚠️ Not following any FPL leagues";
}
var allTypes = EventSubscriptionHelper.GetAllSubscriptionTypes();
if (sub.Subscriptions.Any())
{
content += $"\n\n**Subscriptions:**\n{string.Join("\n", sub.Subscriptions.Select(s => $" ✅ {s}"))}";
if (!sub.Subscriptions.Contains(EventSubscription.All))
{
var allTypesExceptSubs = allTypes.Except(sub.Subscriptions).Except(new [] { EventSubscription.All });
content += $"\n\n**Not subscribing:**\n{string.Join("\n", allTypesExceptSubs.Select(s => $" ❌ {s}"))}";
}
}
else
{
content += "\n\n**Subscriptions:**\n ⚠️ No subscriptions";
content += $"\n\n**Events you may subscribe to:**\n{string.Join("\n", allTypes.Select(s => $" ▪️ {s}"))}";
}
}
else
{
content = "⚠️ Not subscribing to any events. Add one to get notifications!";
}
return(Respond(content));
}
public async Task Handle(EventMetaData eventMetadata, AppMentionEvent @event)
{
var team = await _tokenStore.GetTeam(eventMetadata.Team_Id);
var slackClient = _slackClientService.Build(team.AccessToken);
var text = $"*HELP:*\n";
if (team.HasChannelAndLeagueSetup())
{
try
{
var league = await _leagueClient.GetClassicLeague(team.FplbotLeagueId.Value);
text += $"Currently following {league.Properties.Name} in {ChannelName()}\n";
}
catch (HttpRequestException e) when(e.StatusCode == HttpStatusCode.NotFound)
{
text += $"Currently following {team.FplbotLeagueId} in {ChannelName()}\n";
}
string ChannelName()
{
return(team.FplBotSlackChannel.StartsWith("#") ? team.FplBotSlackChannel : $"<#{team.FplBotSlackChannel}>");
}
}
else
{
text += "Currently not following any leagues\n";
}
if (team.Subscriptions.Any())
{
text += $"Active subscriptions:\n{Formatter.BulletPoints(team.Subscriptions)}\n";
}
await slackClient.ChatPostMessage(@event.Channel, text);
var handlerHelp = _handlers.Select(handler => handler.GetHelpDescription())
.Where(desc => !string.IsNullOrEmpty(desc.HandlerTrigger))
.Aggregate($"\n*Available commands:*", (current, tuple) => current + $"\n• `@fplbot {tuple.HandlerTrigger}` : _{tuple.Description}_");
await slackClient.ChatPostMessage(new ChatPostMessageRequest { Channel = @event.Channel, Text = handlerHelp, Link_Names = false });
}
public async Task <IActionResult> GetLeague(int leagueId)
{
try
{
var league = await _leagueClient.GetClassicLeague(leagueId);
return(Ok(new
{
LeagueName = league.Properties.Name,
LeagueAdmin = league.Standings.Entries.FirstOrDefault(e => e.Entry == league.Properties.AdminEntry)?.PlayerName
}));
}
catch (HttpRequestException e)
{
_logger.LogWarning(e.ToString());
}
return(NotFound());
}
public async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, MemberJoinedChannelEvent joinedEvent)
{
_logger.LogInformation(JsonConvert.SerializeObject(joinedEvent));
_logger.LogInformation(JsonConvert.SerializeObject(eventMetadata));
var team = await _teamRepo.GetTeam(eventMetadata.Team_Id);
var slackClient = _slackClientService.Build(team.AccessToken);
var userProfile = await slackClient.UserProfile(joinedEvent.User);
if (userProfile.Profile.Api_App_Id == FplBotProdAppId || userProfile.Profile.Api_App_Id == FplBotTestAppId)
{
var introMessage = ":wave: Hi, I'm fplbot. Type `@fplbot help` to see what I can do.";
var league = await _leagueClient.GetClassicLeague((int)team.FplbotLeagueId);
var setupMessage = $"I'm pushing notifications relevant to {league.Properties.Name} into {team.FplBotSlackChannel}";
await _publisher.PublishToWorkspace(eventMetadata.Team_Id, joinedEvent.Channel, introMessage, setupMessage);
return(new EventHandledResponse("OK"));
}
return(new EventHandledResponse($"IGNORED FOR {userProfile.Profile.Real_Name}"));
}
private async Task <string> GetCountryToBoost(SlackTeam slackTeam)
{
string countryToBoost = null;
if (slackTeam?.FplbotLeagueId != null)
{
var league = await _leagueClient.GetClassicLeague((int)slackTeam.FplbotLeagueId);
var adminEntry = league?.Properties?.AdminEntry;
if (adminEntry != null)
{
var admin = await _entryClient.Get(adminEntry.Value);
if (admin != null)
{
countryToBoost = admin.PlayerRegionShortIso;
}
}
}
return(countryToBoost);
}
public async Task Handle(PublishStandingsToSlackWorkspace message, IMessageHandlerContext context)
{
var settings = await _settingsClient.GetGlobalSettings();
var gameweeks = settings.Gameweeks;
var gw = gameweeks.SingleOrDefault(g => g.Id == message.GameweekId);
ClassicLeague league = null;
try
{
league = await _leagueClient.GetClassicLeague(message.LeagueId);
var intro = Formatter.FormatGameweekFinished(gw, league);
var standings = Formatter.GetStandings(league, gw);
var topThree = Formatter.GetTopThreeGameweekEntries(league, gw);
var worst = Formatter.GetWorstGameweekEntry(league, gw);
await _publisher.PublishToWorkspace(message.WorkspaceId, message.Channel, intro, standings, topThree, worst);
}
catch (HttpRequestException e) when(e.StatusCode == HttpStatusCode.NotFound)
{
await _publisher.PublishToWorkspace(message.WorkspaceId, message.Channel, $"League standings are now generally ready, but I could not seem to find a classic league with id `{message.LeagueId}`. Are you sure it's a valid classic league id?");
}
}
public async Task Handle(ProcessGameweekStartedForSlackWorkspace message, IMessageHandlerContext context)
{
var newGameweek = message.GameweekId;
var team = await _teamRepo.GetTeam(message.WorkspaceId);
if (team.HasRegisteredFor(EventSubscription.Captains) || team.HasRegisteredFor(EventSubscription.Transfers))
{
await _publisher.PublishToWorkspace(team.TeamId, team.FplBotSlackChannel, $"Gameweek {message.GameweekId}!");
}
var messages = new List <string>();
var leagueExists = false;
ClassicLeague league = null;
if (team.FplbotLeagueId.HasValue)
{
league = await _leagueClient.GetClassicLeague(team.FplbotLeagueId.Value, tolerate404 : true);
}
leagueExists = league != null;
if (leagueExists && team.HasRegisteredFor(EventSubscription.Captains))
{
var captainPicks = await _captainsByGameweek.GetEntryCaptainPicks(newGameweek, team.FplbotLeagueId.Value);
if (league.Standings.Entries.Count < MemberCountForLargeLeague)
{
messages.Add(_captainsByGameweek.GetCaptainsByGameWeek(newGameweek, captainPicks));
messages.Add(_captainsByGameweek.GetCaptainsChartByGameWeek(newGameweek, captainPicks));
}
else
{
messages.Add(_captainsByGameweek.GetCaptainsStatsByGameWeek(captainPicks));
}
}
else if (team.FplbotLeagueId.HasValue && !leagueExists && team.HasRegisteredFor(EventSubscription.Captains))
{
messages.Add($"⚠️ You're subscribing to captains notifications, but following a league ({team.FplbotLeagueId.Value}) that does not exist. Update to a valid classic league, or unsubscribe to captains to avoid this message in the future.");
}
else
{
_logger.LogInformation("Team {team} hasn't subscribed for gw start captains, so bypassing it", team.TeamId);
}
if (leagueExists && team.HasRegisteredFor(EventSubscription.Transfers))
{
try
{
if (league.Standings.Entries.Count < MemberCountForLargeLeague)
{
messages.Add(await _transfersByGameweek.GetTransfersByGameweekTexts(newGameweek, team.FplbotLeagueId.Value));
}
else
{
var externalLink = $"See https://www.fplbot.app/leagues/{team.FplbotLeagueId.Value} for all transfers";
messages.Add(externalLink);
}
}
catch (HttpRequestException hre) when(hre.StatusCode == HttpStatusCode.TooManyRequests) // fallback
{
var externalLink = $"See https://www.fplbot.app/leagues/{team.FplbotLeagueId.Value} for all transfers";
messages.Add(externalLink);
}
}
else if (team.FplbotLeagueId.HasValue && !leagueExists && team.HasRegisteredFor(EventSubscription.Transfers))
{
messages.Add($"⚠️ You're subscribing to transfers notifications, but following a league ({team.FplbotLeagueId.Value}) that does not exist. Update to a valid classic league, or unsubscribe to transfers to avoid this message in the future.");
}
else
{
_logger.LogInformation("Team {team} hasn't subscribed for gw start transfers, so bypassing it", team.TeamId);
}
await _publisher.PublishToWorkspace(team.TeamId, team.FplBotSlackChannel, messages.ToArray());
}
public async Task GetClassicLeague()
{
var scoreboard = await _leagueClient.GetClassicLeague(579157);
Assert.NotEmpty(scoreboard.Standings.Entries);
}
public async Task Handle(ProcessGameweekStartedForGuildChannel message, IMessageHandlerContext context)
{
var newGameweek = message.GameweekId;
var team = await _repo.GetGuildSubscription(message.GuildId, message.ChannelId);
var messages = new List <RichMesssage>();
if (team.Subscriptions.ContainsSubscriptionFor(EventSubscription.Captains) ||
team.Subscriptions.ContainsSubscriptionFor(EventSubscription.Transfers))
{
messages.Add(new RichMesssage($"Gameweek {message.GameweekId}!", ""));
}
ClassicLeague league = null;
if (team.LeagueId.HasValue)
{
league = await _leagueClient.GetClassicLeague(team.LeagueId.Value, tolerate404 : true);
}
var leagueExists = league != null;
if (leagueExists && team.Subscriptions.ContainsSubscriptionFor(EventSubscription.Captains))
{
var captainPicks = await _captainsByGameweek.GetEntryCaptainPicks(newGameweek, team.LeagueId.Value);
if (league.Standings.Entries.Count < MemberCountForLargeLeague)
{
string captainsByGameWeek = _captainsByGameweek.GetCaptainsByGameWeek(newGameweek, captainPicks, includeExternalLinks: false);
messages.Add(new RichMesssage("Captains:", captainsByGameWeek));
string captainsChartByGameWeek = _captainsByGameweek.GetCaptainsChartByGameWeek(newGameweek, captainPicks);
messages.Add(new RichMesssage("Chart", captainsChartByGameWeek));
}
else
{
string captainsByGameWeek = _captainsByGameweek.GetCaptainsStatsByGameWeek(captainPicks, includeHeader: false);
messages.Add(new RichMesssage("Captain stats:", captainsByGameWeek));
}
}
else if (team.LeagueId.HasValue && !leagueExists && team.Subscriptions.ContainsSubscriptionFor(EventSubscription.Captains))
{
messages.Add(new RichMesssage("⚠️Warning!", $"️ You're subscribing to captains notifications, but following a league ({team.LeagueId.Value}) that does not exist. Update to a valid classic league, or unsubscribe to captains to avoid this message in the future."));
}
else
{
_logger.LogInformation("Team {team} hasn't subscribed for gw start captains, so bypassing it", team.GuildId);
}
if (leagueExists && team.Subscriptions.ContainsSubscriptionFor(EventSubscription.Transfers))
{
if (league.Standings.Entries.Count < MemberCountForLargeLeague)
{
var transfersByGameweekTexts = await _transfersByGameweek.GetTransferMessages(newGameweek, team.LeagueId.Value, includeExternalLinks : false);
if (transfersByGameweekTexts.GetTotalCharCount() > 2000)
{
var array = transfersByGameweekTexts.Messages.ToList();
int halfway = array.Count() / 2;
var firstArray = array.Take(halfway);
var secondArray = array.Skip(halfway);
messages.Add(new RichMesssage("Transfers", string.Join("", firstArray.Select(c => c.Message))));
messages.Add(new RichMesssage("Transfers (#2)", string.Join("", secondArray.Select(c => c.Message))));
}
else
{
messages.Add(new RichMesssage("Transfers", string.Join("", transfersByGameweekTexts.Messages.Select(m => m.Message))));
}
}
else
{
var externalLink = $"See https://www.fplbot.app/leagues/{team.LeagueId.Value} for full details";
messages.Add(new RichMesssage("Captains/Transfers/Chips", externalLink));
}
}
else if (team.LeagueId.HasValue && !leagueExists && team.Subscriptions.ContainsSubscriptionFor(EventSubscription.Transfers))
{
messages.Add(new RichMesssage("⚠️Warning!", $"⚠️ You're subscribing to transfers notifications, but following a league ({team.LeagueId.Value}) that does not exist. Update to a valid classic league, or unsubscribe to transfers to avoid this message in the future."));
}
else
{
_logger.LogInformation("Team {team} hasn't subscribed for gw start transfers, so bypassing it", team.GuildId);
}
var i = 0;
foreach (var richMessage in messages)
{
i = i + 2;
var sendOptions = new SendOptions();
sendOptions.DelayDeliveryWith(TimeSpan.FromSeconds(i));
sendOptions.RouteToThisEndpoint();
await context.Send(new PublishRichToGuildChannel(team.GuildId, team.ChannelId, richMessage.Title, richMessage.Description), sendOptions);
}
}