public bool Execute(ProcessedMatchEntity processedMatch)
        {
            bool tweetSent = false;

            try
            {
                _logger.LogMessage(string.Format("{0} execution started - {1}", this.GetType().Name, DateTime.Now));

                tweetSent = _twitterService.SendTweet(processedMatch.Tweet);

                _logger.LogMessage(
                    string.Format("Tweet {0}sent for [{1}] vs [{2}] on [{3}] with interest level [{4}]",
                                  tweetSent ? "" : "NOT ",
                                  processedMatch.Match.HomeTeam,
                                  processedMatch.Match.AwayTeam,
                                  processedMatch.Match.StartTime,
                                  processedMatch.MatchInterest));

                _logger.LogMessage(string.Format("{0} finished successfully - {1}", this.GetType().Name, DateTime.Now));
            }
            catch (Exception ex)
            {
                _logger.LogMessage(string.Format("{0} error occurred - {1}", this.GetType().Name, ex.Message), true);
            }

            return(tweetSent);
        }
Exemplo n.º 2
0
        public void Execute(ProcessedMatchEntity processedMatch)
        {
            try
            {
                _logger.LogMessage(string.Format("{0} execution started - {1}", this.GetType().Name, DateTime.Now));

                _database.UpdateMatchTwitterStatus(processedMatch.Match.MatchId, processedMatch.Match.TweetSent, processedMatch.MatchInterest);

                _logger.LogMessage(string.Format("{0} finished successfully - {1}", this.GetType().Name, DateTime.Now));
            }
            catch (Exception ex)
            {
                _logger.LogMessage(string.Format("{0} error occurred - {1}", this.GetType().Name, ex.Message), true);
            }
        }
        public string Execute(ProcessedMatchEntity match)
        {
            string tweet = null;

            try
            {
                _logger.LogMessage(string.Format("{0} execution started - {1}", this.GetType().Name, DateTime.Now));

                tweet = _tweetBuilder.BuildTweet(match.MatchInterest, match.Match);

                _logger.LogMessage(string.Format("Tweet built with message - {0} on {1}", tweet, DateTime.Now));
                _logger.LogMessage(string.Format("{0} finished successfully - {1}", this.GetType().Name, DateTime.Now));
            }
            catch (Exception ex)
            {
                _logger.LogMessage(string.Format("{0} error occurred - {1}", this.GetType().Name, ex.Message), true);
            }

            return(tweet);
        }
Exemplo n.º 4
0
        public void Execute()
        {
            if (_logger != null &&
                _twitterService != null &&
                _footballAPI != null &&
                _database != null &&
                _tweetBuilder != null)
            {
                _logger.LogMessage(string.Format("Processing started on {0}", DateTime.Now));

                var sessionValues = new WorkflowSessionValues();
                sessionValues.ContinueProcessing = true;
                sessionValues.ProcessedMatches   = new List <ProcessedMatchEntity>();              //TODO: move this to the session value getter, changed during debug
                sessionValues.MatchesToProcess   = new Queue <MatchEntity>();

                sessionValues.LastCheckedDate = _getLastMatchCheckTimeStep.Execute();

                if (sessionValues.LastCheckedDate.Day != DateTime.Now.Day)
                {
                    sessionValues.MatchWindowStartDate = DateTime.Now.AddDays(-130);                     //TODO: set for lastCheckedDate after testing
                    sessionValues.MatchWindowEndDate   = DateTime.Now;

                    sessionValues.MatchesToProcess = _getMatchesFromAPIStep.Execute(sessionValues.CompetitionId, sessionValues.MatchWindowStartDate, sessionValues.MatchWindowEndDate);

                    if (sessionValues.MatchesToProcess != null && sessionValues.MatchesToProcess.Any())
                    {
                        //TODO: if this fails we need to stop processing
                        _persistMatchesToDatabaseStep.Execute(sessionValues.MatchesToProcess);
                    }
                }

                //get matches that are before our search window but we haven't sent tweets for yet
                var matchesFromDB = _getMatchesToSearchFromDatabaseStep.Execute();

                if (matchesFromDB != null && matchesFromDB.Any())
                {
                    foreach (var match in matchesFromDB)
                    {
                        if (!sessionValues.MatchesToProcess.Any(x => x.MatchId == match.MatchId))
                        {
                            sessionValues.MatchesToProcess.Enqueue(match);
                        }
                    }
                }

                if (sessionValues != null && sessionValues.MatchesToProcess.Any())
                {
                    foreach (var match in sessionValues.MatchesToProcess)
                    {
                        //TODO: if we've already figured out the interest, only try to send the tweet
                        var matchInProcess = new ProcessedMatchEntity {
                            Match = match
                        };

                        //all to just get the full time score...
                        matchInProcess.Match = _getMatchScoreFromAPIStep.Execute(match);

                        if (matchInProcess.Match.Score == null)
                        {
                            _logger.LogMessage(string.Format("Processing failed with no match score on {0}", DateTime.Now));
                        }

                        matchInProcess.MatchStats = _getMatchStatsFromAPIStep.Execute(match);

                        if (matchInProcess.MatchStats == null)
                        {
                            _logger.LogMessage(string.Format("Processing completed with no match stats on {0}", DateTime.Now));
                        }

                        matchInProcess.MatchInterest = _processMatchStatsStep.Execute(matchInProcess.MatchStats);

                        if (matchInProcess.MatchInterest == InterestLevel.Unknown)
                        {
                            _logger.LogMessage(string.Format("Processing failed with MatchInterest Unknown on {0}", DateTime.Now));
                        }

                        matchInProcess.Tweet = _buildMatchTweetStep.Execute(matchInProcess);

                        if (string.IsNullOrEmpty(matchInProcess.Tweet))
                        {
                            _logger.LogMessage(string.Format("Processing failed with emtpy Tweet on {0}", DateTime.Now));
                        }

                        if (_sendMatchTweetStep.Execute(matchInProcess))
                        {
                            _updateMatchTwitterStatusStep.Execute(matchInProcess);
                        }

                        sessionValues.ProcessedMatches.Add(matchInProcess);
                    }
                }

                _logger.LogMessage(string.Format("Processing completed on {0}", DateTime.Now));
            }
            else
            {
                throw new Exception("One or more dependencies were null");
            }
        }