public async Task Insert(SlackTeam slackTeam)
{
var hashEntries = new List <HashEntry>
{
new HashEntry(_accessTokenField, slackTeam.AccessToken),
new HashEntry(_teamNameField, slackTeam.TeamName),
new HashEntry(_teamIdField, slackTeam.TeamId)
};
if (!string.IsNullOrEmpty(slackTeam.FplBotSlackChannel))
{
hashEntries.Add(new HashEntry(_channelField, slackTeam.FplBotSlackChannel));
}
if (slackTeam.FplbotLeagueId > 0)
{
hashEntries.Add(new HashEntry(_leagueField, slackTeam.FplbotLeagueId));
}
if (slackTeam.Subscriptions != null)
{
var hashEntry = new HashEntry(_subscriptionsField, string.Join(" ", slackTeam.Subscriptions));
hashEntries.Add(hashEntry);
}
await _db.HashSetAsync(FromTeamIdToTeamKey(slackTeam.TeamId), hashEntries.ToArray());
}
public async Task <SlackTeam> GetTeam(string teamId)
{
var fetchedTeamData = await _db.HashGetAsync(FromTeamIdToTeamKey(teamId), new RedisValue[] { _accessTokenField, _channelField, _leagueField, _teamNameField, _subscriptionsField });
var team = new SlackTeam
{
AccessToken = fetchedTeamData[0],
TeamName = fetchedTeamData[3],
TeamId = teamId
};
if (fetchedTeamData[1].HasValue)
{
team.FplBotSlackChannel = fetchedTeamData[1];
}
if (fetchedTeamData[2].HasValue)
{
team.FplbotLeagueId = int.Parse(fetchedTeamData[2]);
}
var subs = GetSubscriptions(teamId, fetchedTeamData[4]);
team.Subscriptions = subs;
return(team);
}
public async Task <IEnumerable <SlackTeam> > GetAllTeams()
{
var allTeamKeys = _redis.GetServer(_server).Keys(pattern: FromTeamIdToTeamKey("*"));
var teams = new List <SlackTeam>();
foreach (var key in allTeamKeys)
{
var teamId = FromKeyToTeamId(key);
var fetchedTeamData = await _db.HashGetAsync(key, new RedisValue[] { _accessTokenField, _channelField, _leagueField, _teamNameField, _subscriptionsField });
var slackTeam = new SlackTeam
{
AccessToken = fetchedTeamData[0],
FplBotSlackChannel = fetchedTeamData[1],
FplbotLeagueId = int.Parse(fetchedTeamData[2]),
TeamName = fetchedTeamData[3],
TeamId = teamId
};
var subs = GetSubscriptions(teamId, fetchedTeamData[4]);
slackTeam.Subscriptions = subs;
teams.Add(slackTeam);
}
return(teams);
}
private static SearchMetaData GetSearchMetaData(SlackTeam slackTeam, AppMentionEvent message)
{
var metaData = new SearchMetaData
{
Team = slackTeam?.TeamId, FollowingFplLeagueId = slackTeam?.FplbotLeagueId.ToString(), Actor = message.User,
Client = QueryClient.Slack
};
return(metaData);
}
public async Task <IDisposable> Connect()
{
teamData = await api.GetConnectionAsync();
Team = SlackTeam.FromData(teamData, api);
var url = teamData["url"];
if (url == null)
{
throw new Exception("Url not returned from slack api.");
}
return(await socket.OpenSocket(new Uri(url.ToString())));
}
private async Task <IEnumerable <User> > GetSlackUsers(SlackTeam t)
{
var slackClient = _service.Build(t.AccessToken);
try
{
var usersResponse = await slackClient.UsersList();
if (usersResponse.Ok)
{
return(usersResponse.Members);
}
return(Enumerable.Empty <User>());
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(Enumerable.Empty <User>());
}
}
public async Task HandleForTeam(FixtureUpdates updates, SlackTeam slackTeam)
{
var slackUsers = await GetSlackUsers(slackTeam);
var entries = await _leagueEntriesByGameweek.GetEntriesForGameweek(updates.CurrentGameweek, (int)slackTeam.FplbotLeagueId);
var transfers = await _transfersByGameWeek.GetTransfersByGameweek(updates.CurrentGameweek, (int)slackTeam.FplbotLeagueId);
var context = new GameweekLeagueContext
{
Players = updates.Players,
Teams = updates.Teams,
Users = slackUsers,
GameweekEntries = entries,
SlackTeam = slackTeam,
TransfersForLeague = transfers
};
var formattedStr = GameweekEventsFormatter.FormatNewFixtureEvents(updates.Events.ToList(), context);
await _publisher.PublishToWorkspace(slackTeam.TeamId, slackTeam.FplBotSlackChannel, formattedStr.ToArray());
}
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 override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent message)
{
var term = ParseArguments(message);
SlackTeam slackTeam = null;
try
{
slackTeam = await _slackTeamRepo.GetTeam(eventMetadata.Team_Id);
}
catch (Exception e)
{
_logger.LogError(e, "Unable to get team {teamId} during search.", eventMetadata.Team_Id);
}
string countryToBoost = await GetCountryToBoost(slackTeam);
var searchMetaData = GetSearchMetaData(slackTeam, message);
var entriesTask = _searchService.SearchForEntry(term, 0, 10, searchMetaData);
var leaguesTask = _searchService.SearchForLeague(term, 0, 10, searchMetaData, countryToBoost);
var entries = await entriesTask;
var leagues = await leaguesTask;
var sb = new StringBuilder();
sb.Append("Matching teams:\n");
int?currentGameweek = null;
if (entries.Any() || leagues.Any())
{
try
{
var globalSettings = await _globalSettingsClient.GetGlobalSettings();
var gameweeks = globalSettings.Gameweeks;
currentGameweek = gameweeks.GetCurrentGameweek().Id;
}
catch (Exception e)
{
_logger.LogError(e, "Unable to obtain current gameweek when creating search result links");
}
}
if (entries.Any())
{
sb.Append(Formatter.BulletPoints(entries.ExposedHits.Select(e => Formatter.FormatEntryItem(e, currentGameweek))));
if (entries.HitCountExceedingExposedOnes > 0)
{
sb.Append($"\n...and {entries.HitCountExceedingExposedOnes} more");
}
}
else
{
sb.Append("Found no matching teams :shrug:");
}
sb.Append("\n\nMatching leagues:\n");
if (leagues.Any())
{
sb.Append(Formatter.BulletPoints(leagues.ExposedHits.Select(e => Formatter.FormatLeagueItem(e, currentGameweek))));
if (leagues.HitCountExceedingExposedOnes > 0)
{
sb.Append($"\n...and {leagues.HitCountExceedingExposedOnes} more");
}
}
else
{
sb.Append("Found no matching leagues :shrug:");
}
await _workSpacePublisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, sb.ToString());
return(new EventHandledResponse(sb.ToString()));
}
public Task Insert(SlackTeam slackTeam)
{
return(Task.CompletedTask);
}
public static bool HasRegisteredFor(this SlackTeam team, EventSubscription subscription)
{
return(team.HasChannelAndLeagueSetup() && team.Subscriptions.ContainsSubscriptionFor(subscription));
}
public UserDataReceivedEventArgs(SlackUser user, SlackChannel channel, SlackTeam team)
{
User = user;
Channel = channel;
Team = team;
}
public static void StackFeeder(
[QueueTrigger("slackfeed-items", Connection = "slackstackfeed_QueueStorage")] QueuedJob job,
[CosmosDB("FeedStateDatabase", "FeedItemsCollection", ConnectionStringSetting = "slackstackfeed_CosmosDB", Id = "state")] SlackStackState state,
[CosmosDB("FeedStateDatabase", "FeedItemsCollection", ConnectionStringSetting = "slackstackfeed_CosmosDB", Id = "{team}")] SlackTeam team,
DateTime processed,
ILogger log)
{
if (!team.Active || !team.Subscriptions.ContainsKey(job.Feed))
{
return;
}
var feed = state.Feeds[job.Feed];
try
{
var atom = XDocument.Load(feed.SourceUri.AbsoluteUri).Root;
XNamespace bs = "http://www.w3.org/2005/Atom";
DateTime.TryParse(atom.Element(bs + "updated").Value, out var updated);
if (updated > processed)
{
log.LogDebug("Feed recently updated, scanning for entries...");
using (var client = new HttpClient(new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
}))
{
foreach (var entry in atom.Elements(bs + "entry"))
{
var id = entry.Element(bs + "id")?.Value ?? string.Empty;
if (string.IsNullOrEmpty(id) || team.Posted.Contains(id))
{
continue;
}
if (!DateTime.TryParse(entry.Element(bs + "published").Value, out var published))
{
log.LogDebug("Invalid entry data -- missing published date.");
continue;
}
var raw = entry.Element(bs + "summary").Value;
var post = StackFunctions.Slackify(raw);
var userLink = entry.Element(bs + "author").Element(bs + "uri").Value ?? string.Empty;
var match = Regex.Match(userLink, $"https://{feed.Site}.stackexchange.com/users/([0-9]+)");
var user = default(StackUser);
if (match.Success)
{
var userData = client.GetStringAsync($"https://api.stackexchange.com/2.2/users/{match.Groups[1].Value}?site={feed.Site}&key=MYe90O9jVj1YJI12XqK0BA((&filter=!)RwdAtHo34gjVfkkY.BZV4L(").Result;
var stackData = JsonConvert.DeserializeObject <StackApiResponse <StackUser> >(userData);
if (string.IsNullOrEmpty(stackData.ErrorMessage) && stackData.Items.Any())
{
user = stackData.Items[0];
}
}
var attachments = new[]
{
new
{
mrkdwn_in = new string[] { "text", "fields" },
title = entry.Element(bs + "title")?.Value ?? string.Empty,
title_link = id,
text = post,
thumb_url = feed.LogoUri.AbsoluteUri,
author_name = user?.DisplayName ?? string.Empty,
author_link = user?.Link?.AbsoluteUri ?? string.Empty,
author_icon = user?.ProfileImage?.AbsoluteUri ?? string.Empty,
fields = entry.Elements(bs + "category").Select(tag => new { value = $"`{tag.Attribute("term").Value}`", @short = true }),
ts = new DateTimeOffset(published).ToUnixTimeSeconds()
}
};
foreach (var channel in team.Subscriptions[job.Feed])
{
var data = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "as_user", "false" },
{ "username", "Slack Stack Feed" },
{ "token", team.BotToken },
{ "channel", channel },
{ "text", $"New Question Posted to: <{feed.Uri}| *{feed.Name}*>." },
{ "unfurl_links", "false" },
{ "unfurl_media", "false" },
{ "attachments", JsonConvert.SerializeObject(attachments, new JsonSerializerSettings {
Formatting = Formatting.Indented
}) }
});
var response = client.PostAsync("https://slack.com/api/chat.postMessage", data).Result;
response.EnsureSuccessStatusCode();
}
team.Posted.Add(id);
}
}
}
// Only keep the last 30 posts we sent, to avoid filling up DocumentDB storage.
team.Posted = team.Posted.Skip(team.Posted.Count - 30).ToList();
}
catch (Exception ex)
{
log.LogDebug(ex.ToString());
}
}
