public Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppHomeOpenedEvent payload)
        {
            string json = JsonConvert.SerializeObject(payload);

            Console.WriteLine(json);
            return(Task.FromResult(new EventHandledResponse(json)));
        }
Ejemplo n.º 2
0
    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"));
    }
Ejemplo n.º 3
0
        /// <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]);
Ejemplo n.º 4
0
    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"));
    }
Ejemplo n.º 5
0
        public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent incomingMessage)
        {
            var isChartRequest = incomingMessage.Text.Contains("chart");

            var gwPattern = $"{Commands.First()} {{gw}}";

            if (isChartRequest)
            {
                gwPattern = $"{Commands.First()} chart {{gw}}|{Commands.First()} {{gw}} chart";
            }
            var gameWeek = await _gameweekHelper.ExtractGameweekOrFallbackToCurrent(incomingMessage.Text, gwPattern);

            if (!gameWeek.HasValue)
            {
                await _workspacePublisher.PublishToWorkspace(eventMetadata.Team_Id, incomingMessage.Channel, "Invalid gameweek :grimacing:");

                return(new EventHandledResponse("Invalid gameweek"));
            }

            var setup = await _slackTeamsRepo.GetTeam(eventMetadata.Team_Id);

            var outgoingMessage = isChartRequest ?
                                  await _captainsByGameWeek.GetCaptainsChartByGameWeek(gameWeek.Value, (int)setup.FplbotLeagueId) :
                                  await _captainsByGameWeek.GetCaptainsByGameWeek(gameWeek.Value, (int)setup.FplbotLeagueId);

            await _workspacePublisher.PublishToWorkspace(eventMetadata.Team_Id, incomingMessage.Channel, outgoingMessage);

            return(new EventHandledResponse(outgoingMessage));
        }
Ejemplo n.º 6
0
    public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent message)
    {
        var gameweek = await _gameweekHelper.ExtractGameweekOrFallbackToCurrent(message.Text, $"{CommandsFormatted} {{gw}}");


        var team = await _slackTeamRepo.GetTeam(eventMetadata.Team_Id);

        var messageToSend = "You don't follow any league yet. Use the `@fplbot follow` command first.";

        if (team.FplbotLeagueId.HasValue)
        {
            try
            {
                messageToSend =
                    await _transfersClient.GetTransfersByGameweekTexts(gameweek ?? 1, team.FplbotLeagueId.Value);
            }
            catch (HttpRequestException e) when(e.Message.Contains("429"))
            {
                messageToSend = "It seems fetching transfers was a bit heavy for this league. Try again later. ­ЪциРђЇ№ИЈ";
            }
        }

        await _workSpacePublisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, messageToSend);

        return(new EventHandledResponse(messageToSend));
    }
Ejemplo n.º 7
0
        public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent message)
        {
            var globalSettings = await _globalSettingsClient.GetGlobalSettings();

            var players = globalSettings.Players;
            var teams   = globalSettings.Teams;

            var name = ParseArguments(message);

            var allPlayers = players.OrderByDescending(player => player.OwnershipPercentage);
            var mostPopularMatchingPlayer = FindMostPopularMatchingPlayer(allPlayers.ToArray(), name);

            if (mostPopularMatchingPlayer == null)
            {
                await _workSpacePublisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, $"Couldn't find {name}");

                return(new EventHandledResponse($"Found no matching player for {name}: "));
            }

            var playerName = $"{mostPopularMatchingPlayer.FirstName} {mostPopularMatchingPlayer.SecondName}";

            await _workSpacePublisher.PublishToWorkspace(eventMetadata.Team_Id, new ChatPostMessageRequest
            {
                Channel = message.Channel,
                Blocks  = Formatter.GetPlayerCard(mostPopularMatchingPlayer, teams)
            });

            return(new EventHandledResponse($"Found matching player for {name}: " + playerName));
        }
