public void Can_Query_By_Equals_ZonedDateTime_Stored_As_DateTimeOffset() { var timeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault(); Instant now = TestClock.Now; ZonedDateTime startZonedDateTime = now.InZone(timeZone); ZonedDateTime finishZonedDateTime = startZonedDateTime.Plus(Duration.FromHours(1)); var testEvent = new ZonedDateTimeTestEntity { Description = "Can_Query_By_Equals_ZonedDateTime_Stored_As_DateTimeOffset", StartZonedDateTime = startZonedDateTime, FinishZonedDateTime = finishZonedDateTime }; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { session.Save(testEvent); transaction.Commit(); } var searchTime = new ZonedDateTime(finishZonedDateTime.ToInstant(), finishZonedDateTime.Zone); using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var query = session.Query <ZonedDateTimeTestEntity>().Where(x => x.FinishZonedDateTime == searchTime); var retrievedEvent = query.SingleOrDefault(); transaction.Commit(); Assert.That(testEvent, Is.Not.Null); Assert.That(testEvent, Is.EqualTo(retrievedEvent)); } }
public void Can_Write_And_Read_ZonedDateTime_Stored_As_DateTimeOffset() { var timeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault(); Instant now = TestClock.Now; ZonedDateTime startZonedDateTime = now.InZone(timeZone); ZonedDateTime finishZonedDateTime = startZonedDateTime.Plus(Duration.FromHours(1)); var testEvent = new ZonedDateTimeTestEntity { Description = "Can_Write_And_Read_ZonedDateTime_Stored_As_DateTimeOffset", StartZonedDateTime = startZonedDateTime, FinishZonedDateTime = finishZonedDateTime }; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { session.Save(testEvent); transaction.Commit(); } ZonedDateTimeTestEntity retrievedEvent; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { retrievedEvent = session.Get <ZonedDateTimeTestEntity>(testEvent.Id); transaction.Commit(); } Assert.That(retrievedEvent.StartZonedDateTime, Is.EqualTo(testEvent.StartZonedDateTime)); Assert.That(retrievedEvent.FinishZonedDateTime, Is.EqualTo(testEvent.FinishZonedDateTime)); Assert.That(retrievedEvent, Is.EqualTo(testEvent)); }
public void Add_MethodEquivalents() { const int minutes = 23; const int hours = 3; const int milliseconds = 40000; const long seconds = 321; const long nanoseconds = 12345; const long ticks = 5432112345; ZonedDateTime before = SampleZone.AtStrictly(new LocalDateTime(2011, 6, 12, 15, 0)); Assert.AreEqual(before + Duration.OneDay, ZonedDateTime.Add(before, Duration.OneDay)); Assert.AreEqual(before + Duration.OneDay, before.Plus(Duration.OneDay)); Assert.AreEqual(before + Duration.FromHours(hours), before.PlusHours(hours)); Assert.AreEqual(before + Duration.FromHours(-hours), before.PlusHours(-hours)); Assert.AreEqual(before + Duration.FromMinutes(minutes), before.PlusMinutes(minutes)); Assert.AreEqual(before + Duration.FromMinutes(-minutes), before.PlusMinutes(-minutes)); Assert.AreEqual(before + Duration.FromSeconds(seconds), before.PlusSeconds(seconds)); Assert.AreEqual(before + Duration.FromSeconds(-seconds), before.PlusSeconds(-seconds)); Assert.AreEqual(before + Duration.FromMilliseconds(milliseconds), before.PlusMilliseconds(milliseconds)); Assert.AreEqual(before + Duration.FromMilliseconds(-milliseconds), before.PlusMilliseconds(-milliseconds)); Assert.AreEqual(before + Duration.FromTicks(ticks), before.PlusTicks(ticks)); Assert.AreEqual(before + Duration.FromTicks(-ticks), before.PlusTicks(-ticks)); Assert.AreEqual(before + Duration.FromNanoseconds(nanoseconds), before.PlusNanoseconds(nanoseconds)); Assert.AreEqual(before + Duration.FromNanoseconds(-nanoseconds), before.PlusNanoseconds(-nanoseconds)); }
public void Can_Query_By_Equals_OffsetDateTime_Stored_As_DateTimeOffset() { var timeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault(); Instant now = TestClock.Now; ZonedDateTime zonedNowDateTime = now.InZone(timeZone); var zonedFinishDateTime = zonedNowDateTime.Plus(Duration.FromMinutes(60)); var offsetFinishTime = new OffsetDateTime(zonedFinishDateTime.LocalDateTime, zonedFinishDateTime.Offset); var testEvent = new OffsetDateTimeTestEntity { Description = "Can_Query_By_Equals_OffsetDateTime_Stored_As_DateTimeOffset", SystemDateTimeOffset = DateTimeOffset.Now, StartOffsetDateTime = new OffsetDateTime(zonedNowDateTime.LocalDateTime, zonedNowDateTime.Offset), FinishOffsetDateTime = offsetFinishTime }; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { session.Save(testEvent); transaction.Commit(); } using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var query = session.Query <OffsetDateTimeTestEntity>().Where(x => x.FinishOffsetDateTime == offsetFinishTime); var retrievedEvent = query.SingleOrDefault(); transaction.Commit(); Assert.That(testEvent, Is.Not.Null); Assert.That(testEvent, Is.EqualTo(retrievedEvent)); } }
public void Add_MethodEquivalents() { ZonedDateTime before = SampleZone.AtStrictly(new LocalDateTime(2011, 6, 12, 15, 0)); Assert.AreEqual(before + Duration.OneStandardDay, ZonedDateTime.Add(before, Duration.OneStandardDay)); Assert.AreEqual(before + Duration.OneStandardDay, before.Plus(Duration.OneStandardDay)); }
public void Can_Query_By_LessThan_ZonedDateTime_Stored_As_DateTimeOffset() { var timeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault(); Instant startInstant = TestClock.Now.Minus(Duration.FromHours(24)); ZonedDateTime startZonedDateTime = startInstant.InZone(timeZone); ZonedDateTime finishZonedDateTime = startZonedDateTime.Plus(Duration.FromHours(1)); var testEvent = new ZonedDateTimeTestEntity { Description = "Can_Query_By_LessThan_ZonedDateTime_Stored_As_DateTimeOffset", StartZonedDateTime = startZonedDateTime, FinishZonedDateTime = finishZonedDateTime }; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { session.Save(testEvent); transaction.Commit(); } ZonedDateTime beforeStart = startZonedDateTime.Plus(Duration.FromMinutes(1)); using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var query = session.Query <ZonedDateTimeTestEntity>() .Where(x => x.Id == testEvent.Id && x.StartZonedDateTime.ToDateTimeOffset() < beforeStart.ToDateTimeOffset()); var retrievedEvent = query.SingleOrDefault(); transaction.Commit(); Assert.That(testEvent, Is.Not.Null); Assert.That(testEvent, Is.EqualTo(retrievedEvent)); } using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var query = session.Query <ZonedDateTimeTestEntity>() .Where(x => x.Id == testEvent.Id && x.StartZonedDateTime.ToDateTimeOffset() < beforeStart.ToDateTimeOffset() && x.FinishZonedDateTime.Value.ToDateTimeOffset() <= finishZonedDateTime.ToDateTimeOffset()); var retrievedEvent = query.SingleOrDefault(); transaction.Commit(); Assert.That(testEvent, Is.Not.Null); Assert.That(testEvent, Is.EqualTo(retrievedEvent)); } }
public void Future_with_options() { var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc); dataSet.Future(reference: starting, daysToGoForward: 500).ToDateTimeUtc().Should() .BeOnOrBefore(starting.Plus(Duration.FromDays(500)).ToDateTimeUtc()) .And .BeOnOrAfter(starting.ToDateTimeUtc()); }
public void Future() { var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc); var zonedDateTime = dataSet.Future(reference: starting).ToDateTimeUtc(); zonedDateTime.Should() .BeOnOrBefore(starting.Plus(Duration.FromDays(100)).ToDateTimeUtc()) .And .BeOnOrAfter(starting.ToDateTimeUtc()); }
public void Update(Size availableSize, Instant firstVisibleDay) { ColumnWidth = LayoutHelper.RoundLayoutValue(availableSize.Width / ColumnsCount); if (DoubleUtil.GreaterThanOrClose(ColumnWidth * ColumnsCount, availableSize.Width) == true) { ColumnWidth = LayoutHelper.FloorLayoutValue(availableSize.Width / ColumnsCount); } RowsHeight = LayoutHelper.RoundLayoutValue(availableSize.Height / RowsCount); if (DoubleUtil.GreaterThanOrClose(RowsHeight * RowsCount, availableSize.Height) == true) { RowsHeight = LayoutHelper.FloorLayoutValue(availableSize.Height / RowsCount); } GridCellSize = new Size(ColumnWidth, RowsHeight); Bounds = LayoutHelper.RoundLayoutRect3(new Rect(0, 0, ColumnWidth * ColumnsCount, RowsHeight * RowsCount)); double columnOffset = 0; Grid = new MonthViewDay[RowsCount][]; IClock systemClock = SystemClock.Instance; Instant now = systemClock.GetCurrentInstant(); DateTimeZone tz = DateTimeZoneProviders.Tzdb.GetSystemDefault(); LocalDate today = now.InZone(tz).Date; ZonedDateTime currentDay = tz.AtStartOfDay(today); for (int rowIndex = 0; rowIndex < RowsCount; rowIndex++) { columnOffset = 0; Grid[rowIndex] = new MonthViewDay[ColumnsCount]; for (int columnIndex = 0; columnIndex < ColumnsCount; columnIndex++) { // ColumnWidth and RowHeight should be already layout rounded - so no need to round the rect bounds var day = new MonthViewDay(); day.GridCell = new Rect(columnIndex * ColumnWidth, rowIndex * RowsHeight, ColumnWidth, RowsHeight); var nextDay = currentDay.Plus(NodaTime.Duration.FromDays(1)); day.Day = new Interval(currentDay.ToInstant(), nextDay.ToInstant()); // may be we should use 23:59:99999 as end interval????? currentDay = nextDay; Grid[rowIndex][columnIndex] = day; } columnOffset += ColumnWidth; } }
public void Can_Query_By_Equals_Using_A_UtcTime_OffsetDateTime_Stored_As_DateTimeOffset() { var timeZoneUnitedKingdom = DateTimeZoneProviders.Tzdb.GetZoneOrNull("Europe/London"); LocalDateTime localTimeInUnitedKingom = new LocalDateTime(2016, 06, 01, 10, 40); ZonedDateTime zonedStartDateTime = localTimeInUnitedKingom.InZoneStrictly(timeZoneUnitedKingdom); ZonedDateTime zonedFinishDateTime = zonedStartDateTime.Plus(Duration.FromMinutes(60)); ZonedDateTime matchingUtcZonedDateTime = zonedStartDateTime.WithZone(DateTimeZone.Utc); var offsetStartTime = new OffsetDateTime(zonedStartDateTime.LocalDateTime, zonedStartDateTime.Offset); var offsetFinishTime = new OffsetDateTime(zonedFinishDateTime.LocalDateTime, zonedFinishDateTime.Offset); var offsetStartTimeUtc = matchingUtcZonedDateTime.ToOffsetDateTime(); var testEvent = new OffsetDateTimeTestEntity { Description = "Can_Query_By_Equals_Using_A_UtcTime_OffsetDateTime_Stored_As_DateTimeOffset", SystemDateTimeOffset = DateTimeOffset.Now, StartOffsetDateTime = offsetStartTime, FinishOffsetDateTime = offsetFinishTime }; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { session.Save(testEvent); transaction.Commit(); } // Even though two OffsetDateTimes may refer to the same instant... Assert.That(offsetStartTime.ToInstant(), Is.EqualTo(offsetStartTimeUtc.ToInstant())); // They are not considered equal by NodaTime unless the LocalDateTime and Offset parts are both equal. // (There is nothing wrong with this, it is perfectly valid logic for comparing two OffsetDateTimes.) Assert.That(offsetStartTime, Is.Not.EqualTo(offsetStartTimeUtc)); // However we are storing OffsetDateTimes as DateTimeOffsets in the sql server. // So when using Linq and sending the expression to the sql server, // the sql server will convert all DateTimeOffsets to utc time before comparing them. // Therefore the same two OffsetDateTimes that are not equal as shown above are seen as being equal by sql. using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var query = session.Query <OffsetDateTimeTestEntity>().Where(x => x.StartOffsetDateTime == offsetStartTimeUtc); var retrievedEvent = query.SingleOrDefault(); transaction.Commit(); Assert.That(testEvent, Is.Not.Null); Assert.That(testEvent, Is.EqualTo(retrievedEvent)); } }
public void Can_RoundTrip_A_ZonedDateTime_To_DateTimeOffset_Using_Persistence() { var systemDateTimeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault(); Instant now = TestClock.Now; var zonedDateTimeStart = new ZonedDateTime(now, systemDateTimeZone); var zonedDateTimeFinish = zonedDateTimeStart.Plus(Duration.FromMinutes(60)); var testLocation = new LocationTestEntity { Description = "Can_RoundTrip_A_ZonedDateTime_To_DateTimeOffset_Using_Persistence", LocationDateTimeZone = systemDateTimeZone }; var testEvent = new DateTimeOffsetTestEntity { Description = "Can_RoundTrip_A_ZonedDateTime_To_DateTimeOffset_Using_Persistence", EventLocation = testLocation, StartDateTimeOffset = zonedDateTimeStart.ToDateTimeOffset(), FinishDateTimeOffset = zonedDateTimeFinish.ToDateTimeOffset() }; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { session.Save(testLocation); session.Save(testEvent); transaction.Commit(); } ZonedDateTime retrievedZonedDateStart; ZonedDateTime retrievedZonedDateFinish; using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var retrievedEvent = session.Get <DateTimeOffsetTestEntity>(testEvent.Id); retrievedZonedDateStart = retrievedEvent.StartDateTimeOffset.ToZonedDateTime(retrievedEvent.EventLocation.LocationDateTimeZone); retrievedZonedDateFinish = retrievedEvent.FinishDateTimeOffset.ToZonedDateTime(retrievedEvent.EventLocation.LocationDateTimeZone); transaction.Commit(); } Assert.That(zonedDateTimeStart, Is.EqualTo(retrievedZonedDateStart)); Assert.That(zonedDateTimeFinish, Is.EqualTo(retrievedZonedDateFinish)); }
public static void CalculateKosmorDate(ZonedDateTime currentDate) { LocalDateTime localTime = new LocalDateTime(2004, 2, 1, 0, 0); ZonedDateTime startDate = new ZonedDateTime(localTime, DateTimeZone.Utc, Offset.Zero); int kosmorDay = 6; int kosmorYear = 3500; PeriodBuilder pb = new PeriodBuilder(); pb.Milliseconds = MILLISECONDS_IN_A_DAY; Period period = pb.Build(); ZonedDateTime date = currentDate.Minus(period.ToDuration()); while (startDate < currentDate) { startDate = startDate.Plus(period.ToDuration()); if (currentDate.Calendar.IsLeapYear(currentDate.Year)) { if (kosmorDay > 366) { kosmorDay = 1; kosmorYear++; } else { kosmorDay++; } } else if (kosmorDay > 365) { kosmorDay = 1; kosmorYear++; } else { kosmorDay++; } } String formattedKosmorDay = kosmorDay.ToString("#000"); kosmorDate = kosmorYear + "_" + formattedKosmorDay; }
public void AddDuration() { // Europe/Dublin transitions from UTC+1 to UTC+0 at 2am (local) on 2017-10-29 var dt = new LocalDateTime(2017, 10, 29, 1, 45, 0); DateTimeZone dublin = DateTimeZoneProviders.Tzdb["Europe/Dublin"]; ZonedDateTime beforeTransition = new ZonedDateTime(dt, dublin, Offset.FromHours(1)); var result = Snippet.For(ZonedDateTime.Add(beforeTransition, Duration.FromHours(1))); Assert.AreEqual(new LocalDate(2017, 10, 29), result.Date); // Adding an hour of elapsed time takes us across the DST transition, so we have // the same local time (shown on a clock) but a different offset. Assert.AreEqual(new ZonedDateTime(dt, dublin, Offset.FromHours(0)), result); // The + operator and Plus instance method are equivalent to the Add static method. var result2 = Snippet.For(beforeTransition + Duration.FromHours(1)); var result3 = Snippet.For(beforeTransition.Plus(Duration.FromHours(1))); Assert.AreEqual(result, result2); Assert.AreEqual(result, result3); }
public void Can_Write_Calculated_OffsetDateTime_Stored_As_DateTimeOffset() { using (ISession session = SessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var timeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault(); Instant now = TestClock.Now; ZonedDateTime zonedNowDateTime = now.InZone(timeZone); var zonedFinishDateTime = zonedNowDateTime.Plus(Duration.FromMinutes(60)); var testEvent = new OffsetDateTimeTestEntity { Description = "Can_Write_Calculated_OffsetDateTime_Stored_As_DateTimeOffset", SystemDateTimeOffset = DateTimeOffset.Now, StartOffsetDateTime = new OffsetDateTime(zonedNowDateTime.LocalDateTime, zonedNowDateTime.Offset), FinishOffsetDateTime = new OffsetDateTime(zonedFinishDateTime.LocalDateTime, zonedFinishDateTime.Offset) }; session.Save(testEvent); transaction.Commit(); Assert.That(testEvent.Id, Is.Not.Null); } }
internal static ZonedDateTime PlusFromDateTime(this ZonedDateTime instance, Duration duration) => instance.Plus(duration);
public Turn(Player player, ZonedDateTime createdAt, Duration maxTurnLength) { Player = player; CreatedAt = createdAt; ExpiresAt = createdAt.Plus(maxTurnLength); }
public static ZonedDateTime PlusDays(this ZonedDateTime time, long days) { return(time.Plus(Duration.FromStandardDays(days))); }
/// <summary> /// we must create a daily list based on the day starting at 5am eastern time /// </summary> /// <param name="listTimestamp">timestamp of list</param> /// <param name="currentTimestamp">simulate the time of day</param> /// <returns></returns> static bool CreateNewDailyList(DateTimeOffset listTimestamp, DateTimeOffset currentTimestamp) { var dayStartHour = 5; var list = new ZonedDateTime(Instant.FromDateTimeOffset(listTimestamp), eastern); //var current = new ZonedDateTime(Instant.FromDateTimeUtc(DateTime.UtcNow), eastern); var current = new ZonedDateTime(Instant.FromDateTimeOffset(currentTimestamp), eastern); // my start of day will be 5am eastern time if (current.Hour < dayStartHour) { current = current.Date.PlusDays(-1).AtStartOfDayInZone(eastern).Plus(Duration.FromHours(dayStartHour)); } else { current = current.Date.AtStartOfDayInZone(eastern).Plus(Duration.FromHours(dayStartHour)); } return(list.LocalDateTime < current.LocalDateTime || list.LocalDateTime >= current.Plus(Duration.FromDays(1)).LocalDateTime); }