private static List <Resolution.Entry> ResolveDateTimeRange(TimexProperty timex)
{
if (timex.PartOfDay != null)
{
var date = TimexValue.DateValue(timex);
var timeRange = PartOfDayTimeRange(timex);
return(new List <Resolution.Entry>
{
new Resolution.Entry
{
Timex = timex.TimexValue,
Type = "datetimerange",
Start = $"{date} {timeRange.Item1}",
End = $"{date} {timeRange.Item2}",
},
});
}
else
{
var range = TimexHelpers.ExpandDateTimeRange(timex);
return(new List <Resolution.Entry>
{
new Resolution.Entry
{
Timex = timex.TimexValue,
Type = "datetimerange",
Start = $"{TimexValue.DateValue(range.Start)} {TimexValue.TimeValue(range.Start)}",
End = $"{TimexValue.DateValue(range.End)} {TimexValue.TimeValue(range.End)}",
},
});
}
}
private static IEnumerable <string> ResolveTimeRange(TimexProperty timex, IEnumerable <TimeRange> constraints)
{
var candidate = TimexHelpers.TimeRangeFromTimex(timex);
var result = new List <string>();
foreach (var constraint in constraints)
{
if (TimexConstraintsHelper.IsOverlapping(candidate, constraint))
{
var start = Math.Max(candidate.Start.GetTime(), constraint.Start.GetTime());
var time = new Time(start);
// TODO: consider a method on TimexProperty to do this clone/overwrite pattern
var resolved = timex.Clone();
resolved.PartOfDay = null;
resolved.Seconds = null;
resolved.Minutes = null;
resolved.Hours = null;
resolved.Second = time.Second;
resolved.Minute = time.Minute;
resolved.Hour = time.Hour;
result.Add(resolved.TimexValue);
}
}
return(result);
}
private static List <Resolution.Entry> ResolveTimeRange(TimexProperty timex)
{
if (timex.PartOfDay != null)
{
var range = PartOfDayTimeRange(timex);
return(new List <Resolution.Entry>
{
new Resolution.Entry
{
Timex = timex.TimexValue,
Type = "timerange",
Start = range.Item1,
End = range.Item2,
},
});
}
else
{
var range = TimexHelpers.ExpandTimeRange(timex);
return(new List <Resolution.Entry>
{
new Resolution.Entry
{
Timex = timex.TimexValue,
Type = "timerange",
Start = TimexValue.TimeValue(range.Start),
End = TimexValue.TimeValue(range.End),
},
});
}
}
private static IEnumerable <string> ResolveByDateRangeConstraints(IEnumerable <string> candidates, IEnumerable <TimexProperty> timexConstraints)
{
var dateRangeconstraints = timexConstraints
.Where((timex) =>
{
return(timex.Types.Contains(Constants.TimexTypes.DateRange));
})
.Select((timex) =>
{
return(TimexHelpers.DateRangeFromTimex(timex));
});
var collapsedDateRanges = TimexConstraintsHelper.Collapse(dateRangeconstraints);
if (!collapsedDateRanges.Any())
{
return(candidates);
}
var resolution = new List <string>();
foreach (var timex in candidates)
{
var r = ResolveDate(new TimexProperty(timex), collapsedDateRanges);
resolution.AddRange(r);
}
return(RemoveDuplicates(resolution));
}
private static Tuple <string, string> MonthWeekDateRange(int year, int month, int weekOfMonth)
{
var monthWeekDateRange = TimexHelpers.MonthWeekDateRange(year, month, weekOfMonth);
return(new Tuple <string, string>(
TimexValue.DateValue(monthWeekDateRange.Item1),
TimexValue.DateValue(monthWeekDateRange.Item2)));
}
private static Tuple <string, string> YearWeekDateRange(int year, int weekOfYear, bool?isWeekend)
{
var yearWeekDateRange = TimexHelpers.YearWeekDateRange(year, weekOfYear, isWeekend);
return(new Tuple <string, string>(
TimexValue.DateValue(yearWeekDateRange.Item1),
TimexValue.DateValue(yearWeekDateRange.Item2)));
}
private static Tuple <string, string> YearDateRange(int year)
{
var yearDateRange = TimexHelpers.YearDateRange(year);
return(new Tuple <string, string>(
TimexValue.DateValue(yearDateRange.Item1),
TimexValue.DateValue(yearDateRange.Item2)));
}
private static DateObject GenerateWeekDate(TimexProperty timex, DateObject date, bool isBefore)
{
DateObject start;
if (timex.WeekOfMonth == null && timex.WeekOfYear == null)
{
var day = timex.DayOfWeek == 7 ? DayOfWeek.Sunday : (DayOfWeek)timex.DayOfWeek;
if (isBefore)
{
start = TimexDateHelpers.DateOfLastDay(day, date);
}
else
{
start = TimexDateHelpers.DateOfNextDay(day, date);
}
}
else
{
int dayOfWeek = timex.DayOfWeek.Value - 1;
int year = timex.Year ?? date.Year;
if (timex.WeekOfYear != null)
{
int weekOfYear = timex.WeekOfYear.Value;
start = TimexHelpers.FirstDateOfWeek(year, weekOfYear, CultureInfo.InvariantCulture).AddDays(dayOfWeek);
if (timex.Year == null)
{
if (isBefore && start > date)
{
start = TimexHelpers.FirstDateOfWeek(year - 1, weekOfYear, CultureInfo.InvariantCulture).AddDays(dayOfWeek);
}
else if (!isBefore && start < date)
{
start = TimexHelpers.FirstDateOfWeek(year + 1, weekOfYear, CultureInfo.InvariantCulture).AddDays(dayOfWeek);
}
}
}
else
{
int month = timex.Month ?? date.Month;
int weekOfMonth = timex.WeekOfMonth.Value;
start = TimexHelpers.GenerateMonthWeekDateStart(year, month, weekOfMonth).AddDays(dayOfWeek);
if (timex.Year == null || timex.Month == null)
{
if (isBefore && start > date)
{
start = TimexHelpers.GenerateMonthWeekDateStart(timex.Month != null ? year - 1 : year, timex.Month == null ? month - 1 : month, weekOfMonth).AddDays(dayOfWeek);
}
else if (!isBefore && start < date)
{
start = TimexHelpers.GenerateMonthWeekDateStart(timex.Month != null ? year + 1 : year, timex.Month == null ? month + 1 : month, weekOfMonth).AddDays(dayOfWeek);
}
}
}
}
return(start);
}
private static IEnumerable <string> ResolveDefiniteAgainstConstraint(TimexProperty timex, DateRange constraint)
{
var timexDate = TimexHelpers.DateFromTimex(timex);
if (timexDate >= constraint.Start && timexDate < constraint.End)
{
return(new[] { timex.TimexValue });
}
return(Enumerable.Empty <string>());
}
public static string Format(TimexProperty timex)
{
var types = timex.Types.Count != 0 ? timex.Types : TimexInference.Infer(timex);
if (types.Contains(Constants.TimexTypes.Present))
{
return("PRESENT_REF");
}
if ((types.Contains(Constants.TimexTypes.DateTimeRange) || types.Contains(Constants.TimexTypes.DateRange) ||
types.Contains(Constants.TimexTypes.TimeRange)) && types.Contains(Constants.TimexTypes.Duration))
{
var range = TimexHelpers.ExpandDateTimeRange(timex);
return($"({Format(range.Start)},{Format(range.End)},{Format(range.Duration)})");
}
if (types.Contains(Constants.TimexTypes.DateTimeRange))
{
return($"{FormatDate(timex)}{FormatTimeRange(timex)}");
}
if (types.Contains(Constants.TimexTypes.DateRange))
{
return($"{FormatDateRange(timex)}");
}
if (types.Contains(Constants.TimexTypes.TimeRange))
{
return($"{FormatTimeRange(timex)}");
}
if (types.Contains(Constants.TimexTypes.DateTime))
{
return($"{FormatDate(timex)}{FormatTime(timex)}");
}
if (types.Contains(Constants.TimexTypes.Duration))
{
return($"{FormatDuration(timex)}");
}
if (types.Contains(Constants.TimexTypes.Date))
{
return($"{FormatDate(timex)}");
}
if (types.Contains(Constants.TimexTypes.Time))
{
return($"{FormatTime(timex)}");
}
return(string.Empty);
}
private static List <Resolution.Entry> ResolveDefiniteDateRange(TimexProperty timex, DateObject date)
{
var range = TimexHelpers.ExpandDateTimeRange(timex);
return(new List <Resolution.Entry>
{
new Resolution.Entry
{
Timex = timex.TimexValue,
Type = "daterange",
Start = TimexValue.DateValue(range.Start),
End = TimexValue.DateValue(range.End),
},
});
}
private static List <TimexProperty> ResolveDuration(TimexProperty candidate, IEnumerable <TimexProperty> constraints)
{
var results = new List <TimexProperty>();
foreach (var constraint in constraints)
{
if (constraint.Types.Contains(Constants.TimexTypes.DateTime))
{
results.Add(TimexHelpers.TimexDateTimeAdd(constraint, candidate));
}
else if (constraint.Types.Contains(Constants.TimexTypes.Time))
{
results.Add(TimexHelpers.TimexTimeAdd(constraint, candidate));
}
}
return(results);
}
private static List <Resolution.Entry> ResolveDateTimeRange(TimexProperty timex, DateObject date)
{
if (timex.PartOfDay != null)
{
var dateValues = GetDateValues(timex, date);
var timeRange = PartOfDayTimeRange(timex);
var result = new List <Resolution.Entry> {
};
foreach (string dateValue in dateValues)
{
result.Add(
new Resolution.Entry
{
Timex = timex.TimexValue,
Type = "datetimerange",
Start = TimexHelpers.FormatResolvedDateValue(dateValue, timeRange.Item1),
End = TimexHelpers.FormatResolvedDateValue(dateValue, timeRange.Item2),
});
}
return(result);
}
else
{
var range = TimexHelpers.ExpandDateTimeRange(timex);
var startDateValues = GetDateValues(range.Start, date);
var endDateValues = GetDateValues(range.End, date);
var result = new List <Resolution.Entry> {
};
foreach (var dateRange in startDateValues.Zip(endDateValues, (n, w) => new { start = n, end = w }))
{
result.Add(
new Resolution.Entry
{
Timex = timex.TimexValue,
Type = "datetimerange",
Start = TimexHelpers.FormatResolvedDateValue(dateRange.start, TimexValue.TimeValue(range.Start, date)),
End = TimexHelpers.FormatResolvedDateValue(dateRange.end, TimexValue.TimeValue(range.End, date)),
});
}
return(result);
}
}
private static string FormatDuration(TimexProperty timex)
{
var timexList = new List <string> {
};
if (timex.Years != null)
{
timexList.Add(TimexHelpers.GenerateDurationTimex(TimexUnit.Year, timex.Years ?? Constants.InvalidValue));
}
if (timex.Months != null)
{
timexList.Add(TimexHelpers.GenerateDurationTimex(TimexUnit.Month, timex.Months ?? Constants.InvalidValue));
}
if (timex.Weeks != null)
{
timexList.Add(TimexHelpers.GenerateDurationTimex(TimexUnit.Week, timex.Weeks ?? Constants.InvalidValue));
}
if (timex.Days != null)
{
timexList.Add(TimexHelpers.GenerateDurationTimex(TimexUnit.Day, timex.Days ?? Constants.InvalidValue));
}
if (timex.Hours != null)
{
timexList.Add(TimexHelpers.GenerateDurationTimex(TimexUnit.Hour, timex.Hours ?? Constants.InvalidValue));
}
if (timex.Minutes != null)
{
timexList.Add(TimexHelpers.GenerateDurationTimex(TimexUnit.Minute, timex.Minutes ?? Constants.InvalidValue));
}
if (timex.Seconds != null)
{
timexList.Add(TimexHelpers.GenerateDurationTimex(TimexUnit.Second, timex.Seconds ?? Constants.InvalidValue));
}
return(TimexHelpers.GenerateCompoundDurationTimex(timexList));
}
private static IEnumerable <string> ResolveByTimeConstraints(IEnumerable <string> candidates, IEnumerable <TimexProperty> timexConstraints)
{
var times = timexConstraints
.Where((timex) =>
{
return(timex.Types.Contains(Constants.TimexTypes.Time));
})
.Select((timex) =>
{
return(TimexHelpers.TimeFromTimex(timex));
});
if (!times.Any())
{
return(candidates);
}
var resolution = new List <string>();
foreach (var timex in candidates.Select(t => new TimexProperty(t)))
{
if (timex.Types.Contains(Constants.TimexTypes.Date) && !timex.Types.Contains(Constants.TimexTypes.Time))
{
foreach (var time in times)
{
timex.Hour = time.Hour;
timex.Minute = time.Minute;
timex.Second = time.Second;
resolution.Add(timex.TimexValue);
}
}
else
{
resolution.Add(timex.TimexValue);
}
}
return(RemoveDuplicates(resolution));
}
private static string FormatDate(TimexProperty timex)
{
return(TimexHelpers.GenerateDateTimex(timex.Year ?? Constants.InvalidValue, timex.WeekOfYear ?? (timex.Month ?? Constants.InvalidValue), timex.DayOfWeek != null ? timex.DayOfWeek.Value : timex.DayOfMonth ?? Constants.InvalidValue, timex.WeekOfMonth ?? Constants.InvalidValue, timex.DayOfWeek != null));
}
