private void SetPlayer1(
ExaminationEvent result,
IList <string> words)
{
LogTrace("SetPlayer1");
for (int i = 0; i < words.Count - 1; i++)
{
var playerFirstName = words[i];
if (NotAName(playerFirstName))
{
continue;
}
var playerLastName = words[i + 1];
if (NotAName(playerLastName))
{
continue;
}
var playerName = $"{playerFirstName} {playerLastName}";
LogTrace($"Calling Service to find {playerName}");
var p = TflService.GetNflPlayer(
playerFirstName,
playerLastName);
if (p != null)
{
result.PlayerId = p.PlayerCode;
result.PlayerFirstName = playerFirstName;
result.PlayerLastName = playerLastName;
result.PlayerName = playerName;
break;
}
}
}
private ExaminationEvent PurifyTheText(
NewsArticleCommand article,
ExaminationEvent result)
{
// get rid of the full stop at the end
if (article.ArticleText.Substring(Math.Max(0, article.ArticleText.Length - 1)) == ".")
{
article.ArticleText = article.ArticleText.Substring(0, article.ArticleText.Length - 1);
}
// get rid of commas
article.ArticleText = article.ArticleText.Replace(",", string.Empty);
// get rid of the term exclusive rights free agent
article.ArticleText = article.ArticleText.Replace("exclusive rights free agent ", string.Empty);
// get rid of the term restricted free agent
article.ArticleText = article.ArticleText.Replace("restricted free agent ", string.Empty);
// Treat "agreed to terms with" as "signed"
article.ArticleText = article.ArticleText.Replace("agreed to terms with", "signed");
// Treat "has agreed to a pay cut signing" as "signed"
article.ArticleText = article.ArticleText.Replace("has agreed to a pay cut signing", "is signing");
// Treat "re-signed" as "signed"
article.ArticleText = article.ArticleText.Replace("re-signed", "signed");
// Treat "claimed" as "signed"
article.ArticleText = article.ArticleText.Replace("claimed", "signed");
// Treat "has retired" as "is retiring"
article.ArticleText = article.ArticleText.Replace("has retired", "is retiring");
// Treat "waived/failed physical" as "waived"
article.ArticleText = article.ArticleText.Replace("waived/failed physical", "waived");
// Treat "waived/released" as "waived"
article.ArticleText = article.ArticleText.Replace("waived/released", "waived");
// Get rid of the positions
article.ArticleText = StripOutPositions(article.ArticleText, result);
// remove possessives
article.ArticleText = article.ArticleText.Replace("'s", "");
return(result);
}
private void LogResult(
ExaminationEvent result)
{
LogInfo($@"Result: {
result.RecommendedAction
} : {result.ArticleText}" );
}
public bool Process(
ExaminationEvent transactionEvent,
ILog logger)
{
var p = TflService.GetNflPlayer(transactionEvent.PlayerId);
var eventDate = transactionEvent.EventDate
?? transactionEvent.ExaminationDateTime;
if (TflService.IsSameDay(p, eventDate))
{
logger.Info($@"Signing for {
p.PlayerName
} ignored: Same day contract rule" );
return(false);
}
if (!string.IsNullOrEmpty(p.TeamCode))
{
// end his previous team contract
TflService.EndContract(
p,
when: eventDate,
isRetirement: false);
}
// start new contract
return(transactionEvent.EventDate != null &&
TflService.RecordSigning(
p,
teamCode: transactionEvent.TeamId,
when: (DateTime)transactionEvent.EventDate,
how: "FA"));
}
private void NewMethodSetPosition(string articleText, ExaminationEvent result)
{
for (int i = 0; i < Positions.Length; i++)
{
var pos = Positions[i] + " ";
if (articleText.Contains(pos))
{
result.Position = Positions[i];
}
}
}
private void ResultIsRetirement(
ExaminationEvent result,
int wordIndex,
IList <string> words)
{
result.IsCut = false;
result.IsWaiver = false;
result.IsSigning = false;
result.IsRetirement = true;
result.RecommendedAction = Result.Retired;
SetPlayer(result, words);
}
public bool ProcessEvent(ExaminationEvent transactionEvent)
{
Log.Trace($"Processing: {transactionEvent}");
if (!ProcessingStrategies[transactionEvent.RecommendedAction]
.Process(transactionEvent, Log))
{
return(true);
}
Log.Trace($"Handled: {transactionEvent}");
ProcessCount++;
return(true);
}
private ExaminationEvent FindPlayerNameByTeam(
ExaminationEvent result,
string articleText)
{
var words = articleText.Split(' ');
for (var i = 0; i < words.Length; i++)
{
var word = words[i];
if (WordIsTeamWord(word))
{
SetPlayer(result, words);
SetTeam(result, i, words, 0);
}
}
return(result);
}
private void SetTeam(
ExaminationEvent result,
int wordIndex,
IList <string> words,
int offset)
{
LogTrace("SetTeam");
try
{
result.TeamName = words[wordIndex - offset];
result.TeamId = GetTeamCodeFor(words[wordIndex - offset]);
}
catch (ArgumentOutOfRangeException)
{
result.TeamName = "???";
result.TeamId = "??";
}
LogTrace($"SetTeam to {result.TeamName}");
}
private void ResultIsCut(
ExaminationEvent result,
int wordIndex,
IList <string> words)
{
result.IsCut = true;
result.IsWaiver = false;
result.IsSigning = false;
result.IsRetirement = false;
SetPlayer(result, words);
SetTeam(result, wordIndex, words);
if (string.IsNullOrEmpty(result.PlayerId))
{
result.RecommendedAction = Result.Ignore;
}
else
{
result.RecommendedAction = Result.Cut;
}
}
public bool Process(
ExaminationEvent transactionEvent,
ILog logger)
{
var p = TflService.GetNflPlayer(transactionEvent.PlayerId);
if (!string.IsNullOrEmpty(p.TeamCode))
{
TflService.EndContract(
p,
transactionEvent.EventDate
?? transactionEvent.ExaminationDateTime,
isRetirement: false);
}
return(transactionEvent.EventDate != null &&
(TflService.RecordSigning(
p,
transactionEvent.TeamId,
(DateTime)transactionEvent.EventDate,
how: "T")));
}
public void ProcessMessage(
IHandlerContext <NewsArticleCommand> context)
{
try
{
var msg = $@"[ARTICLE RECEIVED] : article = '{
context.Message.ArticleText}'" ;
WriteTraceLog(msg);
Console.WriteLine();
Console.WriteLine(msg);
Console.WriteLine();
var examinationEvent = new ExaminationEvent();
examinationEvent = Examiner.ExamineArticle(context.Message);
WriteTraceLog($"{examinationEvent}");
if (examinationEvent.RecommendedAction != Constants.Result.Ignore)
{
WriteTraceLog($"Processing {examinationEvent.RecommendedAction}");
Manager.ProcessEvent(examinationEvent);
//TODO: raise the event so subscribers might do something
//context.Publish(examinationEvent);
}
else
{
WriteTraceLog($@"{
examinationEvent
} ignored - {
context.Message.ArticleText
}" );
}
}
catch (Exception ex)
{
WriteErrorLog(
$"Article >>{context.Message.ArticleText}<< caused :- {ex.Message}", ex);
throw;
}
}
private void ResultIsSigning(
ExaminationEvent result,
int wordIndex,
IList <string> words)
{
result.IsSigning = true;
result.IsWaiver = false;
result.IsRetirement = false;
result.RecommendedAction
= words[wordIndex].ToUpper() == "SIGNED" ||
words[wordIndex].ToUpper() == "SIGNING" ? "SIGN" : "TRADE";
if (words[wordIndex].ToUpper() == "SIGNED")
{
SetPlayer(result, words);
SetTeam(result, wordIndex, words);
}
else
{
if (result.RecommendedAction == "TRADE")
{
SetPlayer1(result, words);
SetTeam(result, wordIndex, words);
}
else
{
SetPlayer1(result, words);
SetTeam(result, wordIndex, words, 4);
}
}
if (result.TeamId.Equals("??"))
{
result.IsSigning = false;
result.RecommendedAction = Result.Ignore;
}
}
private void SetTeam(
ExaminationEvent result,
int wordIndex,
IList <string> words)
{
LogTrace("SetTeam");
try
{
var possibleTeamName = words[wordIndex - 1];
if (possibleTeamName.Equals("have"))
{
wordIndex--;
possibleTeamName = words[wordIndex - 1];
}
result.TeamName = possibleTeamName;
result.TeamId = GetTeamCodeFor(words[wordIndex - 1]);
}
catch (ArgumentOutOfRangeException)
{
result.TeamName = "???";
result.TeamId = "??";
}
LogTrace($"SetTeam to {result.TeamName}");
}
public ExaminationEvent ExamineArticle(NewsArticleCommand article)
{
LogTrace("----------------------------------");
LogTrace($"Examining {article}");
var result = new ExaminationEvent
{
EventDate = article.ArticleDate,
ExaminationDateTime = DateTime.Now,
ArticleText = article.ArticleText
};
// Offer sheet not official
if (article.ArticleText.ToUpper().Contains("OFFER SHEET"))
{
LogResult(result);
return(result);
}
if (article.IsInDraftSeason())
{
// Draft picks are handled by NFL.EXE
if (article.ArticleText.ToUpper().Contains("OVERALL "))
{
LogResult(result);
return(result);
}
if (article.ArticleText.ToUpper().Contains("ROUND "))
{
// sometime players are aquired in a trade for a late-round pick
if (!article.ArticleText.ToUpper().Contains("LATE-ROUND "))
{
LogResult(result);
return(result);
}
}
}
result = PurifyTheText(article, result);
LogTrace($"Purified {article}");
// Parse the article looking for a key word which triggers hunt
// for a player and optionally team
string[] words = SplitIntoWords(article);
LogTrace($"article contains {words.Length} words");
var previousWord = string.Empty;
for (var i = 0; i < words.Length; i++)
{
var word = words[i];
if (WordIsSigningWord(word))
{
ResultIsSigning(result, i, words);
}
if (WordIsWaiverWord(word))
{
ResultIsWaiver(result, i, words);
}
if (WordIsCutWord(word, previousWord))
{
ResultIsCut(result, i, words);
}
if (WordIsRetirementWord(word))
{
ResultIsRetirement(result, i, words);
}
previousWord = word;
}
// Look for 2 words
if (IsInjury(article.ArticleText))
{
LogTrace("Article is injury");
result.RecommendedAction = "INJURY";
result.IsInjury = true;
result = FindPlayerNameByTeam(result, article.ArticleText);
}
if (result.IsRetirement)
{
LogResult(result);
return(result);
}
// Two words Free Agent
if (article.ArticleText.ToUpper().Contains("FREE AGENT"))
{
LogTrace("Article is about Free agent");
var fawords = article.ArticleText.Split(' ');
for (var i = 0; i < fawords.Length; i++)
{
var word = fawords[i];
if (word.ToUpper() == "AGENT")
{
ResultIsFreeAgent(result, i, fawords);
break;
}
}
}
if (result.RecommendedAction.Equals(Result.Ignore))
{
LogResult(result);
return(result);
}
if (result.PlayerFirstName == null || result.PlayerLastName == null)
{
result.RecommendedAction = Result.Ignore;
}
else
{
if (!result.RecommendedAction.Equals("NEWBIE"))
{
LogTrace($"Asking service for: {result.PlayerFirstName} {result.PlayerLastName}");
var p = TflService.GetNflPlayer(result.PlayerFirstName, result.PlayerLastName);
if (p == null)
{
result.RecommendedAction = Result.Ignore;
}
else
{
result.PlayerId = p.PlayerCode;
}
}
}
LogResult(result);
return(result);
}
private string StripOutPositions(string articleText, ExaminationEvent result)
{
NewMethodSetPosition(articleText, result);
return(Positions.Aggregate(articleText, (current, pos) =>
current.Replace(pos + " ", string.Empty)));
}
private void SetPlayer(
ExaminationEvent result,
IList <string> words)
{
var realFirstName = string.Empty;
var realLastName = string.Empty;
LogTrace("SetPlayer");
for (int i = 0; i < words.Count - 1; i++)
{
var playerFirstName = words[i];
if (NotAName(playerFirstName))
{
continue;
}
var playerLastName = words[i + 1];
if (NotAName(playerLastName))
{
continue;
}
// attempt a code lookup
var playerName = $"{playerFirstName} {playerLastName}";
LogTrace($"Calling Service to find {playerName}");
result.PlayerFirstName = playerFirstName;
result.PlayerLastName = playerLastName;
var p = TflService.GetNflPlayer(
playerFirstName,
playerLastName);
if (p != null)
{
if (string.IsNullOrEmpty(result.PlayerId))
{
result.PlayerId = p.PlayerCode;
result.PlayerFirstName = playerFirstName;
result.PlayerLastName = playerLastName;
result.PlayerName = playerName;
realFirstName = playerFirstName;
realLastName = playerLastName;
}
else
{
// 2 players found, we can only handle 1 at a time
result.PlayerId = string.Empty;
result.PlayerFirstName = string.Empty;
result.PlayerLastName = string.Empty;
result.PlayerName = string.Empty;
break;
}
}
}
if (string.IsNullOrEmpty(result.PlayerId) &&
!string.IsNullOrEmpty(result.PlayerFirstName) &&
!string.IsNullOrEmpty(result.PlayerLastName)
)
{
if (!result.RecommendedAction.Equals("WAIVER"))
{
// potential Newbie??
Log.Info($"{result.PlayerFirstName} {result.PlayerLastName} is a potential newbie");
result.RecommendedAction = "NEWBIE";
}
}
else
{
// we have identified, get rid of newbie names
result.PlayerFirstName = realFirstName;
result.PlayerLastName = realLastName;
}
}
