public DateTimeParseResult Parse(ExtractResult er, DateObject referenceTime)
{
object value = null;
if (er.Type.Equals(ParserName))
{
DateTimeResolutionResult innerResult;
// Resolve timezome
if (TimeZoneUtility.ShouldResolveTimeZone(er, config.Options))
{
var metadata = er.Data as Dictionary <string, object>;
var timezoneEr = metadata[Constants.SYS_DATETIME_TIMEZONE] as ExtractResult;
var timezonePr = config.TimeZoneParser.Parse(timezoneEr);
innerResult = InternalParse(er.Text.Substring(0, (int)(er.Text.Length - timezoneEr.Length)),
referenceTime);
if (timezonePr != null && timezonePr.Value != null)
{
innerResult.TimeZoneResolution = ((DateTimeResolutionResult)timezonePr.Value).TimeZoneResolution;
}
}
else
{
innerResult = InternalParse(er.Text, referenceTime);
}
if (innerResult.Success)
{
innerResult.FutureResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.TIME, DateTimeFormatUtil.FormatTime((DateObject)innerResult.FutureValue) }
};
innerResult.PastResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.TIME, DateTimeFormatUtil.FormatTime((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);
}
// 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;
}
}
public DateTimeParseResult Parse(ExtractResult er, DateObject referenceTime)
{
object value = null;
if (er.Type.Equals(ParserName))
{
DateTimeResolutionResult innerResult;
// Resolve timezome
if ((config.Options & DateTimeOptions.EnablePreview) != 0 &&
er.Data is KeyValuePair <string, ExtractResult> )
{
var timezoneEr = ((KeyValuePair <string, ExtractResult>)er.Data).Value;
var timezonePr = config.TimeZoneParser.Parse(timezoneEr);
innerResult = InternalParse(er.Text.Substring(0, (int)(er.Length - timezoneEr.Length)),
referenceTime);
if (timezonePr.Value != null)
{
innerResult.TimeZoneResolution = ((DateTimeResolutionResult)timezonePr.Value).TimeZoneResolution;
}
}
else
{
innerResult = InternalParse(er.Text, referenceTime);
}
if (innerResult.Success)
{
innerResult.FutureResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.TIME, DateTimeFormatUtil.FormatTime((DateObject)innerResult.FutureValue) }
};
innerResult.PastResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.TIME, DateTimeFormatUtil.FormatTime((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 refDate)
{
var referenceTime = refDate;
var extra = er.Data as DateTimeExtra <TimeType>;
if (extra == null)
{
var result = this.config.TimeExtractor.Extract(er.Text, refDate);
extra = result[0]?.Data as DateTimeExtra <TimeType>;
}
if (extra != null)
{
var timeResult = this.config.FunctionMap[extra.Type](extra);
var parseResult = this.config.TimeFunc.PackTimeResult(extra, timeResult, referenceTime);
if (parseResult.Success)
{
parseResult.FutureResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.TIME, DateTimeFormatUtil.FormatTime((DateObject)parseResult.FutureValue) },
};
parseResult.PastResolution = new Dictionary <string, string>
{
{ TimeTypeConstants.TIME, DateTimeFormatUtil.FormatTime((DateObject)parseResult.PastValue) },
};
}
var ret = new DateTimeParseResult
{
Start = er.Start,
Text = er.Text,
Type = er.Type,
Length = er.Length,
Value = parseResult,
Data = timeResult,
ResolutionStr = string.Empty,
TimexStr = parseResult.Timex,
};
return(ret);
}
return(null);
}
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);
}
public DateTimeParseResult Parse(ExtractResult er, DateObject refTime)
{
var referenceTime = refTime;
object value = null;
if (er.Type.Equals(ParserName))
{
var innerResult = ParseSimpleCases(er.Text, referenceTime);
if (!innerResult.Success)
{
innerResult = MergeTwoTimePoints(er.Text, referenceTime);
}
if (!innerResult.Success)
{
innerResult = ParseTimeOfDay(er.Text, referenceTime);
}
if (innerResult.Success)
{
innerResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_TIME,
DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item1)
},
{
TimeTypeConstants.END_TIME,
DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)innerResult.FutureValue).Item2)
}
};
innerResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_TIME,
DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)innerResult.PastValue).Item1)
},
{
TimeTypeConstants.END_TIME,
DateTimeFormatUtil.FormatTime(((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);
}
public DateTimeParseResult Parse(ExtractResult er, DateObject refDate)
{
var referenceTime = refDate;
var extra = er.Data as DateTimeExtra <PeriodType>;
if (extra == null)
{
var result = this.config.TimeExtractor.Extract(er.Text, refDate);
extra = result[0]?.Data as DateTimeExtra <PeriodType>;
}
if (extra != null)
{
// Handle special case like '上午' (morning), '下午' (afternoon)
var parseResult = ParseTimeOfDay(er.Text, referenceTime);
if (!parseResult.Success)
{
parseResult = TimePeriodFunctions.Handle(this.config.TimeParser, extra, referenceTime, this.config.TimeFunc);
}
if (parseResult.Success)
{
parseResult.FutureResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_TIME,
DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)parseResult.FutureValue).Item1)
},
{
TimeTypeConstants.END_TIME,
DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)parseResult.FutureValue).Item2)
},
};
parseResult.PastResolution = new Dictionary <string, string>
{
{
TimeTypeConstants.START_TIME,
DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)parseResult.PastValue).Item1)
},
{
TimeTypeConstants.END_TIME,
DateTimeFormatUtil.FormatTime(((Tuple <DateObject, DateObject>)parseResult.PastValue).Item2)
},
};
}
var ret = new DateTimeParseResult
{
Start = er.Start,
Text = er.Text,
Type = er.Type,
Length = er.Length,
Value = parseResult,
ResolutionStr = string.Empty,
TimexStr = parseResult.Timex,
};
return(ret);
}
return(null);
}
