private void ValidateZoneEquality(Instant instant, DateTimeZone nodaZone, TimeZoneInfo windowsZone)
{
// The BCL is basically broken (up to and including .NET 4.5.1 at least) around its interpretation
// of its own data around the new year. See http://codeblog.jonskeet.uk/2014/09/30/the-mysteries-of-bcl-time-zone-data/
// for details. We're not trying to emulate this behaviour.
// It's a lot *better* for .NET 4.6,
var utc = instant.InUtc();
if ((utc.Month == 12 && utc.Day == 31) || (utc.Month == 1 && utc.Day == 1))
{
return;
}
var interval = nodaZone.GetZoneInterval(instant);
// Check that the zone interval really represents a transition. It could be a change in
// wall offset, name, or the split between standard time and daylight savings for the interval.
if (interval.RawStart != Instant.BeforeMinValue)
{
var previousInterval = nodaZone.GetZoneInterval(interval.Start - Duration.Epsilon);
Assert.AreNotEqual(new { interval.WallOffset, interval.Name, interval.StandardOffset },
new { previousInterval.WallOffset, previousInterval.Name, previousInterval.StandardOffset },
"Non-transition from {0} to {1}", previousInterval, interval);
}
var nodaOffset = interval.WallOffset;
var windowsOffset = windowsZone.GetUtcOffset(instant.ToDateTimeUtc());
Assert.AreEqual(windowsOffset, nodaOffset.ToTimeSpan(), $"Incorrect offset at {instant} in interval {interval}");
var bclDaylight = windowsZone.IsDaylightSavingTime(instant.ToDateTimeUtc());
Assert.AreEqual(bclDaylight, interval.Savings != Offset.Zero,
$"At {instant}, BCL IsDaylightSavingTime={bclDaylight}; Noda savings={interval.Savings}");
}
static void Main(string[] args)
{
// Instant represents time from epoch
Instant now = SystemClock.Instance.GetCurrentInstant();
// Convert an instant to a ZonedDateTime
ZonedDateTime nowInIsoUtc = now.InUtc();
// Create a duration
Duration duration = Duration.FromMinutes(3);
// Add it to our ZonedDateTime
ZonedDateTime thenInIsoUtc = nowInIsoUtc + duration;
// Time zone support (multiple providers)
var london = DateTimeZoneProviders.Tzdb["Asia/Bangkok"];
// Time zone conversions
var localDate = new LocalDateTime();
var before = london.AtStrictly(localDate);
Console.WriteLine(localDate);
Console.WriteLine(before);
Console.ReadKey();
}
public void DepositCheque(Guid chequeId, double amount, IClock clock, CorrelatedMessage source)
{
if (amount <= 0)
{
throw new InvalidOperationException("Cheque's amount must be strictly positive");
}
var depositTime = clock.GetCurrentInstant();
Instant clearanceTime = depositTime;
switch (clearanceTime.InUtc().DayOfWeek)
{
case IsoDayOfWeek.Saturday:
clearanceTime.Plus(Duration.FromDays(2));
break;
case IsoDayOfWeek.Sunday:
clearanceTime.Plus(Duration.FromDays(1));
break;
}
Raise(new ChequeDeposited(source)
{
AccountId = Id,
ChequeId = chequeId,
Amount = amount,
DepositTime = depositTime,
ClearanceTime = clearanceTime
});
}
private void ValidateZoneEquality(Instant instant, DateTimeZone nodaZone, TimeZoneInfo windowsZone)
{
// The BCL is basically broken (up to and including .NET 4.5.1 at least) around its interpretation
// of its own data around the new year. See http://codeblog.jonskeet.uk/2014/09/30/the-mysteries-of-bcl-time-zone-data/
// for details. We're not trying to emulate this behaviour.
// It's a lot *better* for .NET 4.6,
// FIXME: Finish this comment, try again. (We don't test against .NET 4.5 any more...)
var utc = instant.InUtc();
if ((utc.Month == 12 && utc.Day == 31) || (utc.Month == 1 && utc.Day == 1))
{
return;
}
var interval = nodaZone.GetZoneInterval(instant);
// Check that the zone interval really represents a transition. It could be a change in
// wall offset, name, or the split between standard time and daylight savings for the interval.
if (interval.RawStart != Instant.BeforeMinValue)
{
var previousInterval = nodaZone.GetZoneInterval(interval.Start - Duration.Epsilon);
Assert.AreNotEqual(new { interval.WallOffset, interval.Name, interval.StandardOffset },
new { previousInterval.WallOffset, previousInterval.Name, previousInterval.StandardOffset },
"Non-transition from {0} to {1}", previousInterval, interval);
}
var nodaOffset = interval.WallOffset;
// Some midnight transitions in the Noda Time representation are actually corrections for the
// BCL data indicating 23:59:59.999 on the previous day. If we're testing around midnight,
// allow the Windows data to be correct for either of those instants.
var acceptableInstants = new List <Instant> {
instant
};
var localTimeOfDay = instant.InZone(nodaZone).TimeOfDay;
if ((localTimeOfDay == LocalTime.Midnight || localTimeOfDay == LocalTime.MaxValue) && instant > NodaConstants.BclEpoch)
{
acceptableInstants.Add(instant - Duration.FromMilliseconds(1));
}
var expectedOffsetAsTimeSpan = nodaOffset.ToTimeSpan();
// Find an instant that at least has the right offset (so will pass the first assertion).
var instantToTest = acceptableInstants.FirstOrDefault(candidate => windowsZone.GetUtcOffset(candidate.ToDateTimeUtc()) == expectedOffsetAsTimeSpan);
// If the test is definitely going to fail, just use the original instant that was passed in.
if (instantToTest == default)
{
instantToTest = instant;
}
var windowsOffset = windowsZone.GetUtcOffset(instantToTest.ToDateTimeUtc());
Assert.AreEqual(windowsOffset, expectedOffsetAsTimeSpan, "Incorrect offset at {0} in interval {1}", instantToTest, interval);
var bclDaylight = windowsZone.IsDaylightSavingTime(instantToTest.ToDateTimeUtc());
Assert.AreEqual(bclDaylight, interval.Savings != Offset.Zero,
"At {0}, BCL IsDaylightSavingTime={1}; Noda savings={2}",
instant, bclDaylight, interval.Savings);
}
private void TimeToJSON()
{
Instant now = SystemClock.Instance.Now;
String timeZone = TimeZoneInfo.Local.DisplayName;
long ticks = now.Ticks;
String timeZoneStan = TimeZoneInfo.Local.StandardName;
String timeZoneId = TimeZoneInfo.Local.Id;
var nowUtc = now.InUtc();
DateTimeOffset odt = DateTimeOffset.Now;
DateTime dt = odt.DateTime;
DateTimeZoneProviders.Serialization = DateTimeZoneProviders.Bcl;
//var curZone = DateTimeZoneProviders.Tzdb["Canada/Eastern"];
var curZone = DateTimeZoneProviders.Bcl[timeZoneId];
var nowZone = now.InZone(curZone);
var offset = nowZone.ToOffsetDateTime();
var duration = NodaTime.Duration.FromMinutes(3);
var local = new LocalDateTime(nowZone.Year, nowZone.Month, nowZone.Day, nowZone.Hour, nowZone.Minute, nowZone.Second, nowZone.Millisecond);
var localInUtc = local.InUtc();
var inst = localInUtc.ToInstant();
var odtToStr = odt.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture);
var offsetToStr = offset.ToString("yyyy-MM-ddTHH:mm:ss.ffffffo<m>", CultureInfo.InvariantCulture);
String nowStr = JsonConvert.SerializeObject(now, Formatting.None, settings);
String offSet = JsonConvert.SerializeObject(offset, Formatting.Indented, settings);
String utc = JsonConvert.SerializeObject(nowUtc, Formatting.None, settings);
String dur = JsonConvert.SerializeObject(duration, Formatting.None, settings);
String loc = JsonConvert.SerializeObject(local, Formatting.None, settings);
String loc2Str = local.ToString();
//JSONText = String.Format("Time: {0}\nOffset: {1}\nUtc time: {2}\nZoned time: {3}\nTime zone name: {4}\nTime zone name standard: {5}\nLocal time: {6}\nTostr local: {7}\nTicks: {8}",
// nowStr, offSet, utc, nowZone, timeZone, timeZoneStan, loc, loc2Str, ticks);
JSONText = String.Format("Time: {0}\nOffset: {1}\nZoned time: {2}\nOffset To String: {3}",
nowStr, offSet, nowZone, offset.ToString());
}
/// <summary>
/// BidAsk AddData
/// </summary>
/// <remarks>
/// Add Data on to the curve with Instant
/// </remarks>
/// <returns>AddBidAskOperationResult</returns>
public AddBidAskOperationResult AddData(Instant time, string product, BidAskValue value)
{
if (!_entity.OriginalGranularity.IsTimeGranularity())
{
throw new BidAskException("This MarketData has Date granularity. Use AddData(LocalDate date...)");
}
return(_addBidAsk(time.InUtc().LocalDateTime, product, value));
}
private Period GetPeriodFromNow(Instant pastInstant)
{
var now = _clock.GetCurrentInstant();
var today = now.InUtc().Date;
var pastDate = pastInstant.InUtc().Date;
var period = Period.Between(pastDate, today);
return(period);
}
static DateTimeOffset LocalTimeToUtc(string localDate)
{
var pattern = LocalDateTimePattern.CreateWithInvariantCulture("dd/MM/yyyy");
LocalDateTime ldt = pattern.Parse(localDate).Value;
ZonedDateTime zdt = ldt.InZoneLeniently(DateTimeZoneProviders.Tzdb["Australia/Sydney"]);
Instant instant = zdt.ToInstant();
ZonedDateTime utc = instant.InUtc();
return(utc.ToDateTimeOffset());
}
/// <summary>
/// If given <see cref="Instant"/> value of parameter <paramref name="calculatedTime"/> has second component larger than zero, the second component is resetted to zero and minute component is added with one.
/// </summary>
private static Instant RoundPrayerTime(Instant calculatedTime)
{
var utc = calculatedTime.InUtc();
if (utc.Second > 0)
{
calculatedTime = calculatedTime + Duration.FromSeconds(60 - utc.Second);
}
return(calculatedTime);
}
private Season ResolveSeason(Instant releaseDate)
{
var year = releaseDate.InUtc().Year;
var month = releaseDate.InUtc().Month;
string seasonPrefix;
if (month < 4)
{
seasonPrefix = "Winter";
}
else if (month < 7)
{
seasonPrefix = "Spring";
}
else if (month < 10)
{
seasonPrefix = "Summer";
}
else
{
seasonPrefix = "Autumn";
}
var season = new Season
{
Year = year,
Name = seasonPrefix + " " + year
};
var dbSeason = _dbContext.Seasons.FirstOrDefault(_ => _.Name == season.Name);
if (dbSeason != null)
{
return(dbSeason);
}
_dbContext.Add(season);
_dbContext.SaveChanges();
return(season);
}
/// <summary>
/// VersionedTimeSerie AddData
/// </summary>
/// <remarks>
/// Add Data on to the curve with Instant
/// </remarks>
/// <returns>AddTimeSerieOperationResult</returns>
public AddTimeSerieOperationResult AddData(Instant time, double?value)
{
Ensure.Any.IsNotNull(_entity);
if (!_entity.OriginalGranularity.IsTimeGranularity())
{
throw new VersionedTimeSerieException("This MarketData has Date granularity. Use AddData(LocalDate date, double? value)");
}
var localTime = time.InUtc().LocalDateTime;
return(_add(localTime, value));
}
/// <summary>
/// AuctionTimeSerie AddData
/// </summary>
/// <remarks>
/// Add Data on to the curve with Instant
/// </remarks>
/// <returns>AddAuctionTimeSerieOperationResult</returns>
public AddAuctionTimeSerieOperationResult AddData(Instant time, AuctionBidValue[] bid, AuctionBidValue[] offer)
{
Ensure.Any.IsNotNull(_entity);
if (!_entity.OriginalGranularity.IsTimeGranularity())
{
throw new AuctionTimeSerieException("This MarketData has Date granularity. Use AddData(LocalDate date, AuctionBidValue[] bid, AuctionBidValue[] offer)");
}
var localTime = time.InUtc().LocalDateTime;
return(_add(localTime, bid, offer));
}
/// <summary>
/// Converts the given object to the type of this converter, using the specified context and culture information.
/// </summary>
/// <returns>
/// An <see cref="T:System.Object"/> that represents the converted value.
/// </returns>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"/> that provides a format context. </param>
/// <param name="culture">The <see cref="T:System.Globalization.CultureInfo"/> to use as the current culture. </param>
/// <param name="value">The <see cref="T:System.Object"/> to convert. </param>
/// <exception cref="T:System.NotSupportedException">The conversion cannot be performed. </exception>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string @string = value as string;
if (@string != null)
{
LocalDateTime localDateTime;
if (TimeHelpers.GetLocalDateTimePatterns(culture).TryParseAny(@string.Trim(), out localDateTime))
{
return(localDateTime);
}
DateTime dateTime;
if (DateTime.TryParse(@string, out dateTime))
{
return(LocalDateTime.FromDateTime(dateTime));
}
throw new NotSupportedException(
// ReSharper disable once AssignNullToNotNullAttribute
string.Format(Resources.LocalDateTimeConverter_ConvertFrom_CannotParse, @string));
}
if (value is DateTime)
{
DateTime dateTime = (DateTime)value;
return(LocalDateTime.FromDateTime(dateTime));
}
if (value is DateTimeOffset)
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
return(LocalDateTime.FromDateTime(dateTimeOffset.LocalDateTime));
}
if (value is OffsetDateTime)
{
OffsetDateTime offsetDateTime = (OffsetDateTime)value;
return(offsetDateTime.LocalDateTime);
}
if (value is Instant)
{
Instant instant = (Instant)value;
return(instant.InUtc().LocalDateTime);
}
if (value is ZonedDateTime)
{
ZonedDateTime zonedDateTime = (ZonedDateTime)value;
return(zonedDateTime.LocalDateTime);
}
return(base.ConvertFrom(context, culture, value));
}
static void Main()
{
Instant now = SystemClock.Instance.Now;
Console.WriteLine("now : {0}", now);
ZonedDateTime utcNow = now.InUtc();
Console.WriteLine("utcNow : {0}", utcNow);
var poland = DateTimeZoneProviders.Tzdb["Europe/Warsaw"];
var polandTime = now.InZone(poland);
Console.WriteLine("in poland : {0}", polandTime);
}
/// <summary>
/// Converts a local-time DateTime to UTC DateTime based on the specified
/// timezone. The returned object will be of UTC DateTimeKind. To be used
/// when we want to know what's the UTC representation of the time somewhere
/// in the world.
/// </summary>
/// <param name="dateTime">Local DateTime as UTC or Unspecified DateTimeKind.</param>
/// <returns>UTC DateTime as UTC DateTimeKind.</returns>
internal static DateTime ToUTC(this DateTime localDateTime)
{
if (localDateTime.Kind == DateTimeKind.Local)
{
return(localDateTime.ToUniversalTime());
}
DateTimeZone zone = CultureHelper.GetDateTimeZone();
LocalDateTime asLocal = localDateTime.ToLocalDateTime();
ZonedDateTime asZoned = asLocal.InZoneLeniently(zone);
Instant instant = asZoned.ToInstant();
ZonedDateTime asZonedInUtc = instant.InUtc();
return(asZonedInUtc.ToDateTimeUtc());
}
/// <summary>
/// Converts a local-time DateTime to UTC DateTime based on the specified
/// timezone. The returned object will be of UTC DateTimeKind. To be used
/// when we want to know what's the UTC representation of the time somewhere
/// in the world.
/// </summary>
/// <param name="dateTime">Local DateTime as UTC or Unspecified DateTimeKind.</param>
/// <param name="timezone">Timezone name (in TZDB format).</param>
/// <returns>UTC DateTime as UTC DateTimeKind.</returns>
public static DateTime InZone(this DateTime dateTime, string timezone)
{
if (dateTime.Kind == DateTimeKind.Local)
{
throw new ArgumentException("Expected non-local kind of DateTime");
}
var zone = DateTimeZoneProviders.Tzdb[timezone];
LocalDateTime asLocal = dateTime.ToLocalDateTime();
ZonedDateTime asZoned = asLocal.InZoneLeniently(zone);
Instant instant = asZoned.ToInstant();
ZonedDateTime asZonedInUtc = instant.InUtc();
DateTime utc = asZonedInUtc.ToDateTimeUtc();
return(utc);
}
static void Main(string[] args)
{
Instant now = SystemClock.Instance.Now;
ZonedDateTime currentDate = now.InUtc();
CalculateKosmorDate(currentDate);
WebClient client = new WebClient();
string result = client.DownloadString("http://www.kosmor.de/forum/viewforum.php?f=-8");
string id = FindCurrentId(result);
GetNewsPost(id);
Console.ReadKey();
}
/// <summary>
/// Convert Instant to ISO 8601 long with millisecond precision
/// using yyyymmddhhmmssfff format in UTC.
///
/// Error message if equal to the default constructed value.
/// </summary>
public static long ToIsoLong(this Instant value)
{
// If default constructed datetime is passed, error message
if (value == InstantUtil.Empty)
{
throw new Exception(
$"Default constructed (empty) Instant {value} has been passed to ToIsoLong() method.");
}
// Convert to zoned date time in UTC timezone, then take LocalDateTime component of the result
var dateTimeInUtc = value.InUtc().LocalDateTime;
// Convert the result to long
long result = dateTimeInUtc.ToIsoLong();
return(result);
}
/// <summary>
/// Converts the given value object to the specified type, using the specified context and culture information.
/// </summary>
/// <returns>
/// An <see cref="T:System.Object"/> that represents the converted value.
/// </returns>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"/> that provides a format context. </param>
/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo"/>. If null is passed, the current culture is assumed. </param>
/// <param name="value">The <see cref="T:System.Object"/> to convert. </param>
/// <param name="destinationType">The <see cref="T:System.Type"/> to convert the <paramref name="value"/> parameter to. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="destinationType"/> parameter is null. </exception>
/// <exception cref="T:System.NotSupportedException">The conversion cannot be performed. </exception>
public override object ConvertTo(
ITypeDescriptorContext context,
CultureInfo culture,
[NotNull] object value,
Type destinationType)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (destinationType == null)
{
throw new ArgumentNullException(nameof(destinationType));
}
Instant instant = (Instant)value;
if (destinationType == typeof(string))
{
// ReSharper disable once PossibleNullReferenceException
return(InstantPattern.ExtendedIsoPattern.Format(instant));
}
if (destinationType == typeof(DateTime))
{
return(instant.ToDateTimeUtc());
}
if (destinationType == typeof(DateTimeOffset))
{
return(instant.ToDateTimeOffset());
}
if (destinationType == typeof(ZonedDateTime))
{
return(instant.InUtc());
}
if (destinationType == typeof(OffsetDateTime))
{
return(OffsetDateTime.FromDateTimeOffset(instant.ToDateTimeOffset()));
}
return(base.ConvertTo(context, culture, value, destinationType));
}
/// <summary>
/// Generate prayer times for one day at given date.
/// </summary>
/// <param name="when">
/// <see cref="Instant" /> value which represents the date.
/// </param>
/// <param name="settings">
/// Settings containing parameters for calculating prayer times.
/// </param>
/// <param name="coordinate">
/// Location's coordinate.
/// </param>
/// <param name="timeZone">
/// Location's time zone.
/// </param>
/// <returns>
/// <see cref="Prayers" /> object containing prayer times for one day at given date.
/// </returns>
internal static Prayers GetPrayerTimesForOneDay(Instant when, [NotNull] PrayerCalculationSettings settings, Geocoordinate coordinate, double timeZone)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var utc = when.InUtc();
var year = utc.Year;
var month = utc.Month;
var day = utc.Day;
var local = new LocalDate(year, month, day);
var newUtc = new ZonedDateTime(local.AtMidnight(), DateTimeZone.Utc, Offset.Zero);
var jd = newUtc.ToInstant().ToJulianDate() - (coordinate.Longitude / 360.0);
var raw = ComputeRaw(jd, settings, coordinate.Latitude, coordinate.Altitude);
var afterAdjustment = AdjustTime(raw, settings, coordinate.Longitude, timeZone);
// Calculate midnight.
var fajr = afterAdjustment.Fajr;
var sunrise = afterAdjustment.Sunrise;
var sunset = afterAdjustment.Sunset;
afterAdjustment.Midnight = ComputeMidnightTime(settings.CalculationMethod.MidnightMethod, fajr, sunrise, sunset);
// Convert.
var converted = ConvertFromFloatingPointFormat(afterAdjustment, year, month, day, timeZone);
// Round.
var rounded = new Prayers(RoundPrayerTime(converted.Imsak),
RoundPrayerTime(converted.Fajr),
RoundPrayerTime(converted.Sunrise),
RoundPrayerTime(converted.Dhuha),
RoundPrayerTime(converted.Zuhr),
RoundPrayerTime(converted.Asr),
RoundPrayerTime(converted.Sunset),
RoundPrayerTime(converted.Maghrib),
RoundPrayerTime(converted.Isha),
RoundPrayerTime(converted.Midnight));
return(rounded);
}
private void ValidateZoneEquality(Instant instant, DateTimeZone nodaZone, TimeZoneInfo windowsZone)
{
// Skip just the first transition in Libya. It's broken in Windows.
// See issue 220 for the background.
if (windowsZone.Id == "Libya Standard Time" && instant.InUtc().Year == 2011)
{
return;
}
var interval = nodaZone.GetZoneInterval(instant);
// Check that the zone interval really represents a transition.
if (interval.Start != Instant.MinValue)
{
Assert.AreNotEqual(interval.WallOffset, nodaZone.GetUtcOffset(interval.Start - Duration.Epsilon));
}
var nodaOffset = interval.WallOffset;
var windowsOffset = windowsZone.GetUtcOffset(instant.ToDateTimeUtc());
Assert.AreEqual(windowsOffset, nodaOffset.ToTimeSpan(), "Incorrect offset at " + instant + " in interval " + interval);
}
private async Task <bool> WasLastRunToday()
{
today = SystemClock.Instance.GetCurrentInstant();
todayUtc = today.InUtc();
Instant lastRun = Instant.MinValue;
try
{
// ConfigCache updates every 5 minutes (see JobFac.Library.ConstTimeouts)
// so it will always be up-to-date since ScheduleWriter is invoked on a
// 15-minute cycle (also defined in ConstTimeouts).
var lastRunTimestamp = await configCache.GetValue(ConstConfigKeys.ScheduleWriterLastRunDateUtc);
lastRun = InstantPattern.General.Parse(lastRunTimestamp).GetValueOrThrow();
}
catch
{ }
return(todayUtc.Date == lastRun.InUtc().Date);
}
/// <summary>
/// Returns the next date time for the given target local time (UTC).
/// </summary>
/// <param name="target">The target time of day.</param>
/// <param name="now">The current time instant.</param>
/// <returns>The next date time (UTC).</returns>
public static ZonedDateTime GetNextUtc([CanBeDefault] LocalTime target, [CanBeDefault] Instant now)
{
var localNow = now.InZone(DateTimeZone.Utc).LocalDateTime;
var localTarget = new LocalDateTime(
localNow.Year,
localNow.Month,
localNow.Day,
target.Hour,
target.Minute,
target.Second,
target.Millisecond);
var nextToday = new ZonedDateTime(localTarget, DateTimeZone.Utc, Offset.Zero);
if (nextToday.IsLessThanOrEqualTo(now.InUtc()))
{
localTarget += Period.FromDays(1);
nextToday = new ZonedDateTime(localTarget, DateTimeZone.Utc, Offset.Zero);
}
return(nextToday);
}
private static void AssertEqualInstant(Instant expected, Instant actual)
{
var expectedUtc = expected.InUtc();
var expectedYear = expectedUtc.Year;
var expectedMonth = expectedUtc.Month;
var expectedDay = expectedUtc.Day;
var expectedHour = expectedUtc.Hour;
var expectedMinute = expectedUtc.Minute;
var actualUtc = actual.InUtc();
var actualYear = actualUtc.Year;
var actualMonth = actualUtc.Month;
var actualDay = actualUtc.Day;
var actualHour = actualUtc.Hour;
var actualMinute = actualUtc.Minute;
Assert.Equal(expectedYear, actualYear);
Assert.Equal(expectedMonth, actualMonth);
Assert.Equal(expectedDay, actualDay);
Assert.Equal(expectedHour, actualHour);
Assert.Equal(expectedMinute, actualMinute);
}
/// <summary>
/// Serializes the <see cref="Instant"/> for SQL Server queries.
/// </summary>
/// <param name="instant">An instant.</param>
/// <param name="decimalPlaces">Number of digits after the decimal. Must be between 0 and 7 (both included).</param>
/// <returns>A SQL formatted string representation of <paramref name="instant"/>.</returns>
/// <seealso cref="ToQuotedSqlString(Instant)"/>
public static string ToSqlString(this Instant instant, int decimalPlaces)
{
if (decimalPlaces < 0 || 7 < decimalPlaces)
{
throw new ArgumentOutOfRangeException(nameof(decimalPlaces), "Value must be between 0 and 7 (both included).");
}
if (instant.InUtc().TimeOfDay == LocalTime.Midnight)
{
return(PatternWithoutTime.Format(instant));
}
if (decimalPlaces == 7)
{
return(PatternWithSevenDecimalPlaces.Format(instant));
}
if (decimalPlaces == 0)
{
return(PatternWithNoDecimalPlaces.Format(instant));
}
return(InstantPattern.CreateWithInvariantCulture(@"yyyy'-'MM'-'dd HH':'mm':'ss." + new string('F', decimalPlaces)).Format(instant));
}
private LocalDateTime GetStartOfMonth(Instant instant) => GetStartOfMonth(instant.InUtc().LocalDateTime);
public ZonedDateTime InUtc()
{
return(Sample.InUtc());
}
private void ValidateZoneEquality(Instant instant, DateTimeZone nodaZone, TimeZoneInfo windowsZone)
{
// The BCL is basically broken (up to and including .NET 4.5.1 at least) around its interpretation
// of its own data around the new year. See http://codeblog.jonskeet.uk/2014/09/30/the-mysteries-of-bcl-time-zone-data/
// for details. We're not trying to emulate this behaviour.
// It's a lot *better* for .NET 4.6,
var utc = instant.InUtc();
if ((utc.Month == 12 && utc.Day == 31) || (utc.Month == 1 && utc.Day == 1))
{
return;
}
var interval = nodaZone.GetZoneInterval(instant);
// Check that the zone interval really represents a transition. It could be a change in
// wall offset, name, or the split between standard time and daylight savings for the interval.
if (interval.RawStart != Instant.BeforeMinValue)
{
var previousInterval = nodaZone.GetZoneInterval(interval.Start - Duration.Epsilon);
Assert.AreNotEqual(new {interval.WallOffset, interval.Name, interval.StandardOffset},
new {previousInterval.WallOffset, previousInterval.Name, previousInterval.StandardOffset},
"Non-transition from {0} to {1}", previousInterval, interval);
}
var nodaOffset = interval.WallOffset;
var windowsOffset = windowsZone.GetUtcOffset(instant.ToDateTimeUtc());
Assert.AreEqual(windowsOffset, nodaOffset.ToTimeSpan(), $"Incorrect offset at {instant} in interval {interval}");
var bclDaylight = windowsZone.IsDaylightSavingTime(instant.ToDateTimeUtc());
Assert.AreEqual(bclDaylight, interval.Savings != Offset.Zero,
$"At {instant}, BCL IsDaylightSavingTime={bclDaylight}; Noda savings={interval.Savings}");
}
public ZonedDateTime InUtc() => Sample.InUtc();
/// <summary>
/// Sets the calculation method parameters from given method preset.
/// </summary>
/// <param name="instant">
/// <see cref="Instant" /> of time.
/// </param>
/// <param name="preset">
/// <see cref="CalculationMethodPreset" /> to set.
/// </param>
public void SetCalculationMethodPreset(Instant instant, CalculationMethodPreset preset)
{
//
// Umm Al-Qura University, Makkah
if (preset == CalculationMethodPreset.UmmAlQuraUniversity)
{
// Convert Gregorian date to Hijri.
var calendarSystem = CalendarSystem.IslamicBcl;
var hijri = instant.InUtc().WithCalendar(calendarSystem);
var isBefore1430H = hijri.Year < 1430;
var isRamadhan = hijri.Month == 9;
Preset = CalculationMethodPreset.UmmAlQuraUniversity;
FajrParameter.Value = isBefore1430H ? 19 : 18.5;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = isRamadhan ? 120.0 : 90.0;
IshaParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
MidnightMethod = Midnight.Standard;
return;
}
switch (preset)
{
case CalculationMethodPreset.IthnaAshari:
Preset = CalculationMethodPreset.IthnaAshari;
FajrParameter.Value = 16.0;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 4.0;
MaghribParameter.Type = PrayerCalculationParameterType.Angle;
IshaParameter.Value = 14.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Jafari;
return;
case CalculationMethodPreset.UniversityOfIslamicSciencesKarachi:
Preset = CalculationMethodPreset.UniversityOfIslamicSciencesKarachi;
FajrParameter.Value = 18.0;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = 18.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Standard;
return;
case CalculationMethodPreset.IslamicSocietyOfNorthAmerica:
Preset = CalculationMethodPreset.IslamicSocietyOfNorthAmerica;
FajrParameter.Value = 15.0;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = 15.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Standard;
return;
case CalculationMethodPreset.MuslimWorldLeague:
Preset = CalculationMethodPreset.MuslimWorldLeague;
FajrParameter.Value = 18.0;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = 17.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Standard;
return;
case CalculationMethodPreset.EgyptianGeneralAuthorityOfSurvey:
Preset = CalculationMethodPreset.EgyptianGeneralAuthorityOfSurvey;
FajrParameter.Value = 19.5;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = 17.5;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Standard;
return;
case CalculationMethodPreset.InstituteOfGeophysicsUniversityOfTehran:
Preset = CalculationMethodPreset.InstituteOfGeophysicsUniversityOfTehran;
FajrParameter.Value = 17.7;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 4.5;
MaghribParameter.Type = PrayerCalculationParameterType.Angle;
IshaParameter.Value = 14.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Jafari;
return;
case CalculationMethodPreset.UnionDesOrganisationsIslamiquesDeFrance:
Preset = CalculationMethodPreset.UnionDesOrganisationsIslamiquesDeFrance;
FajrParameter.Value = 12.0;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = 12.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Standard;
return;
case CalculationMethodPreset.MajlisUgamaIslamSingapura:
Preset = CalculationMethodPreset.MajlisUgamaIslamSingapura;
FajrParameter.Value = 20.0;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = 18.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Standard;
return;
case CalculationMethodPreset.DepartmentOfIslamicAdvancementOfMalaysia:
Preset = CalculationMethodPreset.DepartmentOfIslamicAdvancementOfMalaysia;
FajrParameter.Value = 20.0;
FajrParameter.Type = PrayerCalculationParameterType.Angle;
MaghribParameter.Value = 0.0;
MaghribParameter.Type = PrayerCalculationParameterType.MinutesAdjust;
IshaParameter.Value = 18.0;
IshaParameter.Type = PrayerCalculationParameterType.Angle;
MidnightMethod = Midnight.Standard;
return;
default:
throw new ArgumentOutOfRangeException(nameof(preset));
}
}
public static Serial NewSerial(Instant instant)
{
var utc = instant.InUtc();
return(new Serial(utc.Year, utc.Month, utc.Day, 0));
}
