public DateTimeParseResult Parse(ExtractResult er, DateObject refTime)
{
var referenceTime = refTime;
object value = null;
if (er.Type.Equals(ParserName, StringComparison.Ordinal))
{
var innerResult = MergeDateAndTime(er.Text, referenceTime);
if (!innerResult.Success)
{
innerResult = ParseBasicRegex(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseTimeOfToday(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseSpecialTimeOfDate(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParserDurationWithAgoAndLater(er.Text, referenceTime);
}
if (innerResult.Success)
{
innerResult.FutureResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.DATETIME, DateTimeFormatUtil.FormatDateTime((DateObject)innerResult.FutureValue) },
};
innerResult.PastResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.DATETIME, DateTimeFormatUtil.FormatDateTime((DateObject)innerResult.PastValue) },
};
value = innerResult;
}
}
var ret = new DateTimeParseResult
{
Text = er.Text,
Start = er.Start,
Length = er.Length,
Type = er.Type,
Data = er.Data,
Value = value,
TimexStr = value == null ? string.Empty : ((DateTimeResolutionResult)value).Timex,
ResolutionStr = string.Empty,
};
return(ret);
}
// merge the entity with its related contexts and then parse the combine text
private static DateTimeResolutionResult GetResolution(ExtractResult er, DateTimeParseResult pr, DateTimeResolutionResult ret)
{
var parentText = (string)((Dictionary <string, object>)er.Data)[ExtendedModelResult.ParentTextKey];
var type = pr.Type;
var singlePointResolution = string.Empty;
var pastStartPointResolution = string.Empty;
var pastEndPointResolution = string.Empty;
var futureStartPointResolution = string.Empty;
var futureEndPointResolution = string.Empty;
var singlePointType = string.Empty;
var startPointType = string.Empty;
var endPointType = string.Empty;
if (type is Constants.SYS_DATETIME_DATEPERIOD or Constants.SYS_DATETIME_TIMEPERIOD or Constants.SYS_DATETIME_DATETIMEPERIOD)
{
switch (type)
{
case Constants.SYS_DATETIME_DATEPERIOD:
startPointType = TimeTypeConstants.START_DATE;
endPointType = TimeTypeConstants.END_DATE;
pastStartPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
case Constants.SYS_DATETIME_DATETIMEPERIOD:
startPointType = TimeTypeConstants.START_DATETIME;
endPointType = TimeTypeConstants.END_DATETIME;
if (ret.PastValue is Tuple <DateObject, DateObject> tuple)
{
pastStartPointResolution = DateTimeFormatUtil.FormatDateTime(tuple.Item1);
pastEndPointResolution = DateTimeFormatUtil.FormatDateTime(tuple.Item2);
futureStartPointResolution =
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution =
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
}
else if (ret.PastValue is DateObject datetime)
{
pastStartPointResolution = DateTimeFormatUtil.FormatDateTime(datetime);
futureStartPointResolution = DateTimeFormatUtil.FormatDateTime((DateObject)ret.FutureValue);
}
break;
case Constants.SYS_DATETIME_TIMEPERIOD:
startPointType = TimeTypeConstants.START_TIME;
endPointType = TimeTypeConstants.END_TIME;
pastStartPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
}
}
private static DateTimeResolutionResult GetResolution(ExtractResult er, DateTimeParseResult pr, DateTimeResolutionResult ret)
{
var parentText = (string)((Dictionary <string, object>)er.Data)[ExtendedModelResult.ParentTextKey];
var type = pr.Type;
var singlePointResolution = "";
var pastStartPointResolution = "";
var pastEndPointResolution = "";
var futureStartPointResolution = "";
var futureEndPointResolution = "";
var singlePointType = "";
var startPointType = "";
var endPointType = "";
if (type == Constants.SYS_DATETIME_DATEPERIOD || type == Constants.SYS_DATETIME_TIMEPERIOD ||
type == Constants.SYS_DATETIME_DATETIMEPERIOD)
{
switch (type)
{
case Constants.SYS_DATETIME_DATEPERIOD:
startPointType = TimeTypeConstants.START_DATE;
endPointType = TimeTypeConstants.END_DATE;
pastStartPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = DateTimeFormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
case Constants.SYS_DATETIME_DATETIMEPERIOD:
startPointType = TimeTypeConstants.START_DATETIME;
endPointType = TimeTypeConstants.END_DATETIME;
if (ret.PastValue is Tuple <DateObject, DateObject> tuple)
{
pastStartPointResolution = DateTimeFormatUtil.FormatDateTime(tuple.Item1);
pastEndPointResolution = DateTimeFormatUtil.FormatDateTime(tuple.Item2);
futureStartPointResolution =
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution =
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
}
else if (ret.PastValue is DateObject datetime)
{
pastStartPointResolution = DateTimeFormatUtil.FormatDateTime(datetime);
futureStartPointResolution = DateTimeFormatUtil.FormatDateTime((DateObject)ret.FutureValue);
}
break;
case Constants.SYS_DATETIME_TIMEPERIOD:
startPointType = TimeTypeConstants.START_TIME;
endPointType = TimeTypeConstants.END_TIME;
pastStartPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
}
}
else
{
switch (type)
{
case Constants.SYS_DATETIME_DATE:
singlePointType = TimeTypeConstants.DATE;
singlePointResolution = DateTimeFormatUtil.FormatDate((DateObject)ret.FutureValue);
break;
case Constants.SYS_DATETIME_DATETIME:
singlePointType = TimeTypeConstants.DATETIME;
singlePointResolution = DateTimeFormatUtil.FormatDateTime((DateObject)ret.FutureValue);
break;
case Constants.SYS_DATETIME_TIME:
singlePointType = TimeTypeConstants.TIME;
singlePointResolution = DateTimeFormatUtil.FormatTime((DateObject)ret.FutureValue);
break;
}
}
ret.FutureResolution = new Dictionary <string, string>();
ret.PastResolution = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(futureStartPointResolution))
{
ret.FutureResolution.Add(startPointType, futureStartPointResolution);
}
if (!string.IsNullOrEmpty(futureEndPointResolution))
{
ret.FutureResolution.Add(endPointType, futureEndPointResolution);
}
if (!string.IsNullOrEmpty(pastStartPointResolution))
{
ret.PastResolution.Add(startPointType, pastStartPointResolution);
}
if (!string.IsNullOrEmpty(pastEndPointResolution))
{
ret.PastResolution.Add(endPointType, pastEndPointResolution);
}
if (!string.IsNullOrEmpty(singlePointResolution))
{
ret.FutureResolution.Add(singlePointType, singlePointResolution);
ret.PastResolution.Add(singlePointType, singlePointResolution);
}
if (!string.IsNullOrEmpty(parentText))
{
ret.FutureResolution.Add(ExtendedModelResult.ParentTextKey, parentText);
ret.PastResolution.Add(ExtendedModelResult.ParentTextKey, parentText);
}
if (((DateTimeResolutionResult)pr.Value).Mod != null)
{
ret.Mod = ((DateTimeResolutionResult)pr.Value).Mod;
}
if (((DateTimeResolutionResult)pr.Value).TimeZoneResolution != null)
{
ret.TimeZoneResolution = ((DateTimeResolutionResult)pr.Value).TimeZoneResolution;
}
return(ret);
}
internal static void ResolveAmpm(Dictionary <string, object> resolutionDic, string keyName)
{
if (resolutionDic.ContainsKey(keyName))
{
var resolution = (Dictionary <string, string>)resolutionDic[keyName];
var resolutionPm = new Dictionary <string, string>();
if (!resolutionDic.ContainsKey(DateTimeResolutionKey.Timex))
{
return;
}
var timex = (string)resolutionDic[DateTimeResolutionKey.Timex];
resolutionDic.Remove(keyName);
resolutionDic.Add(keyName + "Am", resolution);
switch ((string)resolutionDic[ResolutionKey.Type])
{
case Constants.SYS_DATETIME_TIME:
resolutionPm[ResolutionKey.Value] = DateTimeFormatUtil.ToPm(resolution[ResolutionKey.Value]);
resolutionPm[DateTimeResolutionKey.Timex] = DateTimeFormatUtil.ToPm(timex);
break;
case Constants.SYS_DATETIME_DATETIME:
var split = resolution[ResolutionKey.Value].Split(' ');
resolutionPm[ResolutionKey.Value] = split[0] + " " + DateTimeFormatUtil.ToPm(split[1]);
resolutionPm[DateTimeResolutionKey.Timex] = DateTimeFormatUtil.AllStringToPm(timex);
break;
case Constants.SYS_DATETIME_TIMEPERIOD:
if (resolution.ContainsKey(DateTimeResolutionKey.Start))
{
resolutionPm[DateTimeResolutionKey.Start] = DateTimeFormatUtil.ToPm(resolution[DateTimeResolutionKey.Start]);
}
if (resolution.ContainsKey(DateTimeResolutionKey.End))
{
resolutionPm[DateTimeResolutionKey.End] = DateTimeFormatUtil.ToPm(resolution[DateTimeResolutionKey.End]);
}
resolutionPm[DateTimeResolutionKey.Timex] = DateTimeFormatUtil.AllStringToPm(timex);
break;
case Constants.SYS_DATETIME_DATETIMEPERIOD:
if (resolution.ContainsKey(DateTimeResolutionKey.Start))
{
var start = Convert.ToDateTime(resolution[DateTimeResolutionKey.Start], CultureInfo.InvariantCulture);
start = start.Hour == Constants.HalfDayHourCount ?
start.AddHours(-Constants.HalfDayHourCount) : start.AddHours(Constants.HalfDayHourCount);
resolutionPm[DateTimeResolutionKey.Start] = DateTimeFormatUtil.FormatDateTime(start);
}
if (resolution.ContainsKey(DateTimeResolutionKey.End))
{
var end = Convert.ToDateTime(resolution[DateTimeResolutionKey.End], CultureInfo.InvariantCulture);
end = end.Hour == Constants.HalfDayHourCount ?
end.AddHours(-Constants.HalfDayHourCount) : end.AddHours(Constants.HalfDayHourCount);
resolutionPm[DateTimeResolutionKey.End] = DateTimeFormatUtil.FormatDateTime(end);
}
resolutionPm[DateTimeResolutionKey.Timex] = DateTimeFormatUtil.AllStringToPm(timex);
break;
}
resolutionDic.Add(keyName + "Pm", resolutionPm);
}
}
public DateTimeParseResult Parse(ExtractResult er, DateObject refTime)
{
var referenceTime = refTime;
object value = null;
if (er.Type.Equals(ParserName))
{
var innerResult = MergeDateWithSingleTimePeriod(er.Text, referenceTime);
if (!innerResult.Success)
{
innerResult = MergeTwoTimePoints(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseSpecificTimeOfDay(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseDuration(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseRelativeUnit(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseDateWithPeriodPrefix(er.Text, referenceTime);
}
if (!innerResult.Success)
{
// Cases like "today after 2:00pm", "1/1/2015 before 2:00 in the afternoon"
innerResult = ParseDateWithTimePeriodSuffix(er.Text, referenceTime);
}
if (innerResult.Success)
{
if (!IsBeforeOrAfterMod(innerResult.Mod))
{
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item2)
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item2)
}
};
}
else
{
if (innerResult.Mod == Constants.AFTER_MOD)
{
// Cases like "1/1/2015 after 2:00" there is no EndTime
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)(innerResult.FutureValue))
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)(innerResult.PastValue))
}
};
}
else
{
// Cases like "1/1/2015 before 5:00 in the afternoon" there is no StartTime
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)(innerResult.FutureValue))
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)(innerResult.PastValue))
}
};
}
}
value = innerResult;
}
}
var ret = new DateTimeParseResult
{
Text = er.Text,
Start = er.Start,
Length = er.Length,
Type = er.Type,
Data = er.Data,
Value = value,
TimexStr = value == null ? "" : ((DateTimeResolutionResult)value).Timex,
ResolutionStr = ""
};
return(ret);
}
public DateTimeParseResult Parse(ExtractResult er, DateObject refTime)
{
var referenceTime = refTime;
object value = null;
if (er.Type.Equals(ParserName))
{
var innerResult = InternalParse(er.Text, referenceTime);
// Handling timeZone
if (innerResult.Success && TimeZoneUtility.ShouldResolveTimeZone(er, this.Config.Options))
{
var metadata = er.Data as Dictionary <string, object>;
var timezoneEr = metadata[Constants.SYS_DATETIME_TIMEZONE] as ExtractResult;
var timezonePr = this.Config.TimeZoneParser.Parse(timezoneEr);
if (timezonePr != null && timezonePr.Value != null)
{
innerResult.TimeZoneResolution = ((DateTimeResolutionResult)timezonePr.Value).TimeZoneResolution;
}
}
if (innerResult.Success)
{
if (!IsBeforeOrAfterMod(innerResult.Mod))
{
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item2)
},
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item2)
},
};
}
else
{
if (innerResult.Mod == Constants.AFTER_MOD)
{
// Cases like "1/1/2015 after 2:00" there is no EndTime
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)innerResult.FutureValue)
},
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)innerResult.PastValue)
},
};
}
else
{
// Cases like "1/1/2015 before 5:00 in the afternoon" there is no StartTime
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)innerResult.FutureValue)
},
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime((DateObject)innerResult.PastValue)
},
};
}
}
value = innerResult;
}
}
var ret = new DateTimeParseResult
{
Text = er.Text,
Start = er.Start,
Length = er.Length,
Type = er.Type,
Data = er.Data,
Value = value,
TimexStr = value == null ? string.Empty : ((DateTimeResolutionResult)value).Timex,
ResolutionStr = string.Empty,
};
return(ret);
}
public DateTimeParseResult Parse(ExtractResult er, DateObject refDate)
{
var referenceTime = refDate;
object value = null;
if (er.Type.Equals(ParserName, StringComparison.Ordinal))
{
var innerResult = MergeDateAndTimePeriod(er.Text, referenceTime);
if (!innerResult.Success)
{
innerResult = MergeTwoTimePoints(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseDuration(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseSpecificNight(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseNumberWithUnit(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseRelativeUnit(er.Text, referenceTime);
}
if (innerResult.Success)
{
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item2)
},
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
DateTimeFormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item2)
},
};
value = innerResult;
}
}
var ret = new DateTimeParseResult
{
Text = er.Text,
Start = er.Start,
Length = er.Length,
Type = er.Type,
Data = er.Data,
Value = value,
TimexStr = value == null ? string.Empty : ((DateTimeResolutionResult)value).Timex,
ResolutionStr = string.Empty,
};
return(ret);
}
