private async Task <string> GetCurrentSubscriptions(string teamId, AppMentionEvent appMentioned)
{
try
{
var team = await _teamRepo.GetTeam(teamId);
var currentSubscriptions = team.Subscriptions;
if (currentSubscriptions.Count() < 1)
{
return("You are not subscribing to any fplbot updates :disappointed:");
}
var sb = new StringBuilder();
sb.Append("This channel will receive notifications for: \n");
sb.Append($"{Formatter.BulletPoints(team.Subscriptions)}");
return(sb.ToString());
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
return($"Oops, could not get subscriptions.");
}
}
public async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent slackEvent)
{
string mentionTextStripped = Regex.Replace(slackEvent.Text, "<@(\\w+)>", "$1");
await _session.Publish(new UnknownAppMentionReceived(eventMetadata.Team_Id, slackEvent.User, mentionTextStripped));
return(new EventHandledResponse("OK"));
}
private async Task <string> GetAndUpdateSubscriptionInfo(string teamId, AppMentionEvent appMentioned)
{
try
{
var team = await _teamRepo.GetTeam(teamId);
var currentSubscriptions = team.Subscriptions;
(var inputSubscriptions, var unableToParse) = ParseSubscriptionsFromInput(appMentioned);
if (inputSubscriptions.Count() < 1 && unableToParse.Count() < 1)
{
return($"You need to pass some arguments\n {FormatAllSubsAvailable()}");
}
if (inputSubscriptions.Count() < 1)
{
return($"I was not able to understand: *{string.Join(", ", unableToParse)}.* :confused: \n {FormatAllSubsAvailable()}");
}
var newSubscriptions = appMentioned.Text.Contains("unsubscribe") ?
UnsubscribeToEvents(inputSubscriptions, currentSubscriptions) :
SubscribeToEvents(inputSubscriptions, currentSubscriptions);
await _teamRepo.UpdateSubscriptions(teamId, newSubscriptions);
return(FormatSubscriptionMessage(newSubscriptions, unableToParse));
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
return($"Oops, could not update subscriptions.");
}
}
/// <summary>
/// @smartbot tell @john bull hop stuff
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task <EventHandledResponse> Handle(EventMetaData data, AppMentionEvent message)
{
var args = message.Text.Split(' ');
var recipient = message.Channel;
var content = "Psst";
if (args.Length == 2)
{
content = "lol, du må gi meg et navn å sende til..`@smartbot tell @nash du er en tufs`";
}
if (args.Length == 3)
{
content = "lol, du må gi meg noe innhold å sende! `@smartbot tell @nash du er en tufs`";
}
if (args.Length > 3)
{
var parsedName = args[2];
var users = await _slackClient.UsersList();
var usr = users.Members.FirstOrDefault(u => $"<@{u.Id}>" == parsedName);
var channels = await _slackClient.ConversationsListPublicChannels();
var channel = channels.Channels.FirstOrDefault(c => string.Equals($"<#{c.Id}|{c.Name}>", parsedName, StringComparison.InvariantCultureIgnoreCase));
content = string.Join(" ", args[3..args.Length]);
public async Task <EventHandledResponse> Handle(EventMetaData data, AppMentionEvent message)
{
var index = new Random().Next(_smartinger.Smartingene.Count);
var randomSmarting = _smartinger.Smartingene[index];
await _client.ChatPostMessage(message.Channel, randomSmarting.Name);
return(new EventHandledResponse("OK"));
}
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 Handle(EventMetaData eventMetadata, AppMentionEvent @event)
{
var text = _handlers.Select(handler => handler.GetHelpDescription())
.Where(desc => !string.IsNullOrEmpty(desc.HandlerTrigger))
.Aggregate("*HALP:*", (current, tuple) => current + $"\n• `{tuple.HandlerTrigger}` : _{tuple.Description}_");
var token = await _tokenStore.GetTokenByTeamId(eventMetadata.Team_Id);
var slackClient = _slackClientService.Build(token);
await slackClient.ChatPostMessage(@event.Channel, text);
}
public IEventReaction Generate(
EventWrapper eventWrapper)
{
if (eventWrapper.Event == null)
{
throw new InvalidOperationException(
"EventWrapper does not hold any callback event");
}
return(eventWrapper.Event switch
{
AppMentionEvent _ => _appMentionEventReactionFactory.Create(
eventWrapper),
_ => _noopEventReactionFactory.Create(eventWrapper),
});
public async Task <EventHandledResponse> Handle(EventMetaData data, AppMentionEvent message)
{
var unanswered = await _inviter.SendRemindersToUnanswered();
if (unanswered.Any())
{
var uText = unanswered.Select(u => $"Reminded {u.SlackUsername} to RSVP {u.EventTopic}");
var aggr = $"{uText.Aggregate((x, y) => x + "\n" + y)}";
await _client.ChatPostMessage(message.Channel, aggr);
}
else
{
await _client.ChatPostMessage(message.Channel, $"No unanswered invites or no existing invites for next storsdag");
}
return(new EventHandledResponse("OK"));
}
public Task Handle(EventMetaData eventMetadata, AppMentionEvent @event)
{
var publicHandlersToBeListedBack = _handlers.Where(handler => handler.GetHelpDescription().HandlerTrigger != string.Empty)
.Aggregate("*Public trigger mentions*", (current, kvPair) => current + $"\n• `{kvPair.GetType()}. `{kvPair.GetHelpDescription().HandlerTrigger}` : _{kvPair.GetHelpDescription().Description}_");
Console.WriteLine(publicHandlersToBeListedBack);
var ssh = _handlers.Where(handler => handler.GetHelpDescription().HandlerTrigger == string.Empty)
.Aggregate("*Private trigger handlers*", (current, kvPair) => current + $"\n• `{kvPair.GetType()}`");
Console.WriteLine(ssh);
return(Task.CompletedTask);
}
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 <EventHandledResponse> Handle(EventMetaData data, AppMentionEvent message)
{
var nextStorsdag = await _eventStorage.GetNextEvent(EventTypes.StorsdagEventType);
var invitations = await _inviteStorage.GetInvitations(nextStorsdag.RowKey);
var rapport = nextStorsdag.Topic;
foreach (var inviteGroup in invitations.GroupBy(i => i.Rsvp))
{
string names = inviteGroup.Select(i => i.SlackUsername).Aggregate((x, y) => x + ", " + y);
rapport += $"\n• `{inviteGroup.Key}` : {names}";
}
await _client.ChatPostMessage(message.Channel, rapport);
return(new EventHandledResponse("OK"));
}
public async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent slackEvent)
{
var debugDetails = MetaService.DebugInfo();
var debugInfo = $"▪️ v{debugDetails.MajorMinorPatch}\n" +
$"▪️ {debugDetails.Informational}\n";
var releaseNotes = await GitHubReleaseService.GetReleaseNotes(debugDetails.MajorMinorPatch);
if (!string.IsNullOrEmpty(releaseNotes))
{
debugInfo += releaseNotes;
}
else if (debugDetails.Sha != "0")
{
debugInfo += $"️▪️ <https://github.com/fplbot/fplbot/tree/{debugDetails.Sha}|{debugDetails.Sha?.Substring(0, debugDetails.Sha.Length - 1)}>\n";
}
await _session.Send("FplBot.EventHandlers.Slack", new PublishToSlack(eventMetadata.Team_Id, slackEvent.Channel, debugInfo));
return(new EventHandledResponse("OK"));
}
public void Write_Returns_Expected_AppMentionEvent()
{
var @event = new AppMentionEvent
{
ChannelId = "channel",
Text = "text",
CallbackEventType = AppMentionEvent.CallbackEventTypeValue,
UserId = "user",
MessageId = new Timestamp
{
Suffix = "006", Seconds = 123456,
},
EventTimestamp = new Timestamp
{
Suffix = "006", Seconds = 123456,
},
};
Serialize(@event)
.ShouldMatchSnapshot();
}
public void OnlyExpectedSupportedHandlersShouldHandleCommand(string input, Type expectedSupportedHandler)
{
// Arrange
var mentionEvent = new AppMentionEvent {
Text = input
};
// Act / assert
foreach (var handler in _allHandlers)
{
var handlerShouldHandleCommand = handler.ShouldHandle(mentionEvent);
var handlerIsExpectedSupportedHandler = handler.GetType() == expectedSupportedHandler;
if (handlerIsExpectedSupportedHandler)
{
Assert.True(handlerShouldHandleCommand, $"{handler.GetType().Name} should've handled \"{input}\", but it didn't");
}
else
{
Assert.False(handlerShouldHandleCommand, $"{handler.GetType().Name} shouldn't handle \"{input}\"");
}
}
}
public async Task <EventHandledResponse> Handle(EventMetaData data, AppMentionEvent message)
{
var messageText = message.Text.Replace($"wolf ", "");
var wolfram = new WolframAlpha(_options.Value.WulframAlphaAppId);
var results = wolfram.Query(messageText);
var text = "";
if (results != null)
{
foreach (var pod in results.Pods)
{
if (pod.SubPods != null)
{
foreach (var subPod in pod.SubPods)
{
if (!string.IsNullOrEmpty(subPod.Title))
{
text += $"•{subPod.Title}\n";
}
text += $"{subPod.Plaintext} \n";
text += $"\n";
}
}
}
}
if (string.IsNullOrEmpty(text))
{
text = "Wulf aner ikke 🐺";
}
await _client.ChatPostMessage(message.Channel, text);
return(new EventHandledResponse("OK"));
}
protected string ParseArguments(AppMentionEvent message) => MessageHelper.ExtractArgs(message.Text, Commands.Select(c => $"{c} {{args}}").ToArray());
public virtual bool ShouldHandle(AppMentionEvent slackEvent) => Commands.Any(c => slackEvent.Text.TextAfterFirstSpace().StartsWith(c, StringComparison.InvariantCultureIgnoreCase));
public abstract Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent slackEvent);
public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent message)
{
var globalSettings = await _globalSettingsClient.GetGlobalSettings();
var allPlayers = globalSettings.Players;
var teams = globalSettings.Teams;
var priceChangedPlayers = allPlayers.Where(p => p.CostChangeEvent != 0 && p.IsRelevant())
.Select(p =>
{
var t = teams.First(t => t.Code == p.TeamCode);
return(new PlayerWithPriceChange(p.Id, p.WebName, p.CostChangeEvent, p.NowCost, p.OwnershipPercentage, t.Id, t.ShortName));
});
if (priceChangedPlayers.Any())
{
var messageToSend = Formatter.FormatPriceChanged(priceChangedPlayers);
await _workSpacePublisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, messageToSend);
}
else
{
await _workSpacePublisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, "No relevant price changes yet");
}
return(new EventHandledResponse("Ok"));
}
public bool ShouldHandle(AppMentionEvent message) => message.User == "johnkors" && message.Text.Contains("storsdagreminder");
public bool ShouldHandle(AppMentionEvent slackEvent) => slackEvent.Text.Contains("debug");
public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent appMentioned)
{
var team = await _teamRepo.GetTeam(eventMetadata.Team_Id);
var settings = await _globalSettingsClient.GetGlobalSettings();
var gameweek = settings.Gameweeks.GetCurrentGameweek();
await _mediator.Publish(new PublishStandingsCommand(team, gameweek));
return(new EventHandledResponse("OK"));
}
public bool ShouldHandle(AppMentionEvent slackEvent) => slackEvent.Text == "test";
public bool ShouldHandle(AppMentionEvent message) => Contains(message.Text, "wolf");
public async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent slackEvent)
{
await _session.SendLocal(new PublishToSlack("T0A9QSU83", "#fplbot-notifications", $"Unhandled app_mention:\n * [{eventMetadata.Team_Id}-{slackEvent.User}] \"{slackEvent.Text}\""));
return(new EventHandledResponse("OK"));
}
public bool ShouldShortcut(AppMentionEvent @event) => @event.Text.Contains("help");
public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent slackEvent)
{
var team = await _tokenStore.GetTeam(eventMetadata.Team_Id);
var slackClient = _slackClientService.Build(team.AccessToken);
var usersTask = slackClient.UsersList();
var settings = await _globalSettingsClient.GetGlobalSettings();
var users = await usersTask;
var gameweeks = settings.Gameweeks;
var teams = settings.Teams;
var nextGw = gameweeks.First(gw => gw.IsNext);
var fixtures = await _fixtureClient.GetFixturesByGameweek(nextGw.Id);
var user = users.Members.FirstOrDefault(x => x.Id == slackEvent.User);
var userTzOffset = user?.Tz_Offset ?? 0;
var textToSend = Formatter.FixturesForGameweek(nextGw.Id, nextGw.Name, nextGw.Deadline, fixtures, teams, userTzOffset);
await _workspacePublisher.PublishToWorkspace(eventMetadata.Team_Id, slackEvent.Channel, textToSend);
return(new EventHandledResponse(textToSend));
}
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 <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent slackEvent)
{
Console.WriteLine("Doing stuff from AppmentionHandler: " + JsonConvert.SerializeObject(slackEvent));
return(Task.FromResult(new EventHandledResponse("Wrote stuff to log")));
}
