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