public static List <SentenceSummary> AssignEmergencyContactInfoAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var name    = summaries[question.Position + 1].Names.FirstOrDefault();
            var phrases = summaries
                          .Skip(question.Position + 1)
                          .TakeWhile(x => !Constants.InitialWordsToIgnore.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x.Phrase.First())) &&
                                     x.Answer != null);

            var extras = new List <SentenceSummary>();

            var relationshipPhrase = phrases.FirstOrDefault(x => Constants.RelationshipTypes.CaseInsensitiveContains(x.Phrase.Select(x => x.OriginalToken.Text.Content)));

            if (relationshipPhrase != null)
            {
                var fullPhrase = relationshipPhrase.Phrase.GetPhraseText();
                foreach (var relationship in Constants.RelationshipTypes)
                {
                    if (fullPhrase.CaseInsensitiveContains(relationship))
                    {
                        extras.Add(new SentenceSummary()
                        {
                            KeyWords = new List <string>()
                            {
                                "relationship"
                            }, CombinedAnswerText = relationship, Position = question.Position
                        });
                    }
                }
            }

            question.CombinedAnswerText = name ?? "Not disclosed";
            return(extras);
        }
        public static List <SentenceSummary> AssignAddressAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var answer = summaries
                         .Skip(question.Position + 1)
                         .TakeWhile(x => !Constants.InitialWordsToIgnore.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x.Phrase.First())) &&
                                    x.Answer != null);
            var extras = new List <SentenceSummary>();

            var fullAnswerText   = answer.First().Phrase.GetPhraseText();
            var lastCharPosition = fullAnswerText.Length - 1;
            var firstComma       = fullAnswerText.IndexOf(',');
            var secondComma      = firstComma == -1 ? -1 : fullAnswerText.IndexOf(',', firstComma);

            var address = fullAnswerText.Substring(0, firstComma == -1 ? lastCharPosition : firstComma);
            var city    = null as string;
            var state   = null as string;

            if (firstComma != -1)
            {
                city = fullAnswerText.Substring(firstComma + 1, secondComma == -1 ? lastCharPosition - firstComma : secondComma);
            }
            if (secondComma != -1)
            {
                state = fullAnswerText.Substring(secondComma + 1, lastCharPosition - secondComma);
            }

            if (city != null)
            {
                extras.Add(new SentenceSummary()
                {
                    KeyWords = new List <string>()
                    {
                        "city"
                    }, CombinedAnswerText = city, Position = question.Position
                });
            }
            if (state != null)
            {
                extras.Add(new SentenceSummary()
                {
                    KeyWords = new List <string>()
                    {
                        "state"
                    }, CombinedAnswerText = state, Position = question.Position
                });
            }

            question.CombinedAnswerText = address;

            return(extras);
        }
        public static void AssignFreeformAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var answer = summaries
                         .Skip(question.Position + 1)
                         .TakeWhile(x => !Constants.InitialWordsToIgnore.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x.Phrase.First())) &&
                                    x.Answer != null);

            var fullAnswer = new StringBuilder();

            foreach (var summary in answer)
            {
                fullAnswer.Append(summary.Phrase.GetPhraseText());
            }

            question.CombinedAnswerText = fullAnswer.ToString();
        }
        public static List <SentenceSummary> AssignGeneralQuestionAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var answer      = summaries[question.Position + 1];
            var answerIsYes = answer.Phrase.Any(x => Constants.AffirmativeAnswerWords.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x)));
            var answerIsNo  = answer.Phrase.Any(x => Constants.NegativeAnswerWords.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x)));
            var extras      = new List <SentenceSummary>();

            if (answerIsYes || (!answerIsYes && !answerIsNo))
            {
                var phrases = summaries
                              .Skip(question.Position + 1)
                              .TakeWhile(x => !Constants.InitialWordsToIgnore.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x.Phrase.First())) &&
                                         x.Answer != null);

                var fullAnswer = new StringBuilder();
                foreach (var summary in phrases)
                {
                    fullAnswer.Append(summary.Phrase.SkipWhile(x =>
                                                               Constants.AffirmativeAnswerWords.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x)) ||
                                                               TextAnalysisUtils.GetTokenText(x).CaseInsensitiveEquals(" ") ||
                                                               TextAnalysisUtils.GetTokenText(x).CaseInsensitiveEquals(",") ||
                                                               TextAnalysisUtils.GetTokenText(x).CaseInsensitiveEquals("."))
                                      .GetPhraseText()
                                      );
                }
                fullAnswer.Replace("was n't", "wasn't").Replace("do n't", "don't");

                var keywords = question.KeyWords;
                if (!answerIsYes && !answerIsNo)
                {
                    keywords.Add("indecision");
                }

                if (fullAnswer.Length > 0 && (answerIsYes || !keywords.CaseInsensitiveContains("indecision")))
                {
                    extras.Add(new SentenceSummary()
                    {
                        KeyWords = keywords, CombinedAnswerText = fullAnswer.ToString(), Position = question.Position
                    });
                }
            }

            question.CombinedAnswerText = answer.Phrase.GetPhraseText();
            return(extras);
        }
        public static void AssignPhoneNumberAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var answer = summaries[question.Position + 1];
            var number = answer.Phrase.GetPhraseText().Replace("-", "").Replace("dash", "").Replace(".", "");

            if (int.TryParse(number, out int parsedNumber))
            {
                try
                {
                    number = parsedNumber.ToString(@"000\-000\-0000\");
                }
                catch (Exception)
                {
                }
            }

            question.CombinedAnswerText = number;
        }
        public static void AssignRelationshipAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var answer = summaries[question.Position + 1];

            var fullPhrase = answer.Phrase.GetPhraseText();

            foreach (var relationship in Constants.RelationshipTypes)
            {
                if (fullPhrase.CaseInsensitiveContains(relationship))
                {
                    question.CombinedAnswerText = relationship;
                }
            }
            if (string.IsNullOrEmpty(question.CombinedAnswerText))
            {
                question.CombinedAnswerText = answer.Phrase.GetPhraseText();
            }
        }
        public static SentenceSummary SummarizeAnswer(List <ReversedToken> reversedTokens)
        {
            var summary = new SentenceSummary()
            {
                Phrase   = reversedTokens,
                Names    = TextAnalysisUtils.FindNames(reversedTokens),
                Type     = SentenceType.Answer,
                KeyWords = new List <string>()
                           .AddIfNotNull(reversedTokens.Where(x => x.OriginalToken.PartOfSpeech.Tag == PartOfSpeech.Types.Tag.X).ToList()),
                Answer = new Answer()
                {
                    HasAffirmation = reversedTokens.Any(x => Constants.AffirmativeAnswerWords.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x))),
                    Numbers        = TextAnalysisUtils.FindNumbers(reversedTokens),
                }
            };

            return(summary);
        }
        public static void AssignAnswer(SentenceSummary question, List <SentenceSummary> summaries, List <SentenceSummary> extras)
        {
            var questionPhrase = question.Phrase.GetPhraseText();

            if (question.KeyWords.CaseInsensitiveContains(Constants.PhoneKeywords))
            {
                AssignPhoneNumberAnswer(question, summaries);
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.SimpleQuestionKeywords))
            {
                AssignSimpleAnswer(question, summaries);
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.AppointmentKeywords))
            {
                AssignFreeformAnswer(question, summaries);
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.AddressKeywords))
            {
                extras.AddIfNotNull(AssignAddressAnswer(question, summaries));
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.CityKeywords) || questionPhrase.CaseInsensitiveStartsWith(Constants.AddressSpecificationKeywords))
            {
                extras.AddIfNotNull(AssignCityAnswer(question, summaries));
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.StateKeywords))
            {
                AssignSimpleAnswer(question, summaries);
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.RelationshipKeywords))
            {
                AssignRelationshipAnswer(question, summaries);
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.ContactKeywords))
            {
                extras.AddIfNotNull(AssignEmergencyContactInfoAnswer(question, summaries));
            }
            else if (question.KeyWords.CaseInsensitiveContains(Constants.GeneralQuestionKeywords))
            {
                extras.AddIfNotNull(AssignGeneralQuestionAnswer(question, summaries));
            }
        }
        public static List <SentenceSummary> AssignCityAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var answer = summaries
                         .Skip(question.Position + 1)
                         .TakeWhile(x => !Constants.InitialWordsToIgnore.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(x.Phrase.First())) &&
                                    x.Answer != null);
            var extras = new List <SentenceSummary>();

            var fullAnswerText   = answer.First().Phrase.GetPhraseText();
            var lastCharPosition = fullAnswerText.Length - 1;
            var firstComma       = fullAnswerText.IndexOf(',');

            var cityPart = answer.First().Phrase.TakeWhile(x => !TextAnalysisUtils.GetTokenText(x).CaseInsensitiveEquals(","));
            var city     = TextAnalysisUtils.FindNames(cityPart.ToList()).First();
            var state    = null as string;

            if (firstComma != -1)
            {
                state = fullAnswerText.Substring(firstComma + 1, lastCharPosition - firstComma - 1);
            }

            if (state != null)
            {
                extras.Add(new SentenceSummary()
                {
                    KeyWords = new List <string>()
                    {
                        "state"
                    }, CombinedAnswerText = state, Position = question.Position
                });
            }

            question.CombinedAnswerText = city;
            if (!question.KeyWords.CaseInsensitiveContains("city"))
            {
                question.KeyWords.Add("city");
            }

            return(extras);
        }
        public static SentenceSummary SummarizeFacts(List <ReversedToken> reverseTokens, int index, List <SentenceSummary> summaries)
        {
            SentenceSummary summary = null;
            var             phrase  = reverseTokens.GetPhraseText();

            if (Constants.AnyQuestionWords.CaseInsensitiveContains(TextAnalysisUtils.GetTokenText(reverseTokens.First())))
            {
                if (Constants.FollowUpQuestionWords.Any(x => phrase.StartsWith(x, StringComparison.InvariantCultureIgnoreCase)))
                {
                    if (summaries.GetLastQuestion()?.GeneralQuestion != null)
                    {
                        summary = SummarizeGeneralQuestion(reverseTokens);
                    }
                    else if (summaries.GetLastQuestion()?.SpecialQuestion != null)
                    {
                        summary = SummarizeSpecialQuestion(reverseTokens);
                    }
                }
                else if (Constants.SpecialQuestionWords.Contains(reverseTokens.First().OriginalToken.Text.Content))
                {
                    summary = SummarizeSpecialQuestion(reverseTokens);
                }
                else if (Constants.GeneralQuestionWords.Contains(reverseTokens.First().OriginalToken.Text.Content))
                {
                    summary = SummarizeGeneralQuestion(reverseTokens);
                }
            }
            else
            {
                summary = SummarizeAnswer(reverseTokens);
            }

            if (summary != null)
            {
                summary.Position = index;
            }

            return(summary);
        }
        public static void AssignSimpleAnswer(SentenceSummary question, List <SentenceSummary> summaries)
        {
            var answer = summaries[question.Position + 1];

            question.CombinedAnswerText = answer.Phrase.GetPhraseText().Substring(0, answer.Phrase.GetPhraseText().Length - 1);
        }