private void ParseDateTimeToUniversalTime(string item, DateTimePrecision DateTimePrecision, string format, bool HasTimeZone)
{
if (HasTimeZone)
{
//As we have timezone info in the string we can parse stright to DateTimeOffset and then to UniversalTime
if (DateTimeOffset.TryParseExact(item, format, null, System.Globalization.DateTimeStyles.None, out DateTimeOffset DateTimeOffsetFinal))
{
this.Precision = DateTimePrecision;
this.Value = DateTimeOffsetFinal.ToUniversalTime();
}
else
{
throw new NullReferenceException($"Error parsing datetime with time zone info. Value was {item}, format in use {format}, the DateTime precision detected was {DateTimePrecision.ToString()}");
}
}
else
{
//As we have no timezone info we must first parse to DateTime, then set as local timezone before converting to UniversalTime
if (DateTime.TryParseExact(item, format, null, System.Globalization.DateTimeStyles.None, out DateTime DateTimeOut))
{
DateTimeOffset DateTimeOffsetFinal = new DateTimeOffset(DateTimeOut, TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow));
this.Precision = DateTimePrecision;
this.Value = DateTimeOffsetFinal.ToUniversalTime();
}
else
{
throw new NullReferenceException($"Error parsing datetime wiht no time zone info. Value was {item}, format in use {format}, the DateTime precision detected was {DateTimePrecision.ToString()}");
}
}
}
public static DTM AsDTM(
this DateTimeOffset date,
DateTimePrecision precision = DateTimePrecision.Millisecond,
int? tenHundrethSeconds = null)
{
return new DTM(date, precision, tenHundrethSeconds);
}
/// <summary>
///
/// </summary>
/// <param name="precision"></param>
/// <returns></returns>
public static DateTimeFormatter GetFormatter(DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Year:
return(DateTimeFormatter.LongYear);
case DateTimePrecision.Month:
return(DateTimeFormatter.LongYearMonth);
case DateTimePrecision.Day:
return(DateTimeFormatter.LongDate);
case DateTimePrecision.Hour:
return(DateTimeFormatter.LongDateShortHourTime);
case DateTimePrecision.Minute:
return(DateTimeFormatter.LongDateShortTime);
case DateTimePrecision.Second:
return(DateTimeFormatter.LongDateTime);
default:
return(DateTimeFormatter.LongDate);
}
}
public static DateTimeOffset Truncate(this DateTimeOffset dt, DateTimePrecision precision = DateTimePrecision.Millisecond)
{
switch (precision)
{
case DateTimePrecision.Millisecond:
return(new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, dt.Millisecond,
dt.Offset));
case DateTimePrecision.Second:
return(new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0, dt.Offset));
case DateTimePrecision.Minute:
return(new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, 0, 0, dt.Offset));
case DateTimePrecision.Hour:
return(new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, 0, 0, 0, dt.Offset));
case DateTimePrecision.Day:
return(new DateTimeOffset(dt.Year, dt.Month, dt.Day, 0, 0, 0, 0, dt.Offset));
case DateTimePrecision.Month:
return(new DateTimeOffset(dt.Year, dt.Month, 1, 0, 0, 0, 0, dt.Offset));
case DateTimePrecision.Year:
return(new DateTimeOffset(dt.Year, 1, 1, 0, 0, 0, 0, dt.Offset));
default:
throw new ArgumentOutOfRangeException("precision");
}
}
public static DTM AsDTM(
this DateTimeOffset date,
DateTimePrecision precision = DateTimePrecision.Millisecond,
int?tenHundrethSeconds = null)
{
return(new DTM(date, precision, tenHundrethSeconds));
}
private Date(string original, DateTimeOffset parsedValue, DateTimePrecision precision, bool hasOffset)
{
_original = original;
_parsedValue = parsedValue;
Precision = precision;
HasOffset = hasOffset;
}
/// <summary>
/// Returns a <see cref="DateTime"/> with the specified <see cref="DateTimePrecision"/>.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="precision">The precision.</param>
/// <returns></returns>
public static DateTime ToPrecision(this DateTime value, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Year:
return(new DateTime(value.Year, 1, 1, 0, 0, 0, value.Kind));
case DateTimePrecision.Month:
return(new DateTime(value.Year, value.Month, 1, 0, 0, 0, value.Kind));
case DateTimePrecision.Day:
return(new DateTime(value.Year, value.Month, value.Day, 0, 0, 0, value.Kind));
case DateTimePrecision.Hour:
return(new DateTime(value.Year, value.Month, value.Day, value.Hour, 0, 0, value.Kind));
case DateTimePrecision.Minute:
return(new DateTime(value.Year, value.Month, value.Day, value.Hour, value.Minute, 0, value.Kind));
case DateTimePrecision.Second:
return(new DateTime(value.Year, value.Month, value.Day, value.Hour, value.Minute, value.Second, value.Kind));
case DateTimePrecision.Millisecond:
return(new DateTime(value.Year, value.Month, value.Day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind));
default:
return(new DateTime(value.Year, value.Month, value.Day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind));
}
}
public DateTime IndexSettingCalculateHighDateTimeForRange(DateTime LowValue, DateTimePrecision Precision)
{
switch (Precision)
{
case Bug.Common.Enums.DateTimePrecision.Year:
return(LowValue.AddYears(1).AddMilliseconds(-1));
case Bug.Common.Enums.DateTimePrecision.Month:
return(LowValue.AddMonths(1).AddMilliseconds(-1));
case Bug.Common.Enums.DateTimePrecision.Day:
return(LowValue.AddDays(1).AddMilliseconds(-1));
case Bug.Common.Enums.DateTimePrecision.HourMin:
return(LowValue.AddMinutes(1).AddMilliseconds(-1));
case Bug.Common.Enums.DateTimePrecision.Sec:
return(LowValue.AddSeconds(1).AddMilliseconds(-1));
case Bug.Common.Enums.DateTimePrecision.MilliSec:
return(LowValue.AddMilliseconds(1).AddTicks(-999));
default:
throw new System.ComponentModel.InvalidEnumArgumentException(Precision.GetCode(), (int)Precision, typeof(DateTimePrecision));
}
}
public static string NiceToString(this TimeSpan timeSpan, DateTimePrecision precision)
{
StringBuilder sb = new StringBuilder();
bool any = false;
if (timeSpan.Days != 0 /* && precision >= DateTimePrecision.Days*/)
{
sb.AppendFormat("{0}d", timeSpan.Days);
any = true;
}
if ((any || timeSpan.Hours != 0) && precision >= DateTimePrecision.Hours)
{
if (any)
{
sb.Append(" ");
}
sb.AppendFormat("{0,2}h", timeSpan.Hours);
any = true;
}
if ((any || timeSpan.Minutes != 0) && precision >= DateTimePrecision.Minutes)
{
if (any)
{
sb.Append(" ");
}
sb.AppendFormat("{0,2}m", timeSpan.Minutes);
any = true;
}
if ((any || timeSpan.Seconds != 0) && precision >= DateTimePrecision.Seconds)
{
if (any)
{
sb.Append(" ");
}
sb.AppendFormat("{0,2}s", timeSpan.Seconds);
any = true;
}
if ((any || timeSpan.Milliseconds != 0) && precision >= DateTimePrecision.Milliseconds)
{
if (any)
{
sb.Append(" ");
}
sb.AppendFormat("{0,3}ms", timeSpan.Milliseconds);
}
return(sb.ToString());
}
public static string ToIso8601(this DateTime date, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Seconds:
return date.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ");
default:
throw new InvalidOperationException();
}
}
public DocumentEntry(
DateTimePrecision creationPrecision,
DateTimePrecision serviceStartTimePrecision = DateTimePrecision.Second,
DateTimePrecision serviceStopTimePrecision = DateTimePrecision.Second)
{
_creationTimePrecision = creationPrecision;
_serviceStartTimePrecision = serviceStartTimePrecision;
_serviceStopTimePrecision = serviceStopTimePrecision;
LimitedMetadata = false;
}
/// <param name="precision">Using Milliseconds does nothing, using Days use DateTime.Date</param>
public static DateTime TrimTo(this DateTime dateTime, DateTimePrecision precision)
{
return(precision switch
{
DateTimePrecision.Days => dateTime.Date,
DateTimePrecision.Hours => TrimToHours(dateTime),
DateTimePrecision.Minutes => TrimToMinutes(dateTime),
DateTimePrecision.Seconds => TrimToSeconds(dateTime),
DateTimePrecision.Milliseconds => dateTime,
_ => throw new UnexpectedValueException(precision),
});
public static string ToIso8601(this DateTime date, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Seconds:
return(date.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ"));
default:
throw new InvalidOperationException();
}
}
public static TimeSpan TrimTo(this TimeSpan time, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Days: return time.TrimToDays();
case DateTimePrecision.Hours: return TrimToHours(time);
case DateTimePrecision.Minutes: return TrimToMinutes(time);
case DateTimePrecision.Seconds: return TrimToSeconds(time);
case DateTimePrecision.Milliseconds: return time;
}
throw new ArgumentException("precission");
}
/// <param name="precision">Using Milliseconds does nothing, using Days use DateTime.Date</param>
public static DateTime TrimTo(this DateTime dateTime, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Days: return dateTime.Date;
case DateTimePrecision.Hours: return TrimToHours(dateTime);
case DateTimePrecision.Minutes: return TrimToMinutes(dateTime);
case DateTimePrecision.Seconds: return TrimToSeconds(dateTime);
case DateTimePrecision.Milliseconds: return dateTime;
}
throw new ArgumentException("precision");
}
private DateTimeFormatter(DateTimePrecision precision, string format, string mask, params string[] regexes)
{
this.Precision = precision;
_stringFormat = format;
_editMask = mask;
_regexes = new List <Regex>();
foreach (var item in regexes)
{
_regexes.Add(new Regex(item));
}
_list.Add(this);
}
public static DT AsDT(
this DateTimeOffset date,
DateTimePrecision precision = DateTimePrecision.Day)
{
switch (precision)
{
case DateTimePrecision.Year:
return new DT(date.Year);
case DateTimePrecision.Month:
return new DT(date.Year, date.Month);
default:
return new DT(date.Year, date.Month, date.Day);
}
}
public static TimeOnly TrimTo(this TimeOnly time, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Hours: return(TrimToHours(time));
case DateTimePrecision.Minutes: return(TrimToMinutes(time));
case DateTimePrecision.Seconds: return(TrimToSeconds(time));
case DateTimePrecision.Milliseconds: return(time);
}
throw new ArgumentException("precision");
}
/// <summary>
/// Returns a DateTime truncated to the specified precision.
/// </summary>
/// <param name="t"></param>
/// <param name="precision"> </param>
/// <returns></returns>
public static DateTime Truncate(this DateTime t, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Day:
return t.Date;
case DateTimePrecision.Hour:
return new DateTime(t.Year, t.Month, t.Day, t.Hour, 0, 0);
case DateTimePrecision.Minute:
return new DateTime(t.Year, t.Month, t.Day, t.Hour, t.Minute, 0);
case DateTimePrecision.Second:
return new DateTime(t.Year, t.Month, t.Day, t.Hour, t.Minute, t.Second);
}
throw new ArgumentOutOfRangeException("precision");
}
public static TimeSpan TrimTo(this TimeSpan timeSpan, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Days: return(timeSpan.TrimToDays());
case DateTimePrecision.Hours: return(TrimToHours(timeSpan));
case DateTimePrecision.Minutes: return(TrimToMinutes(timeSpan));
case DateTimePrecision.Seconds: return(TrimToSeconds(timeSpan));
case DateTimePrecision.Milliseconds: return(timeSpan);
}
throw new ArgumentException("precission");
}
public static DT AsDT(
this DateTimeOffset date,
DateTimePrecision precision = DateTimePrecision.Day)
{
switch (precision)
{
case DateTimePrecision.Year:
return(new DT(date.Year));
case DateTimePrecision.Month:
return(new DT(date.Year, date.Month));
default:
return(new DT(date.Year, date.Month, date.Day));
}
}
public static string NiceToString(this TimeSpan timeSpan, DateTimePrecision precission)
{
StringBuilder sb = new StringBuilder();
bool any = false;
if (timeSpan.Days != 0/* && precission >= DateTimePrecision.Days*/)
{
sb.AppendFormat("{0}d", timeSpan.Days);
any = true;
}
if ((any || timeSpan.Hours != 0) && precission >= DateTimePrecision.Hours)
{
if (any)
sb.Append(" ");
sb.AppendFormat("{0,2}h", timeSpan.Hours);
any = true;
}
if ((any || timeSpan.Minutes != 0) && precission >= DateTimePrecision.Minutes)
{
if (any)
sb.Append(" ");
sb.AppendFormat("{0,2}m", timeSpan.Minutes);
any = true;
}
if ((any || timeSpan.Seconds != 0) && precission >= DateTimePrecision.Seconds)
{
if (any)
sb.Append(" ");
sb.AppendFormat("{0,2}s", timeSpan.Seconds);
any = true;
}
if ((any || timeSpan.Milliseconds != 0) && precission >= DateTimePrecision.Milliseconds)
{
if (any)
sb.Append(" ");
sb.AppendFormat("{0,3}ms", timeSpan.Milliseconds);
}
return sb.ToString();
}
public static DateTime TrimDate(this DateTime date, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Hour:
return(new DateTime(date.Year, date.Month, date.Day, date.Hour, 0, 0));
case DateTimePrecision.Minute:
return(new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, 0));
case DateTimePrecision.Second:
return(new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second));
default:
return(date);
}
}
/// <summary>
/// Returns date value in a string format at a specified precision
/// </summary>
/// <param name="datetime"></param>
/// <param name="precision"></param>
/// <returns></returns>
public static string EncodeAsSqlVariable(this DateTime datetime, DateTimePrecision precision)
{
string encodedString = "";
string format = "";
switch (precision)
{
case DateTimePrecision.Year:
format = "yyyy-MM-dd";
datetime = new DateTime(datetime.Year, 1, 1);
break;
case DateTimePrecision.Month:
format = "yyyy-MM-dd";
datetime = new DateTime(datetime.Year, datetime.Month, 1);
break;
case DateTimePrecision.Day:
format = "yyyy-MM-dd";
break;
case DateTimePrecision.Hour:
format = "yyyy-MM-dd HH:mm:ss";
datetime = new DateTime(datetime.Year, datetime.Month, datetime.Day, datetime.Hour, 0, 0);
break;
case DateTimePrecision.Minute:
format = "yyyy-MM-dd HH:mm:ss";
datetime = new DateTime(datetime.Year, datetime.Month, datetime.Day, datetime.Hour, datetime.Minute, 0);
break;
case DateTimePrecision.Second:
format = "yyyy-MM-dd HH:mm:ss";
break;
case DateTimePrecision.Millisecond:
format = "yyyy-MM-dd HH:mm:ss.fff";
break;
default:
break;
}
encodedString = string.Format($"'{datetime.ToString(format)}'");
return(encodedString);
}
/// <summary>
/// Returns a DateTime truncated to the specified precision.
/// </summary>
/// <param name="t"></param>
/// <param name="precision"> </param>
/// <returns></returns>
public static DateTime Truncate(this DateTime t, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Day:
return(t.Date);
case DateTimePrecision.Hour:
return(new DateTime(t.Year, t.Month, t.Day, t.Hour, 0, 0));
case DateTimePrecision.Minute:
return(new DateTime(t.Year, t.Month, t.Day, t.Hour, t.Minute, 0));
case DateTimePrecision.Second:
return(new DateTime(t.Year, t.Month, t.Day, t.Hour, t.Minute, t.Second));
}
throw new ArgumentOutOfRangeException("precision");
}
internal static string GetDateString(DateTime date, DateTimePrecision precision, DatePartToOmit omit = DatePartToOmit.None)
{
switch (precision)
{
case DateTimePrecision.Day:
switch (omit)
{
case DatePartToOmit.OmitMonth:
return date.ToString("%d");
case DatePartToOmit.OmitYear:
return date.ToString("d MMMM");
default:
return date.ToString("d MMMM yyyy");
}
case DateTimePrecision.Month:
switch (omit)
{
case DatePartToOmit.OmitYear:
return date.ToString("MMMM");
default:
return date.ToString("MMMM yyyy");
}
case DateTimePrecision.Season:
switch (omit)
{
case DatePartToOmit.OmitYear:
return Texts.ResourceManager.GetString(date.GetSeason().ToString());
default:
return Texts.ResourceManager.GetString(date.GetSeason().ToString()) + " " + date.Year;
}
case DateTimePrecision.Year:
return date.Year.ToString();
default:
throw new UnknownDateTimePrecisionException(precision.ToString());
}
}
public static Date FromDateTimeOffset(DateTimeOffset dto, DateTimePrecision prec = DateTimePrecision.Day,
bool includeOffset = false)
{
string formatString = prec switch
{
DateTimePrecision.Year => "yyyy",
DateTimePrecision.Month => "yyyy-MM",
_ => "yyyy-MM-dd",
};
if (includeOffset)
{
formatString += "K";
}
var representation = dto.ToString(formatString);
return(Parse(representation));
}
public static TM AsTM(
this DateTimeOffset date,
DateTimePrecision precision=DateTimePrecision.Millisecond,
int? tenHundrethSeconds = null)
{
switch (precision)
{
case DateTimePrecision.Minute:
return new TM(date.Hour, date.Minute, null, null, null, date.Offset.Hours, date.Offset.Minutes);
case DateTimePrecision.Second:
return new TM(date.Hour, date.Minute, date.Second, null, null, date.Offset.Hours, date.Offset.Minutes);
case DateTimePrecision.Millisecond:
return new TM(date.Hour, date.Minute, date.Second, date.Millisecond, null, date.Offset.Hours, date.Offset.Minutes);
case DateTimePrecision.TenHundrethSecond:
return new TM(date.Hour, date.Minute, date.Second, date.Millisecond, tenHundrethSeconds, date.Offset.Hours, date.Offset.Minutes);
default:
return null;
}
}
/// <summary>
/// ამრგვალებს ფორმატის დამატებით (გამოიყენება ფილტრებისთვის).
/// </summary>
/// <param name="date">თარიღი რომლის დამრგვალებაც გვინდა.</param>
/// <param name="precission">ფორმატი რუ რა ფორმატში დამრგვალდეს.</param>
/// <returns>აბრუნებს დამრგვალებულ თარიღს.</returns>
public static DateTime RoundUp(this DateTime date, DateTimePrecision precission)
{
switch (precission)
{
case DateTimePrecision.Seconds:
return(GetEndOfSecond(date));
case DateTimePrecision.Minutes:
return(GetEndOfMinute(date));
case DateTimePrecision.Hours:
return(GetEndOfHour(date));
case DateTimePrecision.Days:
return(GetEndOfDay(date));
}
return(GetEndOfSecond(date));
}
/// <summary>
/// ამატებს ფორმატის მიხედვით დროს (გამოიყენება ფილტრებისთვის).
/// </summary>
/// <param name="date">თარიღი რომელზეც დამატება გვინდა.</param>
/// <param name="value">მნიშვნელობა რომლის დამატებაც გვინდა.</param>
/// <param name="precission">ფორმატი რუ რა მნიშვნელობა დაამატოს. წამი, წუთი, საათი...</param>
/// <returns>აბრუნებს დამატებულ თარიღს.</returns>
public static DateTime Add(this DateTime date, double value, DateTimePrecision precission)
{
switch (precission)
{
case DateTimePrecision.Seconds:
return(date.AddSeconds(value));
case DateTimePrecision.Minutes:
return(date.AddMinutes(value));
case DateTimePrecision.Hours:
return(date.AddHours(value));
case DateTimePrecision.Days:
return(date.AddDays(value));
}
return(date.AddSeconds(value));
}
public static Time FromDateTimeOffset(DateTimeOffset dto, DateTimePrecision prec = DateTimePrecision.Fraction,
bool includeOffset = false)
{
string formatString = prec switch
{
DateTimePrecision.Hour => "HH",
DateTimePrecision.Minute => "HH:mm",
DateTimePrecision.Second => "HH:mm:ss",
_ => "HH:mm:ss.FFFFFFF",
};
if (includeOffset)
{
formatString += "K";
}
var representation = dto.ToString(formatString);
return(Parse(representation));
}
/// <summary>
/// ამრგვალებს ფორმატის დამატებით (გამოიყენება ფილტრებისთვის).
/// </summary>
/// <param name="date">თარიღი რომლის დამრგვალებაც გვინდა.</param>
/// <param name="precission">ფორმატი რუ რა ფორმატში დამრგვალდეს.</param>
/// <returns>აბრუნებს დამრგვალებულ თარიღს.</returns>
public static DateTime?RoundUp(this DateTime?date, DateTimePrecision precission)
{
if (date == null)
{
return(null);
}
switch (precission)
{
case DateTimePrecision.Seconds:
return(GetEndOfSecond(date.Value));
case DateTimePrecision.Minutes:
return(GetEndOfMinute(date.Value));
case DateTimePrecision.Hours:
return(GetEndOfHour(date.Value));
case DateTimePrecision.Days:
return(GetEndOfDay(date.Value));
}
return(GetEndOfSecond(date.Value));
}
private static DateTime?RoundDown(DateTime?date, DateTimePrecision precission)
{
if (date == null)
{
return(null);
}
switch (precission)
{
case DateTimePrecision.Seconds:
return(date.Value.GetStartOfSecond());
case DateTimePrecision.Minutes:
return(date.Value.GetStartOfMinute());
case DateTimePrecision.Hours:
return(date.Value.GetStartOfHour());
case DateTimePrecision.Days:
return(date.Value.GetStartOfDay());
}
return(date.Value.GetStartOfSecond());
}
public static TM AsTM(
this DateTimeOffset date,
DateTimePrecision precision = DateTimePrecision.Millisecond,
int?tenHundrethSeconds = null)
{
switch (precision)
{
case DateTimePrecision.Minute:
return(new TM(date.Hour, date.Minute, null, null, null, date.Offset.Hours, date.Offset.Minutes));
case DateTimePrecision.Second:
return(new TM(date.Hour, date.Minute, date.Second, null, null, date.Offset.Hours, date.Offset.Minutes));
case DateTimePrecision.Millisecond:
return(new TM(date.Hour, date.Minute, date.Second, date.Millisecond, null, date.Offset.Hours, date.Offset.Minutes));
case DateTimePrecision.TenHundrethSecond:
return(new TM(date.Hour, date.Minute, date.Second, date.Millisecond, tenHundrethSeconds, date.Offset.Hours, date.Offset.Minutes));
default:
return(null);
}
}
private static DateTime?Add(DateTime?date, double value, DateTimePrecision precission)
{
if (date == null)
{
return(null);
}
switch (precission)
{
case DateTimePrecision.Seconds:
return(date.Value.AddSeconds(value));
case DateTimePrecision.Minutes:
return(date.Value.AddMinutes(value));
case DateTimePrecision.Hours:
return(date.Value.AddHours(value));
case DateTimePrecision.Days:
return(date.Value.AddDays(value));
}
return(date.Value.AddSeconds(value));
}
public static DateTimeOffset Truncate(this DateTimeOffset dt, DateTimePrecision precision = DateTimePrecision.Millisecond)
{
switch (precision)
{
case DateTimePrecision.Millisecond:
return new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, dt.Millisecond,
dt.Offset);
case DateTimePrecision.Second:
return new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0, dt.Offset);
case DateTimePrecision.Minute:
return new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, 0, 0, dt.Offset);
case DateTimePrecision.Hour:
return new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, 0, 0, 0, dt.Offset);
case DateTimePrecision.Day:
return new DateTimeOffset(dt.Year, dt.Month, dt.Day, 0, 0, 0, 0, dt.Offset);
case DateTimePrecision.Month:
return new DateTimeOffset(dt.Year, dt.Month, 1, 0, 0, 0, 0, dt.Offset);
case DateTimePrecision.Year:
return new DateTimeOffset(dt.Year, 1, 1, 0, 0, 0, 0, dt.Offset);
default:
throw new ArgumentOutOfRangeException("precision");
}
}
public static string ToIso8601(this long millisFromEpoch, DateTimePrecision precision)
{
var date = new DateTime(epochTicks + millisFromEpoch * TimeSpan.TicksPerMillisecond);
return(ToIso8601(date, precision));
}
public TimeSpanPrecissionValidatorAttribute(DateTimePrecision precision)
{
this.Precision = precision;
}
/// <param name="precision">Using Milliseconds does nothing, using Days use DateTime.Date</param>
public static DateTime TrimTo(this DateTime dateTime, DateTimePrecision precision)
{
switch (precision)
{
case DateTimePrecision.Days: return dateTime.Date;
case DateTimePrecision.Hours: return TrimToHours(dateTime);
case DateTimePrecision.Minutes: return TrimToMinutes(dateTime);
case DateTimePrecision.Seconds: return TrimToSeconds(dateTime);
case DateTimePrecision.Milliseconds: return dateTime;
}
throw new ArgumentException("precission");
}
/// <summary>
/// 精确时间
/// </summary>
/// <param name="dateTime">时间</param>
/// <param name="precision">精确度</param>
/// <returns>精确时间</returns>
public static DateTime ToPrecision(this DateTime dateTime, DateTimePrecision precision)
{
return dateTime.AddTicks(dateTime.Ticks % (Convert.ToInt64(precision, CultureInfo.InvariantCulture)) * (-1));
}
public DateTime SearchQueryCalculateHighDateTimeForRange(DateTime LowValue, DateTimePrecision Precision)
{
DateTime HighDateTime = LowValue;
if (Precision == DateTimePrecision.Year)
{
//To deal with the problem of no time zones on Dates, e.g 2018 or 2018-10 or 2018-10-05 we treat the search as a 36 hour day rather than a 24 hours day
//When the precision is one on Year, Month or Day. For more find grained precisions such as Hour, Min, Sec we expected to have the
//time zones information supplied either by the calling user or by using the server's default timezone.
//
//So to do this I subtract 6 hours from the beginning of the date range 2018-10-05T00:00 and we add 6 hours to the end of the day 2018-10-05T23:59
//This gives us a 36 hour day range. The idea is that it is better to return more than less for the search.
//This is a compromise as we really do not know what is meant by a date with no time zone. We can assume the servers default time zone as a starting point
//but this is only a guess to what the true time zone was for either the supplied search date or the stored FHIR resource dates, when dealing with only date
//and no time.
//
//So the range we actually use for this example is not:
// 2018-10-05T00:00 to 2018-10-05T23:59
//but rather:
// 2018-10-04T18:00 to 2018-10-06T05:59
//which in a 12hr clock is 04/10/2018 6:00PM to 06/10/2018 6:00AM when the search date was: 05/10/2018
//Also bare in mind that all date times are converted to UTC Zulu +00:00 time when stored and searched in the database.
//Work out the normal 24 hour day range low and high
HighDateTime = LowValue.AddYears(1).AddMilliseconds(-1);
//Subtract 6 hours from the low
LowValue = LowValue.AddHours(-6);
//Add 6 hours to the high
HighDateTime = HighDateTime.AddHours(6);
}
else if (Precision == DateTimePrecision.Month)
{
//Work out the normal 24 hour day range low and high
HighDateTime = LowValue.AddMonths(1).AddMilliseconds(-1);
//Subtract 6 hours from the low
LowValue = LowValue.AddHours(-6);
//Add 6 hours to the high
HighDateTime = HighDateTime.AddHours(6);
}
else if (Precision == DateTimePrecision.Day)
{
//Work out the normal 24 hour day range low and high
HighDateTime = LowValue.AddDays(1).AddMilliseconds(-1);
//Subtract 6 hours from the low
LowValue = LowValue.AddHours(-6);
//Add 6 hours to the high
HighDateTime = HighDateTime.AddHours(6);
}
else if (Precision == DateTimePrecision.HourMin)
{
HighDateTime = LowValue.AddMinutes(1).AddMilliseconds(-1);
}
else if (Precision == DateTimePrecision.Sec)
{
HighDateTime = LowValue.AddSeconds(1).AddMilliseconds(-1);
}
else if (Precision == DateTimePrecision.MilliSec)
{
HighDateTime = LowValue.AddMilliseconds(1).AddTicks(-999);
}
else
{
throw new System.ComponentModel.InvalidEnumArgumentException(Precision.ToString(), (int)Precision, typeof(DateTimePrecision));
}
return(HighDateTime);
}
public static string ToIso8601(this long millisFromEpoch, DateTimePrecision precision)
{
var date = new DateTime(epochTicks + millisFromEpoch*TimeSpan.TicksPerMillisecond);
return ToIso8601(date, precision);
}
