public FrenchDateParserConfiguration(ICommonDateTimeParserConfiguration config) : base(config)
{
DateTokenPrefix = DateTimeDefinitions.DateTokenPrefix;
IntegerExtractor = config.IntegerExtractor;
OrdinalExtractor = config.OrdinalExtractor;
CardinalExtractor = config.CardinalExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DateExtractor = config.DateExtractor;
DurationParser = config.DurationParser;
DateRegexes = new FrenchDateExtractorConfiguration(this).DateRegexList;
OnRegex = FrenchDateExtractorConfiguration.OnRegex;
SpecialDayRegex = FrenchDateExtractorConfiguration.SpecialDayRegex;
SpecialDayWithNumRegex = FrenchDateExtractorConfiguration.SpecialDayWithNumRegex;
NextRegex = FrenchDateExtractorConfiguration.NextRegex;
ThisRegex = FrenchDateExtractorConfiguration.ThisRegex;
LastRegex = FrenchDateExtractorConfiguration.LastRegex;
UnitRegex = FrenchDateExtractorConfiguration.DateUnitRegex;
WeekDayRegex = FrenchDateExtractorConfiguration.WeekDayRegex;
StrictWeekDay = FrenchDateExtractorConfiguration.StrictWeekDay;
MonthRegex = FrenchDateExtractorConfiguration.MonthRegex;
WeekDayOfMonthRegex = FrenchDateExtractorConfiguration.WeekDayOfMonthRegex;
ForTheRegex = FrenchDateExtractorConfiguration.ForTheRegex;
WeekDayAndDayOfMothRegex = FrenchDateExtractorConfiguration.WeekDayAndDayOfMothRegex;
RelativeMonthRegex = FrenchDateExtractorConfiguration.RelativeMonthRegex;
YearSuffix = FrenchDateExtractorConfiguration.YearSuffix;
RelativeWeekDayRegex = FrenchDateExtractorConfiguration.RelativeWeekDayRegex;
DayOfMonth = config.DayOfMonth;
DayOfWeek = config.DayOfWeek;
MonthOfYear = config.MonthOfYear;
CardinalMap = config.CardinalMap;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public EnglishDateParserConfiguration(ICommonDateTimeParserConfiguration config)
{
DateTokenPrefix = DateTimeDefinitions.DateTokenPrefix;
IntegerExtractor = config.IntegerExtractor;
OrdinalExtractor = config.OrdinalExtractor;
CardinalExtractor = config.CardinalExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DurationParser = config.DurationParser;
DateRegexes = EnglishDateExtractorConfiguration.DateRegexList;
OnRegex = EnglishDateExtractorConfiguration.OnRegex;
SpecialDayRegex = EnglishDateExtractorConfiguration.SpecialDayRegex;
NextRegex = EnglishDateExtractorConfiguration.NextDateRegex;
ThisRegex = EnglishDateExtractorConfiguration.ThisRegex;
LastRegex = EnglishDateExtractorConfiguration.LastDateRegex;
UnitRegex = EnglishDateExtractorConfiguration.DateUnitRegex;
WeekDayRegex = EnglishDateExtractorConfiguration.WeekDayRegex;
MonthRegex = EnglishDateExtractorConfiguration.MonthRegex;
WeekDayOfMonthRegex = EnglishDateExtractorConfiguration.WeekDayOfMonthRegex;
ForTheRegex = EnglishDateExtractorConfiguration.ForTheRegex;
WeekDayAndDayOfMothRegex = EnglishDateExtractorConfiguration.WeekDayAndDayOfMothRegex;
RelativeMonthRegex = EnglishDateExtractorConfiguration.RelativeMonthRegex;
DayOfMonth = config.DayOfMonth;
DayOfWeek = config.DayOfWeek;
MonthOfYear = config.MonthOfYear;
CardinalMap = config.CardinalMap;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public static List <Token> ExtractorDurationWithBeforeAndAfter(string text,
ExtractResult er,
List <Token> ret,
IDateTimeUtilityConfiguration utilityConfiguration)
{
var pos = (int)er.Start + (int)er.Length;
if (pos <= text.Length)
{
var afterString = text.Substring(pos);
var beforeString = text.Substring(0, (int)er.Start);
var index = -1;
if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.AgoStringList, out index))
{
ret.Add(new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index));
}
else if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.LaterStringList, out index))
{
ret.Add(new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index));
}
else if (MatchingUtil.GetInIndex(beforeString, utilityConfiguration.InStringList, out index))
{
if (er.Start != null && er.Length != null && (int)er.Start > index)
{
ret.Add(new Token((int)er.Start - index, (int)er.Start + (int)er.Length));
}
}
}
return(ret);
}
public EnglishDateTimeParserConfiguration(ICommonDateTimeParserConfiguration config)
{
TokenBeforeDate = "on ";
TokenBeforeTime = "at ";
DateExtractor = config.DateExtractor;
TimeExtractor = config.TimeExtractor;
DateParser = config.DateParser;
TimeParser = config.TimeParser;
NowRegex = EnglishDateTimeExtractorConfiguration.NowRegex;
AMTimeRegex = new Regex(@"(?<am>morning)",
RegexOptions.IgnoreCase | RegexOptions.Singleline);
PMTimeRegex = new Regex(@"(?<pm>afternoon|evening|night)",
RegexOptions.IgnoreCase | RegexOptions.Singleline);
SimpleTimeOfTodayAfterRegex = EnglishDateTimeExtractorConfiguration.SimpleTimeOfTodayAfterRegex;
SimpleTimeOfTodayBeforeRegex = EnglishDateTimeExtractorConfiguration.SimpleTimeOfTodayBeforeRegex;
SpecificNightRegex = EnglishDateTimeExtractorConfiguration.SpecificNightRegex;
TheEndOfRegex = EnglishDateTimeExtractorConfiguration.TheEndOfRegex;
UnitRegex = EnglishTimeExtractorConfiguration.UnitRegex;
Numbers = config.Numbers;
CardinalExtractor = config.CardinalExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DurationParser = config.DurationParser;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public PortugueseDateTimeParserConfiguration(ICommonDateTimeParserConfiguration config) : base(config)
{
TokenBeforeDate = DateTimeDefinitions.TokenBeforeDate;
TokenBeforeTime = DateTimeDefinitions.TokenBeforeTime;
DateExtractor = config.DateExtractor;
TimeExtractor = config.TimeExtractor;
DateParser = config.DateParser;
TimeParser = config.TimeParser;
NowRegex = PortugueseDateTimeExtractorConfiguration.NowRegex;
AMTimeRegex = new Regex(DateTimeDefinitions.AmTimeRegex, RegexOptions.IgnoreCase | RegexOptions.Singleline);
PMTimeRegex = new Regex(DateTimeDefinitions.PmTimeRegex, RegexOptions.IgnoreCase | RegexOptions.Singleline);
SimpleTimeOfTodayAfterRegex = PortugueseDateTimeExtractorConfiguration.SimpleTimeOfTodayAfterRegex;
SimpleTimeOfTodayBeforeRegex = PortugueseDateTimeExtractorConfiguration.SimpleTimeOfTodayBeforeRegex;
SpecificTimeOfDayRegex = PortugueseDateTimeExtractorConfiguration.SpecificTimeOfDayRegex;
TheEndOfRegex = PortugueseDateTimeExtractorConfiguration.TheEndOfRegex;
UnitRegex = PortugueseDateTimeExtractorConfiguration.UnitRegex;
DateNumberConnectorRegex = PortugueseDateTimeExtractorConfiguration.DateNumberConnectorRegex;
Numbers = config.Numbers;
CardinalExtractor = config.CardinalExtractor;
IntegerExtractor = config.IntegerExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DurationParser = config.DurationParser;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public SpanishDateTimeParserConfiguration(ICommonDateTimeParserConfiguration config)
{
TokenBeforeDate = "el ";
TokenBeforeTime = "la ";
DateExtractor = config.DateExtractor;
TimeExtractor = config.TimeExtractor;
DateParser = config.DateParser;
TimeParser = config.TimeParser;
NowRegex = SpanishDateTimeExtractorConfiguration.NowRegex;
AMTimeRegex = new Regex(@"(?<am>(esta|(por|de|a|en)\s+la)\s+(mañana|madrugada))",
RegexOptions.IgnoreCase | RegexOptions.Singleline);
//TODO: modify it according to the corresponding English regex
PMTimeRegex = new Regex(@"(?<pm>(esta|(por|de|a|en)\s+la)\s+(tarde|noche))",
RegexOptions.IgnoreCase | RegexOptions.Singleline);
SimpleTimeOfTodayAfterRegex = SpanishDateTimeExtractorConfiguration.SimpleTimeOfTodayAfterRegex;
SimpleTimeOfTodayBeforeRegex = SpanishDateTimeExtractorConfiguration.SimpleTimeOfTodayBeforeRegex;
SpecificTimeOfDayRegex = SpanishDateTimeExtractorConfiguration.SpecificTimeOfDayRegex;
TheEndOfRegex = SpanishDateTimeExtractorConfiguration.TheEndOfRegex;
UnitRegex = SpanishDateTimeExtractorConfiguration.UnitRegex;
Numbers = config.Numbers;
CardinalExtractor = config.CardinalExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DurationParser = config.DurationParser;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public SpanishDateParserConfiguration(ICommonDateTimeParserConfiguration config)
{
DateTokenPrefix = "en ";
DateRegexes = SpanishDateExtractorConfiguration.DateRegexList;
OnRegex = SpanishDateExtractorConfiguration.OnRegex;
SpecialDayRegex = SpanishDateExtractorConfiguration.SpecialDayRegex;
NextRegex = SpanishDateExtractorConfiguration.NextRegex;
ThisRegex = SpanishDateExtractorConfiguration.ThisRegex;
LastRegex = SpanishDateExtractorConfiguration.LastRegex;
UnitRegex = SpanishDateExtractorConfiguration.UnitRegex;
StrictWeekDay = SpanishDateExtractorConfiguration.StrictWeekDay;
MonthRegex = SpanishDateExtractorConfiguration.MonthRegex;
WeekDayOfMonthRegex = SpanishDateExtractorConfiguration.WeekDayOfMonthRegex;
DayOfMonth = config.DayOfMonth;
DayOfWeek = config.DayOfWeek;
MonthOfYear = config.MonthOfYear;
CardinalMap = config.CardinalMap;
IntegerExtractor = config.IntegerExtractor;
OrdinalExtractor = config.OrdinalExtractor;
CardinalExtractor = config.CardinalExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DurationParser = config.DurationParser;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public EnglishDateTimeParserConfiguration(ICommonDateTimeParserConfiguration config)
{
TokenBeforeDate = DateTimeDefinitions.TokenBeforeDate;
TokenBeforeTime = DateTimeDefinitions.TokenBeforeTime;
DateExtractor = config.DateExtractor;
TimeExtractor = config.TimeExtractor;
DateParser = config.DateParser;
TimeParser = config.TimeParser;
NowRegex = EnglishDateTimeExtractorConfiguration.NowRegex;
AMTimeRegex = new Regex(DateTimeDefinitions.AMTimeRegex,
RegexOptions.IgnoreCase | RegexOptions.Singleline);
PMTimeRegex = new Regex(DateTimeDefinitions.PMTimeRegex,
RegexOptions.IgnoreCase | RegexOptions.Singleline);
SimpleTimeOfTodayAfterRegex = EnglishDateTimeExtractorConfiguration.SimpleTimeOfTodayAfterRegex;
SimpleTimeOfTodayBeforeRegex = EnglishDateTimeExtractorConfiguration.SimpleTimeOfTodayBeforeRegex;
SpecificNightRegex = EnglishDateTimeExtractorConfiguration.SpecificNightRegex;
TheEndOfRegex = EnglishDateTimeExtractorConfiguration.TheEndOfRegex;
UnitRegex = EnglishTimeExtractorConfiguration.TimeUnitRegex;
Numbers = config.Numbers;
CardinalExtractor = config.CardinalExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DurationParser = config.DurationParser;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public static List <Token> ExtractorDurationWithBeforeAndAfter(string text, ExtractResult er, List <Token> ret,
IDateTimeUtilityConfiguration utilityConfiguration)
{
var pos = (int)er.Start + (int)er.Length;
if (pos <= text.Length)
{
var afterString = text.Substring(pos);
var beforeString = text.Substring(0, (int)er.Start);
var index = -1;
if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.AgoRegex, out index))
{
ret.Add(new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index));
}
else if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.LaterRegex, out index))
{
ret.Add(new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index));
}
else if (MatchingUtil.GetInIndex(beforeString, utilityConfiguration.InConnectorRegex, out index))
{
// for range unit like "week, month, year", it should output dateRange or datetimeRange
if (!utilityConfiguration.RangeUnitRegex.IsMatch(er.Text))
{
if (er.Start != null && er.Length != null && (int)er.Start >= index)
{
ret.Add(new Token((int)er.Start - index, (int)er.Start + (int)er.Length));
}
}
}
}
return(ret);
}
public DutchDateTimeParserConfiguration(ICommonDateTimeParserConfiguration config)
: base(config)
{
TokenBeforeDate = DateTimeDefinitions.TokenBeforeDate;
TokenBeforeTime = DateTimeDefinitions.TokenBeforeTime;
DateExtractor = config.DateExtractor;
TimeExtractor = config.TimeExtractor;
DateParser = config.DateParser;
TimeParser = config.TimeParser;
NowRegex = DutchDateTimeExtractorConfiguration.NowRegex;
SimpleTimeOfTodayAfterRegex = DutchDateTimeExtractorConfiguration.SimpleTimeOfTodayAfterRegex;
SimpleTimeOfTodayBeforeRegex = DutchDateTimeExtractorConfiguration.SimpleTimeOfTodayBeforeRegex;
SpecificTimeOfDayRegex = DutchDateTimeExtractorConfiguration.SpecificTimeOfDayRegex;
SpecificEndOfRegex = DutchDateTimeExtractorConfiguration.SpecificEndOfRegex;
UnspecificEndOfRegex = DutchDateTimeExtractorConfiguration.UnspecificEndOfRegex;
UnitRegex = DutchTimeExtractorConfiguration.TimeUnitRegex;
DateNumberConnectorRegex = DutchDateTimeExtractorConfiguration.DateNumberConnectorRegex;
Numbers = config.Numbers;
CardinalExtractor = config.CardinalExtractor;
IntegerExtractor = config.IntegerExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DurationParser = config.DurationParser;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
}
public static List <Token> ExtractorDurationWithBeforeAndAfter(string text, ExtractResult er, List <Token> ret,
IDateTimeUtilityConfiguration utilityConfiguration)
{
var pos = (int)er.Start + (int)er.Length;
if (pos <= text.Length)
{
var afterString = text.Substring(pos);
var beforeString = text.Substring(0, (int)er.Start);
var index = -1;
var isTimeDuration = utilityConfiguration.TimeUnitRegex.Match(er.Text).Success;
if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.AgoRegex, out index))
{
// We don't support cases like "5 minutes from today" for now
// Cases like "5 minutes ago" or "5 minutes from now" are supported
// Cases like "2 days before today" or "2 weeks from today" are also supported
var isDayMatchInAfterString = utilityConfiguration.AgoRegex.Match(afterString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatchInAfterString))
{
ret.Add(new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index));
}
}
else if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.LaterRegex, out index))
{
var isDayMatchInAfterString = utilityConfiguration.LaterRegex.Match(afterString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatchInAfterString))
{
ret.Add(new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index));
}
}
else if (MatchingUtil.GetTermIndex(beforeString, utilityConfiguration.InConnectorRegex, out index))
{
// For range unit like "week, month, year", it should output dateRange or datetimeRange
if (!utilityConfiguration.RangeUnitRegex.IsMatch(er.Text))
{
if (er.Start != null && er.Length != null && (int)er.Start >= index)
{
ret.Add(new Token((int)er.Start - index, (int)er.Start + (int)er.Length));
}
}
}
else if (MatchingUtil.GetTermIndex(beforeString, utilityConfiguration.WithinNextPrefixRegex, out index))
{
// For range unit like "week, month, year, day, second, minute, hour", it should output dateRange or datetimeRange
if (!utilityConfiguration.DateUnitRegex.IsMatch(er.Text) && !utilityConfiguration.TimeUnitRegex.IsMatch(er.Text))
{
if (er.Start != null && er.Length != null && (int)er.Start >= index)
{
ret.Add(new Token((int)er.Start - index, (int)er.Start + (int)er.Length));
}
}
}
}
return(ret);
}
public EnglishTimeParserConfiguration(ICommonDateTimeParserConfiguration config)
{
TimeTokenPrefix = DateTimeDefinitions.TimeTokenPrefix;
AtRegex = EnglishTimeExtractorConfiguration.AtRegex;
TimeRegexes = EnglishTimeExtractorConfiguration.TimeRegexList;
UtilityConfiguration = config.UtilityConfiguration;
Numbers = config.Numbers;
}
public FrenchTimeParserConfiguration(ICommonDateTimeParserConfiguration config) : base(config.Options)
{
TimeTokenPrefix = DateTimeDefinitions.TimeTokenPrefix;
AtRegex = FrenchTimeExtractorConfiguration.AtRegex;
TimeRegexes = FrenchTimeExtractorConfiguration.TimeRegexList;
UtilityConfiguration = config.UtilityConfiguration;
Numbers = config.Numbers;
}
public SpanishTimeParserConfiguration(ICommonDateTimeParserConfiguration config)
{
TimeTokenPrefix = "a las ";
AtRegex = SpanishTimeExtractorConfiguration.AtRegex;
TimeRegexes = SpanishTimeExtractorConfiguration.TimeRegexList;
UtilityConfiguration = config.UtilityConfiguration;
Numbers = config.Numbers;
}
private static DateTimeResolutionResult GetAgoLaterResult(
DateTimeParseResult durationParseResult,
double number,
IImmutableDictionary <string, string> unitMap,
string srcUnit,
string afterStr,
string beforeStr,
System.DateTime referenceTime,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode)
{
var ret = new DateTimeResolutionResult();
if (unitMap.ContainsKey(srcUnit))
{
var unitStr = unitMap[srcUnit];
var numStr = number.ToString(CultureInfo.InvariantCulture);
var result = new DateTimeResolutionResult();
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.AgoRegex))
{
if (mode.Equals(AgoLaterMode.Date))
{
result = GetDateResult(unitStr, numStr, referenceTime, false);
}
else if (mode.Equals(AgoLaterMode.DateTime))
{
result = GetDateTimeResult(unitStr, numStr, referenceTime, false);
}
((DateTimeResolutionResult)durationParseResult.Value).Mod = TimeTypeConstants.beforeMod;
result.SubDateTimeEntities = new List <object> {
durationParseResult
};
return(result);
}
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterRegex) ||
MatchingUtil.ContainsInIndex(beforeStr, utilityConfiguration.InConnectorRegex))
{
if (mode.Equals(AgoLaterMode.Date))
{
result = GetDateResult(unitStr, numStr, referenceTime, true);
}
else if (mode.Equals(AgoLaterMode.DateTime))
{
result = GetDateTimeResult(unitStr, numStr, referenceTime, true);
}
((DateTimeResolutionResult)durationParseResult.Value).Mod = TimeTypeConstants.afterMod;
result.SubDateTimeEntities = new List <object> {
durationParseResult
};
return(result);
}
}
return(ret);
}
public SpanishTimePeriodParserConfiguration(ICommonDateTimeParserConfiguration config)
{
TimeExtractor = config.TimeExtractor;
TimeParser = config.TimeParser;
PureNumberFromToRegex = SpanishTimePeriodExtractorConfiguration.PureNumFromTo;
PureNumberBetweenAndRegex = SpanishTimePeriodExtractorConfiguration.PureNumBetweenAnd;
Numbers = config.Numbers;
UtilityConfiguration = config.UtilityConfiguration;
}
private static DateTimeResolutionResult GetAgoLaterResult(
DateTimeParseResult durationParseResult,
string afterStr,
string beforeStr,
System.DateTime referenceTime,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode)
{
var ret = new DateTimeResolutionResult();
var resultDateTime = referenceTime;
var timex = durationParseResult.TimexStr;
if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.MORE_THAN_MOD)
{
ret.Mod = Constants.MORE_THAN_MOD;
}
else if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.LESS_THAN_MOD)
{
ret.Mod = Constants.LESS_THAN_MOD;
}
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.AgoRegex))
{
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime, false);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.BEFORE_MOD;
}
else if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterRegex) ||
MatchingUtil.ContainsTermIndex(beforeStr, utilityConfiguration.InConnectorRegex))
{
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime, true);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.AFTER_MOD;
}
if (resultDateTime != referenceTime)
{
if (mode.Equals(AgoLaterMode.Date))
{
ret.Timex = $"{FormatUtil.LuisDate(resultDateTime)}";
}
else if (mode.Equals(AgoLaterMode.DateTime))
{
ret.Timex = $"{FormatUtil.LuisDateTime(resultDateTime)}";
}
ret.FutureValue = ret.PastValue = resultDateTime;
ret.SubDateTimeEntities = new List <object> {
durationParseResult
};
ret.Success = true;
}
return(ret);
}
public static DateTimeResolutionResult ParseDurationWithAgoAndLater(string text,
DateObject referenceTime,
IExtractor durationExtractor,
IDateTimeParser durationParser,
IImmutableDictionary <string, string> unitMap,
Regex unitRegex,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode)
{
var ret = new DateTimeResolutionResult();
var durationRes = durationExtractor.Extract(text);
if (durationRes.Count > 0)
{
var pr = durationParser.Parse(durationRes[0], referenceTime);
var match = unitRegex.Match(text);
if (match.Success)
{
var afterStr =
text.Substring((int)durationRes[0].Start + (int)durationRes[0].Length)
.Trim()
.ToLowerInvariant();
var beforeStr =
text.Substring(0, (int)durationRes[0].Start)
.Trim()
.ToLowerInvariant();
var srcUnit = match.Groups["unit"].Value.ToLowerInvariant();
if (pr.Value != null)
{
var durationResult = (DateTimeResolutionResult)pr.Value;
var numStr = durationResult.Timex.Substring(0, durationResult.Timex.Length - 1)
.Replace("P", "")
.Replace("T", "");
double number = 0;
if (double.TryParse(numStr, out number))
{
return(GetAgoLaterResult(
pr,
number,
unitMap,
srcUnit,
afterStr,
beforeStr,
referenceTime,
utilityConfiguration,
mode));
}
}
}
}
return(ret);
}
public EnglishTimePeriodParserConfiguration(ICommonDateTimeParserConfiguration config)
{
TimeExtractor = config.TimeExtractor;
IntegerExtractor = config.IntegerExtractor;
TimeParser = config.TimeParser;
PureNumberFromToRegex = EnglishTimePeriodExtractorConfiguration.PureNumFromTo;
PureNumberBetweenAndRegex = EnglishTimePeriodExtractorConfiguration.PureNumBetweenAnd;
TimeOfDayRegex = EnglishTimePeriodExtractorConfiguration.TimeOfDayRegex;
GeneralEndingRegex = EnglishTimePeriodExtractorConfiguration.GeneralEndingRegex;
TillRegex = EnglishTimePeriodExtractorConfiguration.TillRegex;
Numbers = config.Numbers;
UtilityConfiguration = config.UtilityConfiguration;
}
public static DateTimeResolutionResult ParserDurationWithAgoAndLater(string text,
System.DateTime referenceTime,
IExtractor durationExtractor,
IExtractor cardinalExtractor,
IParser numberParser,
IImmutableDictionary <string, string> unitMap,
Regex unitRegex,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode
)
{
var ret = new DateTimeResolutionResult();
var durationRes = durationExtractor.Extract(text);
if (durationRes.Count > 0)
{
var match = unitRegex.Match(text);
if (match.Success)
{
var afterStr =
text.Substring((int)durationRes[0].Start + (int)durationRes[0].Length)
.Trim()
.ToLowerInvariant();
var beforeStr =
text.Substring(0, (int)durationRes[0].Start)
.Trim()
.ToLowerInvariant();
var srcUnit = match.Groups["unit"].Value.ToLowerInvariant();
var numberStr =
text.Substring((int)durationRes[0].Start, match.Index - (int)durationRes[0].Start)
.Trim()
.ToLowerInvariant();
var er = cardinalExtractor.Extract(numberStr);
if (er.Count != 0)
{
return(GetAgoLaterResult(numberParser,
er[0],
unitMap,
srcUnit,
afterStr,
beforeStr,
referenceTime,
utilityConfiguration,
mode));
}
}
}
return(ret);
}
public ItalianTimePeriodParserConfiguration(ICommonDateTimeParserConfiguration config) : base(config.Options)
{
TimeExtractor = config.TimeExtractor;
IntegerExtractor = config.IntegerExtractor;
TimeParser = config.TimeParser;
PureNumberFromToRegex = ItalianTimePeriodExtractorConfiguration.PureNumFromTo;
PureNumberBetweenAndRegex = ItalianTimePeriodExtractorConfiguration.PureNumBetweenAnd;
SpecificTimeFromToRegex = ItalianTimePeriodExtractorConfiguration.SpecificTimeFromTo;
SpecificTimeBetweenAndRegex = ItalianTimePeriodExtractorConfiguration.SpecificTimeBetweenAnd;
TimeOfDayRegex = ItalianTimePeriodExtractorConfiguration.TimeOfDayRegex;
GeneralEndingRegex = ItalianTimePeriodExtractorConfiguration.GeneralEndingRegex;
TillRegex = ItalianTimePeriodExtractorConfiguration.TillRegex;
Numbers = config.Numbers;
UtilityConfiguration = config.UtilityConfiguration;
}
private static DateTimeResolutionResult GetAgoLaterResult(IParser numberParser,
ExtractResult er,
IImmutableDictionary <string, string> unitMap,
string srcUnit,
string afterStr,
string beforeStr,
System.DateTime referenceTime,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode)
{
var ret = new DateTimeResolutionResult();
var pr = numberParser.Parse(er);
var number = int.Parse(pr.ResolutionStr);
if (unitMap.ContainsKey(srcUnit))
{
var unitStr = unitMap[srcUnit];
var numStr = number.ToString();
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.AgoStringList))
{
if (mode.Equals(AgoLaterMode.Date))
{
return(GetDateResult(unitStr, numStr, referenceTime, false));
}
if (mode.Equals(AgoLaterMode.DateTime))
{
return(GetDateTimeResult(unitStr, numStr, referenceTime, false));
}
}
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterStringList) ||
MatchingUtil.ContainsInIndex(beforeStr, utilityConfiguration.InStringList))
{
if (mode.Equals(AgoLaterMode.Date))
{
return(GetDateResult(unitStr, numStr, referenceTime, true));
}
if (mode.Equals(AgoLaterMode.DateTime))
{
return(GetDateTimeResult(unitStr, numStr, referenceTime, true));
}
}
}
return(ret);
}
public static DateTimeResolutionResult ParseDurationWithAgoAndLater(string text,
DateObject referenceTime,
IDateTimeExtractor durationExtractor,
IDateTimeParser durationParser,
IImmutableDictionary <string, string> unitMap,
Regex unitRegex,
IDateTimeUtilityConfiguration utilityConfiguration)
{
var ret = new DateTimeResolutionResult();
var durationRes = durationExtractor.Extract(text, referenceTime);
if (durationRes.Count > 0)
{
var pr = durationParser.Parse(durationRes[0], referenceTime);
var matches = unitRegex.Matches(text);
if (matches.Count > 0)
{
var afterStr =
text.Substring((int)durationRes[0].Start + (int)durationRes[0].Length)
.Trim()
.ToLowerInvariant();
var beforeStr =
text.Substring(0, (int)durationRes[0].Start)
.Trim()
.ToLowerInvariant();
var mode = AgoLaterMode.Date;
if (pr.TimexStr.Contains("T"))
{
mode = AgoLaterMode.DateTime;
}
if (pr.Value != null)
{
return(GetAgoLaterResult(
pr,
afterStr,
beforeStr,
referenceTime,
utilityConfiguration,
mode));
}
}
}
return(ret);
}
public DutchDateParserConfiguration(ICommonDateTimeParserConfiguration config)
: base(config)
{
DateTokenPrefix = DateTimeDefinitions.DateTokenPrefix;
IntegerExtractor = config.IntegerExtractor;
OrdinalExtractor = config.OrdinalExtractor;
CardinalExtractor = config.CardinalExtractor;
NumberParser = config.NumberParser;
DurationExtractor = config.DurationExtractor;
DateExtractor = config.DateExtractor;
DurationParser = config.DurationParser;
DateRegexes = new DutchDateExtractorConfiguration(this).DateRegexList;
OnRegex = DutchDateExtractorConfiguration.OnRegex;
SpecialDayRegex = DutchDateExtractorConfiguration.SpecialDayRegex;
SpecialDayWithNumRegex = DutchDateExtractorConfiguration.SpecialDayWithNumRegex;
NextRegex = DutchDateExtractorConfiguration.NextDateRegex;
ThisRegex = DutchDateExtractorConfiguration.ThisRegex;
LastRegex = DutchDateExtractorConfiguration.LastDateRegex;
UnitRegex = DutchDateExtractorConfiguration.DateUnitRegex;
WeekDayRegex = DutchDateExtractorConfiguration.WeekDayRegex;
MonthRegex = DutchDateExtractorConfiguration.MonthRegex;
WeekDayOfMonthRegex = DutchDateExtractorConfiguration.WeekDayOfMonthRegex;
ForTheRegex = DutchDateExtractorConfiguration.ForTheRegex;
WeekDayAndDayOfMothRegex = DutchDateExtractorConfiguration.WeekDayAndDayOfMothRegex;
WeekDayAndDayRegex = DutchDateExtractorConfiguration.WeekDayAndDayRegex;
RelativeMonthRegex = DutchDateExtractorConfiguration.RelativeMonthRegex;
YearSuffix = DutchDateExtractorConfiguration.YearSuffix;
RelativeWeekDayRegex = DutchDateExtractorConfiguration.RelativeWeekDayRegex;
RelativeDayRegex = new Regex(DateTimeDefinitions.RelativeDayRegex, RegexOptions.Singleline);
NextPrefixRegex = new Regex(DateTimeDefinitions.NextPrefixRegex, RegexOptions.Singleline);
PreviousPrefixRegex = new Regex(DateTimeDefinitions.PreviousPrefixRegex, RegexOptions.Singleline);
UpcomingPrefixRegex = new Regex(DateTimeDefinitions.UpcomingPrefixRegex, RegexOptions.Singleline);
PastPrefixRegex = new Regex(DateTimeDefinitions.PastPrefixRegex, RegexOptions.Singleline);
DayOfMonth = config.DayOfMonth;
DayOfWeek = config.DayOfWeek;
MonthOfYear = config.MonthOfYear;
CardinalMap = config.CardinalMap;
UnitMap = config.UnitMap;
UtilityConfiguration = config.UtilityConfiguration;
SameDayTerms = DateTimeDefinitions.SameDayTerms.ToImmutableList();
PlusOneDayTerms = DateTimeDefinitions.PlusOneDayTerms.ToImmutableList();
PlusTwoDayTerms = DateTimeDefinitions.PlusTwoDayTerms.ToImmutableList();
MinusOneDayTerms = DateTimeDefinitions.MinusOneDayTerms.ToImmutableList();
MinusTwoDayTerms = DateTimeDefinitions.MinusTwoDayTerms.ToImmutableList();
}
private static DateTimeResolutionResult GetAgoLaterResult(double number,
IImmutableDictionary <string, string> unitMap,
string srcUnit,
string afterStr,
string beforeStr,
System.DateTime referenceTime,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode)
{
var ret = new DateTimeResolutionResult();
if (unitMap.ContainsKey(srcUnit))
{
var unitStr = unitMap[srcUnit];
var numStr = number.ToString(CultureInfo.InvariantCulture);
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.AgoRegex))
{
if (mode.Equals(AgoLaterMode.Date))
{
return(GetDateResult(unitStr, numStr, referenceTime, false));
}
if (mode.Equals(AgoLaterMode.DateTime))
{
return(GetDateTimeResult(unitStr, numStr, referenceTime, false));
}
}
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterRegex) ||
MatchingUtil.ContainsInIndex(beforeStr, utilityConfiguration.InConnectorRegex))
{
if (mode.Equals(AgoLaterMode.Date))
{
return(GetDateResult(unitStr, numStr, referenceTime, true));
}
if (mode.Equals(AgoLaterMode.DateTime))
{
return(GetDateTimeResult(unitStr, numStr, referenceTime, true));
}
}
}
return(ret);
}
private static DateTimeResolutionResult GetAgoLaterResult(
DateTimeParseResult durationParseResult,
string afterStr,
string beforeStr,
DateObject referenceTime,
IParser numberParser,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode,
SwiftDayDelegate swiftDay)
{
var ret = new DateTimeResolutionResult();
var resultDateTime = referenceTime;
var timex = durationParseResult.TimexStr;
if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.MORE_THAN_MOD)
{
ret.Mod = Constants.MORE_THAN_MOD;
}
else if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.LESS_THAN_MOD)
{
ret.Mod = Constants.LESS_THAN_MOD;
}
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.AgoRegex))
{
var match = utilityConfiguration.AgoRegex.Match(afterStr);
var swift = 0;
// Handle cases like "3 days before yesterday"
if (match.Success && !string.IsNullOrEmpty(match.Groups["day"].Value))
{
swift = swiftDay(match.Groups["day"].Value);
}
else if (utilityConfiguration.CheckBothBeforeAfter && match.Success && !MatchingUtil.ContainsAgoLaterIndexInBeforeString(beforeStr, utilityConfiguration.AgoRegex))
{
match = utilityConfiguration.AgoRegex.Match(beforeStr + " " + afterStr);
if (match.Success && !string.IsNullOrEmpty(match.Groups["day"].Value))
{
swift = swiftDay(match.Groups["day"].Value);
}
}
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime.AddDays(swift), false);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.BEFORE_MOD;
}
else if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.ContainsAgoLaterIndexInBeforeString(beforeStr, utilityConfiguration.AgoRegex))
{
var match = utilityConfiguration.AgoRegex.Match(beforeStr);
var swift = 0;
// Handle cases like "3 days before yesterday"
if (match.Success && !string.IsNullOrEmpty(match.Groups["day"].Value))
{
swift = swiftDay(match.Groups["day"].Value);
}
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime.AddDays(swift), false);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.BEFORE_MOD;
}
else if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterRegex) ||
MatchingUtil.ContainsTermIndex(beforeStr, utilityConfiguration.InConnectorRegex) ||
(utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.ContainsAgoLaterIndexInBeforeString(beforeStr, utilityConfiguration.LaterRegex)))
{
var match = utilityConfiguration.LaterRegex.Match(afterStr);
var swift = 0;
if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.ContainsAgoLaterIndexInBeforeString(beforeStr, utilityConfiguration.LaterRegex) && string.IsNullOrEmpty(match.Groups["day"].Value))
{
match = utilityConfiguration.LaterRegex.Match(beforeStr);
}
// Handle cases like "3 days after tomorrow"
if (match.Success && !string.IsNullOrEmpty(match.Groups["day"].Value))
{
swift = swiftDay(match.Groups["day"].Value);
}
var yearMatch = utilityConfiguration.SinceYearSuffixRegex.Match(afterStr);
if (yearMatch.Success)
{
var yearString = yearMatch.Groups[Constants.YearGroupName].Value;
var yearEr = new ExtractResult {
Text = yearString
};
var year = Convert.ToInt32((double)(numberParser.Parse(yearEr).Value ?? 0));
referenceTime = DateObject.MinValue.SafeCreateFromValue(year, 1, 1);
}
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime.AddDays(swift), true);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.AFTER_MOD;
}
else if (utilityConfiguration.CheckBothBeforeAfter && (MatchingUtil.ContainsAgoLaterIndexInBeforeString(beforeStr, utilityConfiguration.LaterRegex) ||
MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.InConnectorRegex) ||
MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterRegex)))
{
// Check also beforeStr
var match = utilityConfiguration.LaterRegex.Match(beforeStr);
var swift = 0;
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterRegex) && string.IsNullOrEmpty(match.Groups["day"].Value))
{
match = utilityConfiguration.LaterRegex.Match(beforeStr);
}
// Handle cases like "3 days after tomorrow"
if (match.Success && !string.IsNullOrEmpty(match.Groups["day"].Value))
{
swift = swiftDay(match.Groups["day"].Value);
}
var yearMatch = utilityConfiguration.SinceYearSuffixRegex.Match(beforeStr);
if (yearMatch.Success)
{
var yearString = yearMatch.Groups[Constants.YearGroupName].Value;
var yearEr = new ExtractResult {
Text = yearString
};
var year = Convert.ToInt32((double)(numberParser.Parse(yearEr).Value ?? 0));
referenceTime = DateObject.MinValue.SafeCreateFromValue(year, 1, 1);
}
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime.AddDays(swift), true);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.AFTER_MOD;
}
if (resultDateTime != referenceTime)
{
if (mode.Equals(AgoLaterMode.Date))
{
ret.Timex = $"{DateTimeFormatUtil.LuisDate(resultDateTime)}";
}
else if (mode.Equals(AgoLaterMode.DateTime))
{
ret.Timex = $"{DateTimeFormatUtil.LuisDateTime(resultDateTime)}";
}
ret.FutureValue = ret.PastValue = resultDateTime;
ret.SubDateTimeEntities = new List <object> {
durationParseResult
};
ret.Success = true;
}
return(ret);
}
private static DateTimeResolutionResult GetAgoLaterResult(
DateTimeParseResult durationParseResult,
string afterStr,
string beforeStr,
DateObject referenceTime,
IParser numberParser,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode,
SwiftDayDelegate swiftDay)
{
var ret = new DateTimeResolutionResult();
var resultDateTime = referenceTime;
var timex = durationParseResult.TimexStr;
if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.MORE_THAN_MOD)
{
ret.Mod = Constants.MORE_THAN_MOD;
}
else if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.LESS_THAN_MOD)
{
ret.Mod = Constants.LESS_THAN_MOD;
}
int swift = 0;
bool isMatch = false, isLater = false;
string dayStr = null;
var agoLaterRegexes = new List <(Regex, string)>
{
(utilityConfiguration.AgoRegex, "ago"),
(utilityConfiguration.LaterRegex, "later"),
};
// AgoRegex and LaterRegex cases
foreach (var regex in agoLaterRegexes)
{
// Match in afterStr
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, regex.Item1, inSuffix: true))
{
isMatch = true;
isLater = regex.Item2 == "later" ? true : false;
var match = regex.Item1.Match(afterStr);
dayStr = match.Groups["day"].Value;
}
if (utilityConfiguration.CheckBothBeforeAfter)
{
// Match split between beforeStr and afterStr
if (string.IsNullOrEmpty(dayStr) && isMatch)
{
var match = regex.Item1.Match(beforeStr + " " + afterStr);
dayStr = match.Groups["day"].Value;
}
// Match in beforeStr
if (string.IsNullOrEmpty(dayStr) && MatchingUtil.ContainsAgoLaterIndex(beforeStr, regex.Item1, inSuffix: false))
{
isMatch = true;
isLater = regex.Item2 == "later" ? true : false;
var match = regex.Item1.Match(beforeStr);
dayStr = match.Groups["day"].Value;
}
}
if (isMatch)
{
break;
}
}
// InConnectorRegex cases
if (!isMatch)
{
if (MatchingUtil.ContainsTermIndex(beforeStr, utilityConfiguration.InConnectorRegex))
{
// Match in afterStr
isMatch = isLater = true;
var match = utilityConfiguration.LaterRegex.Match(afterStr);
dayStr = match.Groups["day"].Value;
}
else if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.InConnectorRegex, inSuffix: true))
{
// Match in beforeStr
isMatch = isLater = true;
var match = utilityConfiguration.LaterRegex.Match(beforeStr);
dayStr = match.Groups["day"].Value;
}
}
if (isMatch)
{
// Handle cases like "3 days before yesterday", "3 days after tomorrow"
if (!string.IsNullOrEmpty(dayStr))
{
swift = swiftDay(dayStr);
}
if (isLater)
{
var yearMatch = utilityConfiguration.SinceYearSuffixRegex.Match(afterStr);
if (yearMatch.Success)
{
var yearString = yearMatch.Groups[Constants.YearGroupName].Value;
var yearEr = new ExtractResult {
Text = yearString
};
var year = Convert.ToInt32((double)(numberParser.Parse(yearEr).Value ?? 0));
referenceTime = DateObject.MinValue.SafeCreateFromValue(year, 1, 1);
}
}
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime.AddDays(swift), isLater ? true : false);
((DateTimeResolutionResult)durationParseResult.Value).Mod = isLater ? Constants.AFTER_MOD : Constants.BEFORE_MOD;
}
if (resultDateTime != referenceTime)
{
if (mode.Equals(AgoLaterMode.Date))
{
ret.Timex = $"{DateTimeFormatUtil.LuisDate(resultDateTime)}";
}
else if (mode.Equals(AgoLaterMode.DateTime))
{
ret.Timex = $"{DateTimeFormatUtil.LuisDateTime(resultDateTime)}";
}
ret.FutureValue = ret.PastValue = resultDateTime;
ret.SubDateTimeEntities = new List <object> {
durationParseResult
};
ret.Success = true;
}
return(ret);
}
public static List <Token> ExtractorDurationWithBeforeAndAfter(string text, ExtractResult er, List <Token> ret,
IDateTimeUtilityConfiguration utilityConfiguration)
{
var pos = (int)er.Start + (int)er.Length;
if (pos <= text.Length)
{
var afterString = text.Substring(pos);
var beforeString = text.Substring(0, (int)er.Start);
var isTimeDuration = utilityConfiguration.TimeUnitRegex.Match(er.Text).Success;
if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.AgoRegex, out var index))
{
// We don't support cases like "5 minutes from today" for now
// Cases like "5 minutes ago" or "5 minutes from now" are supported
// Cases like "2 days before today" or "2 weeks from today" are also supported
var isDayMatchInAfterString = utilityConfiguration.AgoRegex.Match(afterString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatchInAfterString))
{
ret.Add(new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index));
}
if (utilityConfiguration.CheckBothBeforeAfter && !isDayMatchInAfterString)
{
// check if regex match is split between beforeString and afterString
string beforeAfterStr = beforeString + afterString.Substring(0, index);
if (MatchingUtil.GetAgoLaterIndexInBeforeString(beforeAfterStr, utilityConfiguration.AgoRegex, out var indexStart))
{
isDayMatchInAfterString = utilityConfiguration.AgoRegex.Match(beforeAfterStr).Groups["day"].Success;
if (isDayMatchInAfterString && !(isTimeDuration && isDayMatchInAfterString))
{
ret.Add(new Token(indexStart, (er.Start + er.Length ?? 0) + index));
}
}
}
}
else if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.GetAgoLaterIndexInBeforeString(beforeString, utilityConfiguration.AgoRegex, out index))
{
// Check also beforeString
var isDayMatchInBeforeString = utilityConfiguration.AgoRegex.Match(beforeString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatchInBeforeString))
{
ret.Add(new Token(index, (er.Start + er.Length ?? 0) + index));
}
}
else if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.LaterRegex, out index) || (utilityConfiguration.CheckBothBeforeAfter &&
MatchingUtil.GetAgoLaterIndexInBeforeString(beforeString, utilityConfiguration.LaterRegex, out index)))
{
Token tokAfter = null, tokBefore = null;
if (MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.LaterRegex, out index))
{
var isDayMatchInAfterString = utilityConfiguration.LaterRegex.Match(afterString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatchInAfterString))
{
tokAfter = new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index);
}
}
// Check also beforeString
if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.GetAgoLaterIndexInBeforeString(beforeString, utilityConfiguration.LaterRegex, out index))
{
var isDayMatchInBeforeString = utilityConfiguration.LaterRegex.Match(beforeString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatchInBeforeString))
{
tokBefore = new Token(index, er.Start + er.Length ?? 0);
}
}
if (tokAfter != null && tokBefore != null && tokBefore.Start + tokBefore.Length > tokAfter.Start)
{
// merge overlapping tokens
ret.Add(new Token(tokBefore.Start, tokAfter.Start + tokAfter.Length - tokBefore.Start));
}
else if (tokAfter != null)
{
ret.Add(tokAfter);
}
else if (tokBefore != null)
{
ret.Add(tokBefore);
}
}
else if (MatchingUtil.GetTermIndex(beforeString, utilityConfiguration.InConnectorRegex, out index))
{
// For range unit like "week, month, year", it should output dateRange or datetimeRange
if (!utilityConfiguration.RangeUnitRegex.IsMatch(er.Text))
{
if (er.Start != null && er.Length != null && (int)er.Start >= index)
{
ret.Add(new Token((int)er.Start - index, (int)er.Start + (int)er.Length));
}
}
}
else if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.InConnectorRegex, out index))
{
// Check also afterString
// For range unit like "week, month, year", it should output dateRange or datetimeRange
if (!utilityConfiguration.RangeUnitRegex.IsMatch(er.Text))
{
if (er.Start != null && er.Length != null)
{
ret.Add(new Token((int)er.Start, (int)er.Start + (int)er.Length + index));
}
}
}
else if (MatchingUtil.GetTermIndex(beforeString, utilityConfiguration.WithinNextPrefixRegex, out index))
{
// For range unit like "week, month, year, day, second, minute, hour", it should output dateRange or datetimeRange
if (!utilityConfiguration.DateUnitRegex.IsMatch(er.Text) && !utilityConfiguration.TimeUnitRegex.IsMatch(er.Text))
{
if (er.Start != null && er.Length != null && (int)er.Start >= index)
{
ret.Add(new Token((int)er.Start - index, (int)er.Start + (int)er.Length));
}
}
}
else if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.GetAgoLaterIndex(afterString, utilityConfiguration.WithinNextPrefixRegex, out index))
{
// Check also afterString
// For range unit like "week, month, year, day, second, minute, hour", it should output dateRange or datetimeRange
if (!utilityConfiguration.DateUnitRegex.IsMatch(er.Text) && !utilityConfiguration.TimeUnitRegex.IsMatch(er.Text))
{
if (er.Start != null && er.Length != null)
{
ret.Add(new Token((int)er.Start, (int)er.Start + (int)er.Length + index));
}
}
}
}
return(ret);
}
public static List <Token> ExtractorDurationWithBeforeAndAfter(string text, ExtractResult er, List <Token> ret,
IDateTimeUtilityConfiguration utilityConfiguration)
{
var pos = (int)er.Start + (int)er.Length;
if (pos <= text.Length)
{
var afterString = text.Substring(pos);
var beforeString = text.Substring(0, (int)er.Start);
var isTimeDuration = utilityConfiguration.TimeUnitRegex.Match(er.Text).Success;
int index;
bool isMatch = false;
var agoLaterRegexes = new List <Regex>
{
utilityConfiguration.AgoRegex,
utilityConfiguration.LaterRegex,
};
foreach (var regex in agoLaterRegexes)
{
Token tokAfter = null, tokBefore = null;
bool isDayMatch = false;
// Check afterString
if (MatchingUtil.GetAgoLaterIndex(afterString, regex, out index, inSuffix: true))
{
// We don't support cases like "5 minutes from today" for now
// Cases like "5 minutes ago" or "5 minutes from now" are supported
// Cases like "2 days before today" or "2 weeks from today" are also supported
isDayMatch = regex.Match(afterString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatch))
{
tokAfter = new Token(er.Start ?? 0, (er.Start + er.Length ?? 0) + index);
isMatch = true;
}
}
if (utilityConfiguration.CheckBothBeforeAfter)
{
// Check if regex match is split between beforeString and afterString
if (!isDayMatch && isMatch)
{
string beforeAfterStr = beforeString + afterString.Substring(0, index);
var isRangeMatch = utilityConfiguration.RangePrefixRegex.MatchBegin(afterString.Substring(index), trim: true).Success;
if (!isRangeMatch && MatchingUtil.GetAgoLaterIndex(beforeAfterStr, regex, out var indexStart, inSuffix: false))
{
isDayMatch = regex.Match(beforeAfterStr).Groups["day"].Success;
if (isDayMatch && !(isTimeDuration && isDayMatch))
{
ret.Add(new Token(indexStart, (er.Start + er.Length ?? 0) + index));
isMatch = true;
}
}
}
// Check also beforeString
if (MatchingUtil.GetAgoLaterIndex(beforeString, regex, out index, inSuffix: false))
{
isDayMatch = regex.Match(beforeString).Groups["day"].Success;
if (!(isTimeDuration && isDayMatch))
{
tokBefore = new Token(index, er.Start + er.Length ?? 0);
isMatch = true;
}
}
}
if (tokAfter != null && tokBefore != null && tokBefore.Start + tokBefore.Length > tokAfter.Start)
{
// Merge overlapping tokens
ret.Add(new Token(tokBefore.Start, tokAfter.Start + tokAfter.Length - tokBefore.Start));
}
else if (tokAfter != null)
{
ret.Add(tokAfter);
}
else if (tokBefore != null)
{
ret.Add(tokBefore);
}
if (isMatch)
{
break;
}
}
if (!isMatch)
{
var inWithinRegexes = new List <(Regex, List <Regex>)>
{
(utilityConfiguration.InConnectorRegex, new List <Regex> {
utilityConfiguration.RangeUnitRegex
}),
(utilityConfiguration.WithinNextPrefixRegex, new List <Regex> {
utilityConfiguration.DateUnitRegex, utilityConfiguration.TimeUnitRegex
}),
};
foreach (var regex in inWithinRegexes)
{
bool isMatchAfter = false;
if (MatchingUtil.GetTermIndex(beforeString, regex.Item1, out index))
{
isMatch = true;
}
else if (utilityConfiguration.CheckBothBeforeAfter && MatchingUtil.GetAgoLaterIndex(afterString, regex.Item1, out index, inSuffix: true))
{
// Check also afterString
isMatch = isMatchAfter = true;
}
if (isMatch)
{
// For InConnectorRegex and range unit like "week, month, year", it should output dateRange or datetimeRange
// For WithinNextPrefixRegex and range unit like "week, month, year, day, second, minute, hour", it should output dateRange or datetimeRange
bool isUnitMatch = false;
foreach (var unitRegex in regex.Item2)
{
isUnitMatch = isUnitMatch || unitRegex.IsMatch(er.Text);
}
if (!isUnitMatch)
{
if (er.Start != null && er.Length != null && ((int)er.Start >= index || isMatchAfter))
{
int start = (int)er.Start - (!isMatchAfter ? index : 0);
int end = (int)er.Start + (int)er.Length + (isMatchAfter ? index : 0);
ret.Add(new Token(start, end));
}
}
break;
}
}
}
}
return(ret);
}
private static DateTimeResolutionResult GetAgoLaterResult(
DateTimeParseResult durationParseResult,
string afterStr,
string beforeStr,
DateObject referenceTime,
IDateTimeUtilityConfiguration utilityConfiguration,
AgoLaterMode mode,
SwiftDayDelegate swiftDay)
{
var ret = new DateTimeResolutionResult();
var resultDateTime = referenceTime;
var timex = durationParseResult.TimexStr;
if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.MORE_THAN_MOD)
{
ret.Mod = Constants.MORE_THAN_MOD;
}
else if (((DateTimeResolutionResult)durationParseResult.Value).Mod == Constants.LESS_THAN_MOD)
{
ret.Mod = Constants.LESS_THAN_MOD;
}
if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.AgoRegex))
{
var match = utilityConfiguration.AgoRegex.Match(afterStr);
var swift = 0;
// Handle cases like "3 days before yesterday"
if (match.Success && !string.IsNullOrEmpty(match.Groups["day"].Value))
{
swift = swiftDay(match.Groups["day"].Value);
}
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime.AddDays(swift), false);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.BEFORE_MOD;
}
else if (MatchingUtil.ContainsAgoLaterIndex(afterStr, utilityConfiguration.LaterRegex) ||
MatchingUtil.ContainsTermIndex(beforeStr, utilityConfiguration.InConnectorRegex))
{
var match = utilityConfiguration.LaterRegex.Match(afterStr);
var swift = 0;
// Handle cases like "3 days after tomorrow"
if (match.Success && !string.IsNullOrEmpty(match.Groups["day"].Value))
{
swift = swiftDay(match.Groups["day"].Value);
}
resultDateTime = DurationParsingUtil.ShiftDateTime(timex, referenceTime.AddDays(swift), true);
((DateTimeResolutionResult)durationParseResult.Value).Mod = Constants.AFTER_MOD;
}
if (resultDateTime != referenceTime)
{
if (mode.Equals(AgoLaterMode.Date))
{
ret.Timex = $"{DateTimeFormatUtil.LuisDate(resultDateTime)}";
}
else if (mode.Equals(AgoLaterMode.DateTime))
{
ret.Timex = $"{DateTimeFormatUtil.LuisDateTime(resultDateTime)}";
}
ret.FutureValue = ret.PastValue = resultDateTime;
ret.SubDateTimeEntities = new List <object> {
durationParseResult
};
ret.Success = true;
}
return(ret);
}