Ejemplo n.º 8
0
    public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent appMentioned)
    {
        var subscriptionInfo = await GetAndUpdateSubscriptionInfo(eventMetadata.Team_Id, appMentioned);

        await _workspacePublisher.PublishToWorkspace(eventMetadata.Team_Id, appMentioned.Channel, subscriptionInfo);

        return(new EventHandledResponse(subscriptionInfo));
    }
Ejemplo n.º 9
0
        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"));
        }
Ejemplo n.º 10
0
        private static string SerializeMetaData(IDomainEvent @event)
        {
            var metaData = new EventMetaData
            {
                EventType = @event.GetType().AssemblyQualifiedName
            };

            return(JsonConvert.SerializeObject(metaData));
        }
Ejemplo n.º 11
0
        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);
        }
Ejemplo n.º 12
0
        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"));
        }
Ejemplo n.º 13
0
            public void Received(SensorOnline @event, EventMetaData metaData)
            {
                _uptimeReporter.Up(metaData.TimeStamp);

                var timeOffline = _uptimeReporter.OnlineAt.Subtract(_uptimeReporter.OfflineAt).TotalSeconds;

                if (timeOffline < THRESHOLD_IN_SECONDS)
                {
                    _eventStream.Process(new IntermittentSensor(@event.Name));
                }
            }
Ejemplo n.º 14
0
        /// <summary>
        /// Gain the specified amount of armor.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="armor"></param>
        public void GainArmor(IPlayable source, int armor)
        {
            Game.Log(LogLevel.INFO, BlockType.ACTION, "Character", !Game.Logging? "":$"{this} gaining armor for {armor}.");
            Armor += armor;
            EventMetaData temp = Game.CurrentEventData;

            Game.CurrentEventData = new EventMetaData(source, this, armor);
            Game.TriggerManager.OnArmorTrigger(this);
            //Game.ProcessTasks();
            Game.CurrentEventData = temp;
        }
Ejemplo n.º 15
0
        public Task <NewStreamMessage> SerializeEvent(Event @event)
        {
            var type     = @event.GetType();
            var typeName = type.FullName;

            var serializedEvent = JsonSerializer.Serialize(@event, type);

            var metaData           = new EventMetaData(@event);
            var serializedMetaData = JsonSerializer.Serialize(metaData, typeof(EventMetaData));

            return(Task.FromResult(new NewStreamMessage(@event.EventId, typeName, serializedEvent, serializedMetaData)));
        }
Ejemplo n.º 16
0
    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}"));
    }
Ejemplo n.º 17
0
        public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent message)
        {
            var gameweek = await _gameweekHelper.ExtractGameweekOrFallbackToCurrent(message.Text, $"{CommandsFormatted} {{gw}}");


            var team = await _slackTeamRepo.GetTeam(eventMetadata.Team_Id);

            var messageToSend = await _transfersClient.GetTransfersByGameweekTexts(gameweek ?? 1, (int)team.FplbotLeagueId);


            await _workSpacePublisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, messageToSend);

            return(new EventHandledResponse(messageToSend));
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Heal a specified amount of health.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="heal"></param>
        public void TakeHeal(IPlayable source, int heal)
        {
            //	TODO: Power Word: Glory interaction https://hearthstone.gamepedia.com/Healing#Advanced_rules
            if ((source is Spell || source is HeroPower) && source.Controller.ControllerAuraEffects[GameTag.HEALING_DOUBLE] > 0)
            {
                heal *= (int)Math.Pow(2, source.Controller.ControllerAuraEffects[GameTag.HEALING_DOUBLE]);
            }

            if (source.Controller.ControllerAuraEffects[GameTag.RESTORE_TO_DAMAGE] == 1)
            {
                if (_lifestealChecker)
                {
                    return;
                }

                _lifestealChecker = true;
                TakeDamage(source, heal);
                _lifestealChecker = false;
                return;
            }
            // we don't heal undamaged entities
            if (Damage == 0)
            {
                return;
            }

            int amount = Damage > heal ? heal : Damage;

            if (Game.Logging)
            {
                Game.Log(LogLevel.INFO, BlockType.ACTION, "Character", $"{this} took healing for {amount}.");
            }
            Damage -= amount;

            // Heal event created
            // Process gathered tasks
            Game.TaskQueue.StartEvent();
            EventMetaData temp = Game.CurrentEventData;

            Game.CurrentEventData = new EventMetaData(source, this, amount);
            Game.TriggerManager.OnHealTrigger(this);
            Game.ProcessTasks();
            Game.TaskQueue.EndEvent();
            Game.CurrentEventData = temp;

            if (this is Hero)
            {
                Controller.AmountHeroHealedThisTurn += amount;
            }
        }
