public DateTimeParseResult Parse(ExtractResult er, DateObject refTime)
{
var referenceTime = refTime;
object value = null;
if (er.Type.Equals(ParserName))
{
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, FormatUtil.FormatDateTime((DateObject)innerResult.FutureValue) }
};
innerResult.PastResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.DATETIME, FormatUtil.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 = MergeDateAndTimePeriods(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,
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item2)
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
FormatUtil.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,
FormatUtil.FormatDateTime((DateObject)(innerResult.FutureValue))
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
FormatUtil.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,
FormatUtil.FormatDateTime((DateObject)(innerResult.FutureValue))
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.END_DATETIME,
FormatUtil.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 = MergeDateAndTimePeriods(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.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item2)
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_DATETIME,
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item1)
},
{
TimeTypeConstants.END_DATETIME,
FormatUtil.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 ? "" : ((DateTimeResolutionResult)value).Timex,
ResolutionStr = ""
};
return(ret);
}
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 isPeriod = false;
var isSinglePoint = false;
string singlePointResolution = "";
string pastStartPointResolution = "";
string pastEndPointResolution = "";
string futureStartPointResolution = "";
string futureEndPointResolution = "";
string singlePointType = "";
string startPointType = "";
string endPointType = "";
if (type == Constants.SYS_DATETIME_DATEPERIOD || type == Constants.SYS_DATETIME_TIMEPERIOD ||
type == Constants.SYS_DATETIME_DATETIMEPERIOD)
{
isPeriod = true;
switch (type)
{
case Constants.SYS_DATETIME_DATEPERIOD:
startPointType = TimeTypeConstants.START_DATE;
endPointType = TimeTypeConstants.END_DATE;
pastStartPointResolution = FormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = FormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = FormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = FormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
case Constants.SYS_DATETIME_DATETIMEPERIOD:
startPointType = TimeTypeConstants.START_DATETIME;
endPointType = TimeTypeConstants.END_DATETIME;
pastStartPointResolution = FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
case Constants.SYS_DATETIME_TIMEPERIOD:
startPointType = TimeTypeConstants.START_TIME;
endPointType = TimeTypeConstants.END_TIME;
pastStartPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
}
}
else
{
isSinglePoint = true;
switch (type)
{
case Constants.SYS_DATETIME_DATE:
singlePointType = TimeTypeConstants.DATE;
singlePointResolution = FormatUtil.FormatDate((DateObject)ret.FutureValue);
break;
case Constants.SYS_DATETIME_DATETIME:
singlePointType = TimeTypeConstants.DATETIME;
singlePointResolution = FormatUtil.FormatDateTime((DateObject)ret.FutureValue);
break;
case Constants.SYS_DATETIME_TIME:
singlePointType = TimeTypeConstants.TIME;
singlePointResolution = FormatUtil.FormatTime((DateObject)ret.FutureValue);
break;
}
}
if (isPeriod)
{
ret.FutureResolution = new Dictionary <string, string>
{
{ startPointType, futureStartPointResolution },
{ endPointType, futureEndPointResolution },
{ ExtendedModelResult.ParentTextKey, parentText }
};
ret.PastResolution = new Dictionary <string, string>
{
{ startPointType, pastStartPointResolution },
{ endPointType, pastEndPointResolution },
{ ExtendedModelResult.ParentTextKey, parentText }
};
}
else if (isSinglePoint)
{
ret.FutureResolution = new Dictionary <string, string>
{
{ singlePointType, singlePointResolution },
{ ExtendedModelResult.ParentTextKey, parentText }
};
ret.PastResolution = new Dictionary <string, string>
{
{ singlePointType, singlePointResolution },
{ ExtendedModelResult.ParentTextKey, parentText }
};
}
if (((DateTimeResolutionResult)pr.Value).TimeZoneResolution != null)
{
ret.TimeZoneResolution = ((DateTimeResolutionResult)pr.Value).TimeZoneResolution;
}
return(ret);
}
internal 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] = FormatUtil.ToPm(resolution[ResolutionKey.Value]);
resolutionPm[DateTimeResolutionKey.Timex] = FormatUtil.ToPm(timex);
break;
case Constants.SYS_DATETIME_DATETIME:
var splited = resolution[ResolutionKey.Value].Split(' ');
resolutionPm[ResolutionKey.Value] = splited[0] + " " + FormatUtil.ToPm(splited[1]);
resolutionPm[DateTimeResolutionKey.Timex] = FormatUtil.AllStringToPm(timex);
break;
case Constants.SYS_DATETIME_TIMEPERIOD:
if (resolution.ContainsKey(DateTimeResolutionKey.START))
{
resolutionPm[DateTimeResolutionKey.START] = FormatUtil.ToPm(resolution[DateTimeResolutionKey.START]);
}
if (resolution.ContainsKey(DateTimeResolutionKey.END))
{
resolutionPm[DateTimeResolutionKey.END] = FormatUtil.ToPm(resolution[DateTimeResolutionKey.END]);
}
resolutionPm[DateTimeResolutionKey.Timex] = FormatUtil.AllStringToPm(timex);
break;
case Constants.SYS_DATETIME_DATETIMEPERIOD:
if (resolution.ContainsKey(DateTimeResolutionKey.START))
{
var start = Convert.ToDateTime(resolution[DateTimeResolutionKey.START]);
start = start.Hour == 12 ? start.AddHours(-12) : start.AddHours(12);
resolutionPm[DateTimeResolutionKey.START] = FormatUtil.FormatDateTime(start);
}
if (resolution.ContainsKey(DateTimeResolutionKey.END))
{
var end = Convert.ToDateTime(resolution[DateTimeResolutionKey.END]);
end = end.Hour == 12 ? end.AddHours(-12) : end.AddHours(12);
resolutionPm[DateTimeResolutionKey.END] = FormatUtil.FormatDateTime(end);
}
resolutionPm[DateTimeResolutionKey.Timex] = FormatUtil.AllStringToPm(timex);
break;
}
resolutionDic.Add(keyName + "Pm", resolutionPm);
}
}
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 = FormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = FormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = FormatUtil.FormatDate(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = FormatUtil.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 = FormatUtil.FormatDateTime(tuple.Item1);
pastEndPointResolution = FormatUtil.FormatDateTime(tuple.Item2);
futureStartPointResolution =
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution =
FormatUtil.FormatDateTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
}
else if (ret.PastValue is DateObject datetime)
{
pastStartPointResolution = FormatUtil.FormatDateTime(datetime);
futureStartPointResolution = FormatUtil.FormatDateTime((DateObject)ret.FutureValue);
}
break;
case Constants.SYS_DATETIME_TIMEPERIOD:
startPointType = TimeTypeConstants.START_TIME;
endPointType = TimeTypeConstants.END_TIME;
pastStartPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item1);
pastEndPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.PastValue).Item2);
futureStartPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item1);
futureEndPointResolution = FormatUtil.FormatTime(((Tuple <DateObject, DateObject>)ret.FutureValue).Item2);
break;
}
}
else
{
switch (type)
{
case Constants.SYS_DATETIME_DATE:
singlePointType = TimeTypeConstants.DATE;
singlePointResolution = FormatUtil.FormatDate((DateObject)ret.FutureValue);
break;
case Constants.SYS_DATETIME_DATETIME:
singlePointType = TimeTypeConstants.DATETIME;
singlePointResolution = FormatUtil.FormatDateTime((DateObject)ret.FutureValue);
break;
case Constants.SYS_DATETIME_TIME:
singlePointType = TimeTypeConstants.TIME;
singlePointResolution = FormatUtil.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);
}
