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);
}
