public void ToInstant()
{
Instant instant = Instant.FromUtc(2012, 6, 25, 16, 5, 20);
LocalDateTime local = new LocalDateTime(2012, 6, 25, 21, 35, 20);
Offset offset = Offset.FromHoursAndMinutes(5, 30);
OffsetDateTime odt = new OffsetDateTime(local, offset);
Assert.AreEqual(instant, odt.ToInstant());
}
public void ToInstant()
{
Instant instant = Instant.FromUtc(2012, 6, 25, 16, 5, 20);
LocalDateTime local = new LocalDateTime(2012, 6, 25, 21, 35, 20);
Offset offset = Offset.FromHoursAndMinutes(5, 30);
OffsetDateTime odt = new OffsetDateTime(local, offset);
Assert.AreEqual(instant, odt.ToInstant());
}
public static bool OffsetDateTimeConverter(string name, OffsetDateTime value, QueryValueConvertionType type, out string strValue)
{
var instant = value.ToInstant();
NodaUtil.Instant.Validate(instant);
strValue = instant.ToString(NodaUtil.Instant.FullIsoPattern.PatternText, null);
return(true);
}
public void Write(OffsetDateTime value, NpgsqlWriteBuffer buf, NpgsqlParameter?parameter)
{
var instant = value.ToInstant();
if (!DisableDateTimeInfinityConversions && (instant == Instant.MaxValue || instant == Instant.MinValue))
{
throw new InvalidCastException("Infinity values not supported for timestamp with time zone");
}
_wrappedHandler.Write(instant, buf, parameter);
}
private static Instant GetRuleEnd(TimeZoneInfo.AdjustmentRule rule, Transition transition)
{
if (rule.DateEnd.Year == 9999)
{
return(Instant.MaxValue);
}
// We work out the instant at which the *current* offset reaches the end of the given date.
LocalDateTime ruleEndLocal = LocalDateTime.FromDateTime(rule.DateEnd).PlusDays(1);
OffsetDateTime ruleEndOffset = new OffsetDateTime(ruleEndLocal, transition.NewOffset);
return(ruleEndOffset.ToInstant());
}
public async Task When_recruitment_form_is_submitted_repo_contains_its_readmodel()
{
// Arrange
var repo = new EnrollmentRepository();
var campaign = new Impl.Entities.Campaign(now.Minus(aWeek), now.Plus(aWeek), editionId: 1);
campaign.GetType().GetProperty(nameof(campaign.Id)).SetValue(campaign, 1);
var training = new Impl.Entities.Training("Papieska 21/37", "Wadowice", now.Plus(2 * aWeek), now.Plus(2 * aWeek + anHour), Guid.NewGuid());
training.GetType().GetProperty(nameof(training.ID)).SetValue(training, 1);
campaign.ScheduleTraining(training);
var campaignRepo = Mock.Of <ICampaignRepository>(mock => mock.GetById(1) == Task.FromResult(campaign), MockBehavior.Strict);
var trainingRepo = Mock.Of <ITrainingRepository>(MockBehavior.Strict);
var readStoreManager = new ReadStoreManager(repo, campaignRepo, trainingRepo);
// Act
var @event = new RecruitmentFormSubmitted(
now.ToInstant(), "Andrzej", "Strzelba",
EmailAddress.Parse("*****@*****.**"), PhoneNumber.Parse("505551888"),
"no elo",
campaignID: 1, region: "Wolne Miasto Gdańsk", preferredLecturingCities: new[] { "Rumia", "Reda", "Wejherowo" }, preferredTrainingIds: new[] { 1 },
gdprConsentGiven: true);
var domainEvent = new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, RecruitmentFormSubmitted>(@event, new Metadata(), DateTimeOffset.Now, EnrollmentAggregate.EnrollmentId.New, 1);
await readStoreManager.UpdateReadStoresAsync(new[] { domainEvent }, CancellationToken.None);
// Assert
var enrollment = Assert.Single(repo.Query());
Assert.Equal("Andrzej Strzelba", enrollment.FullName);
Assert.Equal(EmailAddress.Parse("*****@*****.**"), enrollment.Email);
Assert.Equal(PhoneNumber.Parse("505551888"), enrollment.PhoneNumber);
Assert.Equal("no elo", enrollment.AboutMe);
Assert.Equal("Wolne Miasto Gdańsk", enrollment.Region);
Assert.Equal(1, enrollment.Campaign.Id);
Assert.Null(enrollment.ResumeDate);
Assert.Collection(enrollment.PreferredLecturingCities,
first => Assert.Equal("Rumia", first),
second => Assert.Equal("Reda", second),
third => Assert.Equal("Wejherowo", third));
var preferredTraining = Assert.Single(enrollment.PreferredTrainings);
Assert.Equal("Wadowice", preferredTraining.City);
}
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 FindCandidateZones()
{
// Unfortunately we can't (yet - November 1st 2012) parse an OffsetDateTime. One day...
OffsetDateTime odt = new OffsetDateTime(new LocalDateTime(2012, 10, 27, 23, 47, 57), Offset.FromHours(-7));
var targetInstant = odt.ToInstant();
var targetOffset = odt.Offset;
var zoneProvider = DateTimeZoneProviders.Tzdb;
foreach (var id in zoneProvider.Ids)
{
var zone = zoneProvider[id];
if (zone.GetUtcOffset(targetInstant) == targetOffset)
{
Console.WriteLine(id);
}
}
}
/// <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)
{
Instant instant;
if (TimeHelpers.GetInstantPatterns(culture).TryParseAny(@string.Trim(), out instant))
{
return(instant);
}
DateTimeOffset dateTimeOffset;
if (DateTimeOffset.TryParse(@string, out dateTimeOffset))
{
return(Instant.FromDateTimeOffset(dateTimeOffset));
}
throw new NotSupportedException(
// ReSharper disable once AssignNullToNotNullAttribute
string.Format(Resources.InstantConverter_ConvertFrom_CannotParse, @string));
}
if (value is DateTime)
{
DateTime dateTime = (DateTime)value;
return(Instant.FromDateTimeUtc(dateTime.ToUniversalTime()));
}
if (value is DateTimeOffset)
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
return(Instant.FromDateTimeOffset(dateTimeOffset));
}
if (value is OffsetDateTime)
{
OffsetDateTime offsetDateTime = (OffsetDateTime)value;
return(offsetDateTime.ToInstant());
}
if (value is ZonedDateTime)
{
ZonedDateTime zonedDateTime = (ZonedDateTime)value;
return(zonedDateTime.ToInstant());
}
return(base.ConvertFrom(context, culture, value));
}
public void FindCandidateZones()
{
// Unfortunately we can't (yet - November 1st 2012) parse an OffsetDateTime. One day...
OffsetDateTime odt = new OffsetDateTime(new LocalDateTime(2012, 10, 27, 23, 47, 57), Offset.FromHours(-7));
var targetInstant = odt.ToInstant();
var targetOffset = odt.Offset;
var zoneProvider = DateTimeZoneProviders.Tzdb;
foreach (var id in zoneProvider.Ids)
{
var zone = zoneProvider[id];
if (zone.GetUtcOffset(targetInstant) == targetOffset)
{
Console.WriteLine(id);
}
}
}
public IEnumerable <Event> Get(OffsetDateTime after)
{
return(events.Where(@event => after == null || @event.EventStartTime.ToInstant() > after.ToInstant()));
}
public void Write(OffsetDateTime value, NpgsqlWriteBuffer buf, NpgsqlParameter?parameter) => Write(value.ToInstant(), buf, parameter);
/// <summary>
/// Returns an OffsetDateTime that represents the same moment in time, but at a potentially different Offset.
/// </summary>
/// <param name="offsetDateTime">The OffsetDateTime value to start with.</param>
/// <param name="offset">The Offset to switch to.</param>
/// <returns>The adjusted OffsetDateTime.</returns>
public static OffsetDateTime SwitchOffset(this OffsetDateTime offsetDateTime, Offset offset)
{
return(offsetDateTime.Offset != offset
? offsetDateTime.ToInstant().InZone(DateTimeZone.ForOffset(offset)).ToOffsetDateTime()
: offsetDateTime);
}
private void Can_Use_NodaTime_OffsetDateTime_In_Dynamic_Index1(OffsetDateTime odt)
{
using (var documentStore = NewDocumentStore())
{
documentStore.ConfigureForNodaTime();
using (var session = documentStore.OpenSession())
{
session.Store(new Foo {
Id = "foos/1", OffsetDateTime = odt
});
session.Store(new Foo {
Id = "foos/2", OffsetDateTime = OffsetDateTime.FromDateTimeOffset(odt.ToDateTimeOffset().AddMinutes(1))
});
session.Store(new Foo {
Id = "foos/3", OffsetDateTime = OffsetDateTime.FromDateTimeOffset(odt.ToDateTimeOffset().AddMinutes(2))
});
session.SaveChanges();
}
using (var session = documentStore.OpenSession())
{
var q1 = session.Query <Foo>().Customize(x => x.WaitForNonStaleResults())
.Where(x => x.OffsetDateTime == odt);
var results1 = q1.ToList();
Assert.Equal(1, results1.Count);
// OffsetDateTime is not directly comparable.
// Depending on context, one will either convert to an Instant, or just compare the LocalDateTime component.
// These are both supported by custom query expression handlers
var q2 = session.Query <Foo>().Customize(x => x.WaitForNonStaleResults())
.Where(x => x.OffsetDateTime.ToInstant() > odt.ToInstant())
.OrderByDescending(x => x.OffsetDateTime.ToInstant());
var results2 = q2.ToList();
Assert.Equal(2, results2.Count);
Assert.True(results2[0].OffsetDateTime.ToInstant() > results2[1].OffsetDateTime.ToInstant());
var q3 = session.Query <Foo>().Customize(x => x.WaitForNonStaleResults())
.Where(x => x.OffsetDateTime.ToInstant() >= odt.ToInstant())
.OrderByDescending(x => x.OffsetDateTime.ToInstant());
var results3 = q3.ToList();
Assert.Equal(3, results3.Count);
Assert.True(results3[0].OffsetDateTime.ToInstant() > results3[1].OffsetDateTime.ToInstant());
Assert.True(results3[1].OffsetDateTime.ToInstant() > results3[2].OffsetDateTime.ToInstant());
var q4 = session.Query <Foo>().Customize(x => x.WaitForNonStaleResults())
.Where(x => x.OffsetDateTime.LocalDateTime > odt.LocalDateTime)
.OrderByDescending(x => x.OffsetDateTime.LocalDateTime);
var results4 = q4.ToList();
Assert.Equal(2, results4.Count);
Assert.True(results4[0].OffsetDateTime.LocalDateTime > results4[1].OffsetDateTime.LocalDateTime);
var q5 = session.Query <Foo>().Customize(x => x.WaitForNonStaleResults())
.Where(x => x.OffsetDateTime.LocalDateTime >= odt.LocalDateTime)
.OrderByDescending(x => x.OffsetDateTime.LocalDateTime);
var results5 = q5.ToList();
Assert.Equal(3, results5.Count);
Assert.True(results5[0].OffsetDateTime.LocalDateTime > results5[1].OffsetDateTime.LocalDateTime);
Assert.True(results5[1].OffsetDateTime.LocalDateTime > results5[2].OffsetDateTime.LocalDateTime);
}
}
}
/// <summary> /// Converts a <see cref="OffsetDateTime"/> to a UNIX Timestamp (seconds since 1970-01-01T00:00:00Z, ignoring leap seconds). /// </summary> /// <param name="offsetDateTime">The offset date time.</param> /// <returns>The number of seconds since midnight on January 1st, 1970 UTC.</returns> public static long ToUnixTimeSeconds(this OffsetDateTime offsetDateTime) => offsetDateTime.ToInstant().ToUnixTimeSeconds();