Ejemplo n.º 19
0
        private EventData SeralizeEvent <T>(T @event) where T : Event
        {
            var type     = @event.GetType();
            var typeName = type.FullName;

            var serializedEvent = JsonSerializer.Serialize(@event, type);
            var dataBytes       = Encoding.UTF8.GetBytes(serializedEvent);

            var metaData           = new EventMetaData(@event);
            var serializedMetaData = JsonSerializer.Serialize(metaData, typeof(EventMetaData));
            var metaDataBytes      = Encoding.UTF8.GetBytes(serializedMetaData);

            return(new EventData(@event.EventId, typeName, true, dataBytes, metaDataBytes));
        }
Ejemplo n.º 20
0
        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));
            }
        }
Ejemplo n.º 21
0
    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();

        if (team.HasChannelAndLeagueSetup())
        {
            await _session.Send("FplBot.EventHandlers.Slack", new PublishStandingsToSlackWorkspace(team.TeamId, appMentioned.Channel, team.FplbotLeagueId.Value, gameweek.Id));
        }

        return(new EventHandledResponse("OK"));
    }
Ejemplo n.º 22
0
        public override async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent message)
        {
            var globalSettings = await _globalSettingsClient.GetGlobalSettings();

            var injuredPlayers = FindInjuredPlayers(globalSettings.Players);

            var textToSend = Formatter.GetInjuredPlayers(injuredPlayers);

            if (string.IsNullOrEmpty(textToSend))
            {
                return(new EventHandledResponse("Not found"));
            }
            await _workspacePublisher.PublishToWorkspace(eventMetadata.Team_Id, message.Channel, textToSend);

            return(new EventHandledResponse(textToSend));
        }
Ejemplo n.º 23
0
        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"));
        }
Ejemplo n.º 24
0
        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);
        }
Ejemplo n.º 25
0
    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 });
    }
Ejemplo n.º 26
0
        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"));
        }
Ejemplo n.º 27
0
    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"));
    }
Ejemplo n.º 28
0
        internal static EventData ToEvent <T>(this T value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }

            var json      = JsonConvert.SerializeObject(value);
            var data      = Encoding.UTF8.GetBytes(json);
            var eventName = value.GetType().FullName;

            var metadata = new EventMetaData
            {
                TimeStamp = DateTime.UtcNow
            };

            var metadataJson = JsonConvert.SerializeObject(metadata);

            return(new EventData(Guid.NewGuid(), eventName, true, data, Encoding.UTF8.GetBytes(metadataJson)));
        }
Ejemplo n.º 29
0
        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());

            if (priceChangedPlayers.Any())
            {
                var messageToSend = Formatter.FormatPriceChanged(priceChangedPlayers, teams);
                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"));
        }
Ejemplo n.º 30
0
            public void Transform(TweetReceived @event, EventMetaData metaData)
            {
                var usersMentioned = Regex.Matches(@event.Message, _userPattern)
                                     .Cast <Match>()
                                     .Select(m => new UserMentioned(@event.MessageId, m.Value))
                                     .ToArray();

                var topicsMentioned = Regex.Matches(@event.Message, _topicPattern)
                                      .Cast <Match>()
                                      .Select(m => new TopicMentioned(@event.MessageId, m.Value))
                                      .ToArray();

                foreach (var u in usersMentioned)
                {
                    _eventStream.Process(u);
                }
                foreach (var t in topicsMentioned)
                {
                    _eventStream.Process(t);
                }
            }