public override object FromDbValue(Type fieldType, object value) { var ticks = (long)this.ConvertNumber(typeof(long), value); var timeSpan = TimeSpan.FromTicks(ticks); return(TimeOnly.FromTimeSpan(timeSpan)); }
/// <summary> /// Calculates the distance of time in words between two provided times /// </summary> public static string DefaultHumanize(TimeOnly input, TimeOnly comparisonBase, CultureInfo culture) { var tense = input > comparisonBase ? Tense.Future : Tense.Past; var ts = new TimeSpan(Math.Abs(comparisonBase.Ticks - input.Ticks)); return(DefaultHumanize(ts, true, 0, tense, culture)); }
[InlineData("23:59:59.9999999")] // TimeOnly.MaxValue public static void TimeOnly_Write_Success(string value, string?expectedValue = null) { TimeOnly ts = TimeOnly.Parse(value); string json = JsonSerializer.Serialize(ts); Assert.Equal($"\"{expectedValue ?? value}\"", json); }
public void ToCollection_TimeOnlyColumn(string dataSourceName, DataSourceType mode) { var dataSource = DataSource(dataSourceName, mode); try { var uniqueKey = Guid.NewGuid().ToString(); var cust1 = new CustomerWithTime() { FullName = uniqueKey, State = "XX", PreferredCallTime = TimeOnly.FromDateTime(DateTime.Now) }; var cust2 = new CustomerWithTime() { FullName = uniqueKey, State = "XX", PreferredCallTime = TimeOnly.FromDateTime(DateTime.Now) }; var cust3 = new CustomerWithTime() { FullName = uniqueKey, State = "XX", PreferredCallTime = TimeOnly.FromDateTime(DateTime.Now) }; dataSource.Insert(CustomerTableName, cust1).Execute(); dataSource.Insert(CustomerTableName, cust2).Execute(); dataSource.Insert(CustomerTableName, cust3).Execute(); var lookup = dataSource.From(CustomerTableName, new { FullName = uniqueKey }).WithSorting("CustomerKey").ToCollection <CustomerWithTime>().Execute(); //To account for rounding, allow a 1 ms delta Assert.IsTrue(cust1.PreferredCallTime.Ticks - lookup[0].PreferredCallTime.Ticks < TimeSpanDelta, $"Actual difference was {cust1.PreferredCallTime.Ticks - lookup[0].PreferredCallTime.Ticks}"); } finally { Release(dataSource); } }
public void TransformDateInJsPatch() { using var store = GetDocumentStore(); var @do = new DateOnly(2022, 2, 21); var to = new TimeOnly(21, 11, 00); var entity = new DateAndTimeOnly() { DateOnly = @do, TimeOnly = to }; { using var session = store.OpenSession(); session.Store(entity); session.SaveChanges(); } var operation = store.Operations.Send(new PatchByQueryOperation(@" declare function modifyDateInJs(date, days) { var result = new Date(date); result.setDate(result.getDate() + days); return result.toISOString().substring(0,10); } from DateAndTimeOnlies update { this.DateOnly = modifyDateInJs(this.DateOnly, 1); }")); operation.WaitForCompletion(TimeSpan.FromSeconds(5)); { using var session = store.OpenSession(); WaitForUserToContinueTheTest(store); var result = session.Query <DateAndTimeOnly>().Single(); Assert.Equal(@do.AddDays(1), result.DateOnly); } }
public static Result TryParseTimeForQuery(byte *buffer, int len, out DateTime dt, out DateTimeOffset dto, #if FEATURE_DATEONLY_TIMEONLY_SUPPORT out DateOnly @do, out TimeOnly to, #endif bool properlyParseThreeDigitsMilliseconds) { dt = default; dto = default; #if FEATURE_DATEONLY_TIMEONLY_SUPPORT @do = default; to = default; if (TryParseDateOnly(buffer, len, out @do)) { return(Result.DateOnly); } if (TryParseTimeOnly(buffer, len, out to)) { return(Result.TimeOnly); } #endif return(TryParseDateTime(buffer, len, out dt, out dto, properlyParseThreeDigitsMilliseconds)); }
public override IEnumerable <ConvertTest> ConvertToTestData() { CultureInfo polandCulture = new CultureInfo("pl-PL"); DateTimeFormatInfo formatInfo = CultureInfo.CurrentCulture.DateTimeFormat; TimeOnly timeOnly = new TimeOnly(10, 30, 50); yield return(ConvertTest.Valid(timeOnly, timeOnly.ToString(formatInfo.ShortTimePattern))); yield return(ConvertTest.Valid(timeOnly, timeOnly.ToString(polandCulture.DateTimeFormat.ShortTimePattern, polandCulture.DateTimeFormat)) .WithRemoteInvokeCulture(polandCulture)); yield return(ConvertTest.Valid(timeOnly, "10:30", CultureInfo.InvariantCulture)); yield return(ConvertTest.Valid(TimeOnly.MinValue, string.Empty)); yield return(ConvertTest.Valid( new TimeOnly(), new InstanceDescriptor(typeof(TimeOnly).GetConstructor(new Type[] { typeof(long) }), new object[] { (long)0 }) )); yield return(ConvertTest.Valid( timeOnly, new InstanceDescriptor( typeof(TimeOnly).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(int) }), new object[] { 10, 30, 50, 0, 0 } ) )); yield return(ConvertTest.CantConvertTo(new TimeOnly(), typeof(TimeOnly))); yield return(ConvertTest.CantConvertTo(new TimeOnly(), typeof(int))); }
public static void OAndRFormatsTest() { TimeOnly timeOnly = TimeOnly.FromDateTime(DateTime.Now); string formattedDate = timeOnly.ToString("o"); Assert.Equal(16, formattedDate.Length); Assert.Equal(':', formattedDate[2]); Assert.Equal(':', formattedDate[5]); Assert.Equal('.', formattedDate[8]); TimeOnly parsedTimeOnly = TimeOnly.Parse(formattedDate); Assert.Equal(timeOnly, parsedTimeOnly); parsedTimeOnly = TimeOnly.Parse(formattedDate.AsSpan()); Assert.Equal(timeOnly, parsedTimeOnly); parsedTimeOnly = TimeOnly.ParseExact(formattedDate, "O"); Assert.Equal(timeOnly, parsedTimeOnly); parsedTimeOnly = TimeOnly.ParseExact(formattedDate.AsSpan(), "O".AsSpan()); Assert.Equal(timeOnly, parsedTimeOnly); timeOnly = new TimeOnly(timeOnly.Hour, timeOnly.Minute, timeOnly.Second); formattedDate = timeOnly.ToString("r"); Assert.Equal(8, formattedDate.Length); Assert.Equal(':', formattedDate[2]); Assert.Equal(':', formattedDate[5]); parsedTimeOnly = TimeOnly.Parse(formattedDate); Assert.Equal(timeOnly, parsedTimeOnly); parsedTimeOnly = TimeOnly.Parse(formattedDate.AsSpan()); Assert.Equal(timeOnly, parsedTimeOnly); parsedTimeOnly = TimeOnly.ParseExact(formattedDate, "R"); Assert.Equal(timeOnly, parsedTimeOnly); parsedTimeOnly = TimeOnly.ParseExact(formattedDate.AsSpan(), "R".AsSpan()); Assert.Equal(timeOnly, parsedTimeOnly); }
public static void TryFormatTest() { Span <char> buffer = stackalloc char[100]; TimeOnly timeOnly = TimeOnly.FromDateTime(DateTime.Now); buffer.Fill(' '); Assert.True(timeOnly.TryFormat(buffer, out int charsWritten)); Assert.Equal(charsWritten, buffer.TrimEnd().Length); buffer.Fill(' '); Assert.True(timeOnly.TryFormat(buffer, out charsWritten, "o")); Assert.Equal(16, charsWritten); Assert.Equal(16, buffer.TrimEnd().Length); buffer.Fill(' '); Assert.True(timeOnly.TryFormat(buffer, out charsWritten, "R")); Assert.Equal(8, charsWritten); Assert.Equal(8, buffer.TrimEnd().Length); Assert.False(timeOnly.TryFormat(buffer.Slice(0, 3), out charsWritten)); Assert.False(timeOnly.TryFormat(buffer.Slice(0, 3), out charsWritten, "r")); Assert.False(timeOnly.TryFormat(buffer.Slice(0, 3), out charsWritten, "O")); Assert.Throws <FormatException>(() => { Span <char> buff = stackalloc char[100]; timeOnly.TryFormat(buff, out charsWritten, "u"); }); Assert.Throws <FormatException>(() => { Span <char> buff = stackalloc char[100]; timeOnly.TryFormat(buff, out charsWritten, "dd-yyyy"); }); Assert.Throws <FormatException>(() => $"{timeOnly:u}"); Assert.Throws <FormatException>(() => $"{timeOnly:dd-yyyy}"); }
/// <summary> /// Gets a valid IG account. /// </summary> /// <returns>An IG Account</returns> /// <exception cref="InvalidDataException">No accounts avaliable</exception> public static IGAccount GetIGAccount() { //Randomize the accounts Random rand = new Random(); var shuffledAccounts = Accounts.OrderBy(x => rand.Next()).ToList(); //Find a valid account foreach (IGAccount cred in shuffledAccounts) { TimeOnly timeNow = TimeOnly.FromDateTime(DateTime.Now); if (!cred.Blacklist) { if (cred.UsageTimes != null && cred.UsageTimes.Count > 0) { // Check valid times: foreach (IGAccount.OperatingTime time in cred.UsageTimes) { if (time.BetweenStartAndEnd(timeNow)) { return(cred); } } } else { // Warn about not setting valid times: Console.WriteLine("Warning: No time set on account " + cred.UserName + ". Using the account."); return(cred); } } } throw new InvalidDataException("No available accounts."); }
/// <summary> /// Get a <see cref="TimeOnly"/> that will happen soon. /// </summary> /// <param name="mins">Minutes no more than <paramref name="mins"/> ahead.</param> /// <param name="refTime">The time to start calculations. Default is time from <see cref="DateTime.Now"/>.</param> public TimeOnly SoonTimeOnly(int mins = 60, TimeOnly?refTime = null) { var start = refTime ?? TimeOnly.FromDateTime(SystemClock()); var maxForward = start.AddMinutes(mins); return(BetweenTimeOnly(start, maxForward)); }
public void Can_jsv_serialize_TimeOnly() { var time = new TimeOnly(13, 13, 13); var json = time.ToJsv(); Assert.That(json, Is.EqualTo("PT13H13M13S")); var fromJson = json.FromJsv <TimeOnly>(); Assert.That(fromJson, Is.EqualTo(time)); var dto = new TimeOnlyDto { Time = time }; json = dto.ToJsv(); Assert.That(json, Is.EqualTo("{Time:PT13H13M13S}")); var fromJsonDto = json.FromJsv <TimeOnlyDto>(); Assert.That(fromJsonDto, Is.EqualTo(dto)); var nullableDto = new NullableTimeOnlyDto { Time = time }; json = nullableDto.ToJsv(); Assert.That(json, Is.EqualTo("{Time:PT13H13M13S}")); var fromJsonNullableDto = json.FromJsv <NullableTimeOnlyDto>(); Assert.That(fromJsonNullableDto, Is.EqualTo(nullableDto)); }
/// <summary> /// Get a random <see cref="TimeOnly"/> within the last few Minutes. /// </summary> /// <param name="mins">Minutes <paramref name="mins"/> of the day to go back.</param> /// <param name="refTime">The Time to start calculations. Default is time from <see cref="DateTime.Now"/>.</param> public TimeOnly RecentTimeOnly(int mins = 60, TimeOnly?refTime = null) { var start = refTime ?? TimeOnly.FromDateTime(SystemClock()); var maxBehind = start.AddMinutes(-mins); return(BetweenTimeOnly(maxBehind, start)); }
/// <summary> /// Returns localized & humanized distance of time between two times; given a specific precision. /// </summary> public static string PrecisionHumanize(TimeOnly input, TimeOnly comparisonBase, double precision, CultureInfo culture) { var ts = new TimeSpan(Math.Abs(comparisonBase.Ticks - input.Ticks)); var tense = input > comparisonBase ? Tense.Future : Tense.Past; return(PrecisionHumanize(ts, tense, precision, culture)); }
/// <summary> /// Builds a <see cref="Literal"/> instance. /// </summary> /// <param name="value"></param> public Literal(object value = null) { Value = value switch { int i => i, float f => f, decimal d => d, double d => d, long l => l, bool b => b, string s => s, DateTime dateTime => dateTime, DateTimeOffset dateTimeOffset => dateTimeOffset, #if NET6_0_OR_GREATER DateOnly date => date, TimeOnly time => time, #endif null => null, _ => throw new ArgumentException(nameof(value), #if NET6_0_OR_GREATER "only bool/int/float/decimal/double/long/string/Datetime/DateTimeOffset/DateOnly are supported"), #else "only bool/int/float/decimal/double/long/string/Datetime/DateTimeOffset/DateOnly/TimeOnly are supported"), #endif }; }
private void InitHouseStateTimeOfDay() { _log.LogTrace("InitHouseStateTimeOfDay"); if (TimeOnly.FromDateTime(DateTime.Now).IsBetween(Constants.NIGHT_START, Constants.NIGHT_END) && _entities.InputSelect.TimeOfDay.IsNotOption(TimeOfDayOptions.Night)) { _log.LogTrace("Setting time of day to Night"); _entities.InputSelect.TimeOfDay.SelectOption(TimeOfDayOptions.Night); } else if (TimeOnly.FromDateTime(DateTime.Now).IsBetween(Constants.NIGHT_END, Constants.MORNING_END) && _entities.InputSelect.TimeOfDay.IsNotOption(TimeOfDayOptions.Morning)) { _log.LogTrace("Setting time of day to Morning"); _entities.InputSelect.TimeOfDay.SelectOption(TimeOfDayOptions.Morning); } else if (TimeOnly.FromDateTime(DateTime.Now).IsBetween(Constants.MORNING_END, Constants.NIGHT_START) && _entities.Sun.Sun.State == "above_horizon" && _entities.InputSelect.TimeOfDay.IsNotOption(TimeOfDayOptions.Day)) { _log.LogTrace("Setting time of day to Day"); _entities.InputSelect.TimeOfDay.SelectOption(TimeOfDayOptions.Day); } else if (_entities.InputSelect.TimeOfDay.IsNotOption(TimeOfDayOptions.Evening)) { _log.LogTrace("Setting time of day to Evening"); _entities.InputSelect.TimeOfDay.SelectOption(TimeOfDayOptions.Evening); } }
public override void ClassWithDateOnlyAndTimeOnlyValues_Roundtrip() { RunTest(new ClassWithDateOnlyAndTimeOnlyValues { DateOnly = DateOnly.Parse("2022-05-10"), NullableDateOnly = DateOnly.Parse("2022-05-10"), TimeOnly = TimeOnly.Parse("21:51:51"), NullableTimeOnly = TimeOnly.Parse("21:51:51"), }); RunTest(new ClassWithDateOnlyAndTimeOnlyValues()); void RunTest(ClassWithDateOnlyAndTimeOnlyValues expected) { string json = JsonSerializer.Serialize(expected, DefaultContext.ClassWithDateOnlyAndTimeOnlyValues); ClassWithDateOnlyAndTimeOnlyValues actual = JsonSerializer.Deserialize(json, ((ITestContext)MetadataWithPerTypeAttributeContext.Default).ClassWithDateOnlyAndTimeOnlyValues); Assert.Equal(expected.DateOnly, actual.DateOnly); Assert.Equal(expected.NullableDateOnly, actual.NullableDateOnly); Assert.Equal(expected.TimeOnly, actual.TimeOnly); Assert.Equal(expected.NullableTimeOnly, actual.NullableTimeOnly); } }
public void FromTimeOnly() { var timeOnly = new TimeOnly(12, 34, 56, 300).Add(TimeSpan.FromTicks(4567)); var expected = new LocalTime(12, 34, 56, 300).PlusTicks(4567); var actual = LocalTime.FromTimeOnly(timeOnly); Assert.AreEqual(expected, actual); }
public void ToTimeOnly_RoundsDown() { var localTime = new LocalTime(12, 34, 56, 300).PlusTicks(4567).PlusNanoseconds(89); var expected = new TimeOnly(12, 34, 56, 300).Add(TimeSpan.FromTicks(4567)); var actual = localTime.ToTimeOnly(); Assert.AreEqual(expected, actual); }
public void ToTimeOnly_OnTickBoundary() { var localTime = new LocalTime(12, 34, 56, 300).PlusTicks(4567); var expected = new TimeOnly(12, 34, 56, 300).Add(TimeSpan.FromTicks(4567)); var actual = localTime.ToTimeOnly(); Assert.AreEqual(expected, actual); }
public void Values_can_be_correctly_converted_to_nullable_timeonly_without_the_parser_specifying_a_custom_converter() { var option = new Option <TimeOnly?>("-x"); var value = option.Parse("-x 12:34:56").GetValueForOption(option); value.Should().Be(TimeOnly.Parse("12:34:56")); }
public UrlModel Handle(TimeOnly route, TimeOnly?nullable, TimeOnly single = default) { return(new UrlModel { Route = route, Single = single, Nullable = nullable }); }
public static EventCallback <ChangeEventArgs> CreateBinder( this EventCallbackFactory factory, object receiver, Action <TimeOnly> setter, TimeOnly existingValue, CultureInfo?culture = null) { return(CreateBinderCore <TimeOnly>(factory, receiver, setter, culture, ConvertToTimeOnly)); }
public override TimeOnly?ReadJson(JsonReader reader, Type objectType, TimeOnly?existingValue, bool hasExistingValue, JsonSerializer serializer) { if (reader.Value is null) { return(null); } return(TimeOnly.ParseExact(reader.Value as string ?? string.Empty, TimeFormat, CultureInfo.InvariantCulture)); }
/// <summary> /// Get a random <see cref="TimeOnly"/> between <paramref name="start"/> and <paramref name="end"/>. /// </summary> /// <param name="start">Start time</param> /// <param name="end">End time</param> public TimeOnly BetweenTimeOnly(TimeOnly start, TimeOnly end) { var diff = end - start; var diffTicks = diff.Ticks; var part = RandomTimeSpanFromTicks(diffTicks); return(start.Add(part)); }
/// <summary> /// Creates a new instance of this converter. /// </summary> public NullableTimeOnlyConverter() : base( t => t == null ? null : DateTime.MinValue.Add(t.Value.ToTimeSpan()), d => d == null ? null : TimeOnly.FromDateTime(d.Value)) { }
public static void GetHashCodeTest() { TimeOnly timeOnly1 = TimeOnly.FromDateTime(DateTime.Now); TimeOnly timeOnly2 = timeOnly1.Add(new TimeSpan(1)); TimeOnly timeOnly3 = new TimeOnly(timeOnly1.Ticks); Assert.True(timeOnly1.GetHashCode() == timeOnly3.GetHashCode()); Assert.False(timeOnly1.GetHashCode() == timeOnly2.GetHashCode()); }
public void can_get_a_timeonly_that_will_happen_soon() { var now = TimeOnly.Parse("1:00 PM", CultureInfo.InvariantCulture); var maxTime = now.AddMinutes(5); var timeSoon = date.SoonTimeOnly(5, now); timeSoon.IsBetween(now, maxTime).Should().BeTrue(); }
public void can_get_a_timeonly_that_happened_recently() { var now = TimeOnly.Parse("2:00 PM", CultureInfo.InvariantCulture); var maxBehind = now.AddMinutes(-5); var timeRecent = date.RecentTimeOnly(5, now); timeRecent.IsBetween(maxBehind, now).Should().BeTrue(); }
public void When_both_values_are_at_their_maximum_then_it_should_succeed() { // Arrange TimeOnly timeOnly = TimeOnly.MaxValue; TimeOnly sameTimeOnly = TimeOnly.MaxValue; // Act/Assert timeOnly.Should().Be(sameTimeOnly); }