/// <summary>
/// Returns an object of the specified type and whose value is equivalent to the specified object.
/// </summary>
/// <typeparam name="TValue">The type of object to return.</typeparam>
/// <param name="value">An object that implements the <see cref="IConvertible"/> interface.</param>
/// <param name="result">New instance of object whose value is equivalent to the specified object.</param>
/// <param name="cultureInfo">Culture info to use for conversion.</param>
/// <returns>True if conversion was successful.</returns>
public static bool TryChangeType <TValue>(object value, out TValue result, CultureInfo cultureInfo = null)
{
try
{
Type conversionType = Nullable.GetUnderlyingType(typeof(TValue)) ?? typeof(TValue);
if (conversionType.IsEnum && EnumTryParse(value?.ToString(), conversionType, out TValue theEnum))
{
result = theEnum;
}
else if (conversionType == typeof(Guid))
{
result = (TValue)Convert.ChangeType(Guid.Parse(value.ToString()), conversionType);
}
else if (conversionType == typeof(DateOnly))
{
result = (TValue)Convert.ChangeType(DateOnly.Parse(value.ToString()), conversionType);
}
else if (conversionType == typeof(DateTimeOffset))
{
result = (TValue)Convert.ChangeType(DateTimeOffset.Parse(value.ToString()), conversionType);
}
else
{
result = (TValue)Convert.ChangeType(value, conversionType, cultureInfo ?? CultureInfo.InvariantCulture);
}
return(true);
}
catch
{
result = default;
return(false);
}
}
[InlineData("9999-12-31")] // DateOnly.MaxValue
public static void DateOnly_Write_Success(string value)
{
DateOnly ts = DateOnly.Parse(value);
string json = JsonSerializer.Serialize(ts);
Assert.Equal($"\"{value}\"", json);
}
public static void OAndRFormatsTest()
{
DateOnly dateOnly = DateOnly.FromDateTime(DateTime.Today);
string formattedDate = dateOnly.ToString("o");
Assert.Equal(10, formattedDate.Length);
Assert.Equal('-', formattedDate[4]);
Assert.Equal('-', formattedDate[7]);
DateOnly parsedDateOnly = DateOnly.Parse(formattedDate);
Assert.Equal(dateOnly, parsedDateOnly);
parsedDateOnly = DateOnly.Parse(formattedDate.AsSpan());
Assert.Equal(dateOnly, parsedDateOnly);
parsedDateOnly = DateOnly.ParseExact(formattedDate, "O");
Assert.Equal(dateOnly, parsedDateOnly);
parsedDateOnly = DateOnly.ParseExact(formattedDate.AsSpan(), "O".AsSpan());
Assert.Equal(dateOnly, parsedDateOnly);
formattedDate = dateOnly.ToString("r");
Assert.Equal(16, formattedDate.Length);
Assert.Equal(',', formattedDate[3]);
Assert.Equal(' ', formattedDate[4]);
Assert.Equal(' ', formattedDate[7]);
Assert.Equal(' ', formattedDate[11]);
parsedDateOnly = DateOnly.Parse(formattedDate);
Assert.Equal(dateOnly, parsedDateOnly);
parsedDateOnly = DateOnly.Parse(formattedDate.AsSpan());
Assert.Equal(dateOnly, parsedDateOnly);
parsedDateOnly = DateOnly.ParseExact(formattedDate, "R");
Assert.Equal(dateOnly, parsedDateOnly);
parsedDateOnly = DateOnly.ParseExact(formattedDate.AsSpan(), "R".AsSpan());
Assert.Equal(dateOnly, parsedDateOnly);
}
public static object?Parse(string value, Type type)
{
if (type == typeof(string))
{
return((object)value);
}
if (value == null || value == "" || value == " ")
{
return((object?)null);
}
Type utype = type.UnNullify();
if (utype.IsEnum)
{
return(Enum.Parse(utype, (string)value));
}
if (utype == typeof(Guid))
{
return(Guid.Parse(value));
}
if (utype == typeof(DateOnly))
{
return(DateOnly.Parse(value));
}
if (CustomParsers.TryGetValue(utype, out var func))
{
return(func(value)); //Delay reference
}
return(Convert.ChangeType(value, utype));
}
public static T Parse <T>(string value)
{
if (typeof(T) == typeof(string))
{
return((T)(object)value);
}
if (value == null || value == "")
{
return((T)(object?)null !);
}
Type utype = typeof(T).UnNullify();
if (utype.IsEnum)
{
return((T)Enum.Parse(utype, (string)value));
}
if (utype == typeof(Guid))
{
return((T)(object)Guid.Parse(value));
}
if (utype == typeof(DateOnly))
{
return((T)(object)DateOnly.Parse(value));
}
return((T)Convert.ChangeType(value, utype) !);
}
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 Values_can_be_correctly_converted_to_nullable_dateonly_without_the_parser_specifying_a_custom_converter()
{
var option = new Option <DateOnly?>("-x");
var value = option.Parse("-x 2022-03-02").GetValueForOption(option);
value.Should().Be(DateOnly.Parse("2022-03-02"));
}
public void Parse2([DataSources(DateOnlySkipProviders)] string context)
{
using (var db = GetDataContext(context))
using (db.CreateLocalTable(Transaction.AllData))
AreEqual(
from d in from t in Transaction.AllData select DateOnly.Parse(Sql.ConvertTo <string> .From(t.TransactionDate)) where d.Day > 0 select d,
from d in from t in db.GetTable <Transaction>() select DateOnly.Parse(Sql.ConvertTo <string> .From(t.TransactionDate)) where d.Day > 0 select d);
}
[InlineData("9999-12-31")] // DateOnly.MaxValue
public static void DateOnly_WriteDictionaryKey_Success(string value)
{
var dict = new Dictionary <DateOnly, int> {
[DateOnly.Parse(value)] = 0
};
string json = JsonSerializer.Serialize(dict);
Assert.Equal($@"{{""{value}"":0}}", json);
}
public void can_get_dateonly_in_future()
{
var now = DateOnly.Parse("1/1/1990", CultureInfo.InvariantCulture);
var maxDate = now.AddYears(1);
var someFutureDate = date.FutureDateOnly(refDate: now);
someFutureDate.Should().BeInRange(now, maxDate);
}
public override DateOnly?ReadJson(JsonReader reader, Type objectType, DateOnly?existingValue, bool hasExistingValue, JsonSerializer serializer)
{
if (reader.Value is null)
{
return(null);
}
return(DateOnly.Parse(reader.Value as string ?? string.Empty, CultureInfo.InvariantCulture));
}
public void can_get_dateonly_in_past()
{
var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture);
var maxBehind = now.AddYears(-1);
var somePastDate = date.PastDateOnly(refDate: now);
somePastDate.Should().BeInRange(maxBehind, now);
}
public void can_get_dateonly_recently_within_the_year()
{
var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture);
var maxBehind = now.AddDays(-1);
var someRecentDate = date.RecentDateOnly(refDate: now);
someRecentDate.Should().BeInRange(maxBehind, now);
}
public void can_get_dateonly_in_future_with_options()
{
var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture);
var maxDate = now.AddYears(5);
var someFutureDate = date.FutureDateOnly(5, now);
someFutureDate.Should().BeInRange(now, maxDate);
}
public void get_a_dateonly_that_will_happen_soon()
{
var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture);
var maxDate = now.AddDays(3);
var someDateSoon = date.SoonDateOnly(3, now);
someDateSoon.Should().BeInRange(now, maxDate);
}
public void can_get_dateonly_in_past_with_custom_options()
{
var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture);
var maxBehind = now.AddYears(-5);
var somePastDate = date.PastDateOnly(5, now);
somePastDate.Should().BeInRange(maxBehind, now);
}
/// <summary>
/// 判断两个日期是否是在同一月
/// </summary>
/// <param name="date1"></param>
/// <param name="date2"></param>
/// <returns></returns>
public static bool IsMonthSame(String date1, String date2)
{
DateOnly dt1 = DateOnly.Parse(date1);
DateOnly dt2 = DateOnly.Parse(date2);
int temp1 = dt1.Month;
int temp2 = dt2.Month;
bool result = temp1 == temp2;
return(result);
}
/// <summary>
/// 判断两个日期是否是在同一周
/// </summary>
/// <param name="date1"></param>
/// <param name="date2"></param>
/// <returns></returns>
public static bool IsWeekSame(String date1, String date2)
{
DateOnly dt1 = DateOnly.Parse(date1);
DateOnly dt2 = DateOnly.Parse(date2);
DateOnly temp1 = dt1.AddDays(-(int)dt1.DayOfWeek);
DateOnly temp2 = dt2.AddDays(-(int)dt2.DayOfWeek);
bool result = temp1 == temp2;
return(result);
}
public void Parse1([DataSources(DateOnlySkipProviders)] string context)
{
using var db = GetDataContext(context);
using var table = db.CreateLocalTable(Transaction.AllData);
var query = from t in db.GetTable <Transaction>()
let d = DateOnly.Parse("2010-01-" + Sql.ZeroPad(t.TransactionId, 2))
where d.Day > 0
select d;
AssertQuery(query);
}
public virtual DateOnly GetDateOnly(int ordinal)
{
var sqliteType = GetSqliteType(ordinal);
switch (sqliteType)
{
case SQLITE_FLOAT:
case SQLITE_INTEGER:
return(DateOnly.FromDateTime(FromJulianDate(GetDouble(ordinal))));
default:
return(DateOnly.Parse(GetString(ordinal), CultureInfo.InvariantCulture));
}
}
public void can_get_random_dateonly_between_two_dates()
{
var start = DateOnly.Parse("8/8/2020", CultureInfo.InvariantCulture);
var end = DateOnly.Parse("12/12/2021", CultureInfo.InvariantCulture);
var someDate = date.BetweenDateOnly(start, end);
someDate.Should().BeInRange(start, end);
//and reverse...
var otherDate = date.BetweenDateOnly(end, start);
otherDate.Should().BeInRange(start, end);
}
/// <summary>
/// Converts the string to an object.
/// </summary>
/// <param name="text">The string to convert to an object.</param>
/// <param name="row">The <see cref="IReaderRow"/> for the current record.</param>
/// <param name="memberMapData">The <see cref="MemberMapData"/> for the member being created.</param>
/// <returns>The object created from the string.</returns>
public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
{
if (text == null)
{
return(base.ConvertFromString(null, row, memberMapData));
}
var formatProvider = (IFormatProvider)memberMapData.TypeConverterOptions.CultureInfo.GetFormat(typeof(DateTimeFormatInfo)) ?? memberMapData.TypeConverterOptions.CultureInfo;
var dateTimeStyle = memberMapData.TypeConverterOptions.DateTimeStyle ?? DateTimeStyles.None;
return(memberMapData.TypeConverterOptions.Formats == null || memberMapData.TypeConverterOptions.Formats.Length == 0
? DateOnly.Parse(text, formatProvider, dateTimeStyle)
: DateOnly.ParseExact(text, memberMapData.TypeConverterOptions.Formats, formatProvider, dateTimeStyle));
}
public static void InvalidFormatsTest()
{
DateTime dt = DateTime.Now;
string formatted = dt.ToString();
Assert.Throws <FormatException>(() => DateOnly.Parse(formatted));
Assert.Throws <FormatException>(() => DateOnly.Parse(formatted.AsSpan()));
Assert.False(DateOnly.TryParse(formatted, out DateOnly dateOnly));
Assert.False(DateOnly.TryParse(formatted.AsSpan(), out dateOnly));
formatted = dt.ToString("t");
Assert.Throws <FormatException>(() => DateOnly.Parse(formatted));
Assert.Throws <FormatException>(() => DateOnly.Parse(formatted.AsSpan()));
Assert.False(DateOnly.TryParse(formatted, out dateOnly));
Assert.False(DateOnly.TryParse(formatted.AsSpan(), out dateOnly));
}
public async Task GetDatesFromRange_OnNewYear_ShouldReturn3Records()
{
var context = CreateContext();
var(_, records) = await AddTestData(context);
var datesService = GetDatesService(5, context);
var list = await datesService.GetDatesFromRange(new DateOnly(2020, 01, 01), false);
list.Should().HaveCount(2);
list.Should().SatisfyRespectively(
first => first.Date.Should().Be(DateOnly.Parse("2019-12-31")),
second => second.Date.Should().Be(DateOnly.Parse("2018-01-01")));
}
public async Task DateOnlyValueTest()
{
var expected = "2000-10-12";
DateOnly?value = null;
using var ctx = new TestContext();
var cut = ctx.RenderComponent <BSInput <DateOnly?> >(parameters =>
parameters.Add(p => p.Value, value)
.Add(p => p.ValueChanged, e =>
{
value = e;
})
);
cut.Find("input").Change(expected);
Assert.Equal(DateOnly.Parse(expected), value);
}
public async Task DateOnlyValueTest()
{
var expected = DateOnly.Parse("2000-10-20");
var value = DateOnly.Parse("2020-10-20");
using var ctx = new TestContext();
var cut = ctx.RenderComponent <BSInputCheckbox <DateOnly> >(parameters =>
parameters.Add(p => p.Value, value)
.Add(p => p.CheckedValue, DateOnly.Parse("2000-10-20"))
.Add(p => p.UnCheckedValue, DateOnly.Parse("2020-10-20"))
.Add(p => p.ValueChanged, e =>
{
value = e;
})
);
cut.Find("input").Click();
Assert.Equal(expected, value);
cut.Find("input").Click();
Assert.Equal(DateOnly.Parse("2020-10-20"), value);
}
public async Task GetDatesFromRange_ShouldReturn1Records_Then2Records()
{
var context = CreateContext();
await AddTestData(context);
var datesService = GetDatesService(5, context);
var list = await datesService.GetDatesFromRange(new DateOnly(2020, 04, 28), false);
list.Should().HaveCount(1);
list[0].Date.Should().Be(DateOnly.Parse("2012-04-23"));
//============================//
list = await datesService.GetDatesFromRange(new DateOnly(2020, 06, 19), false);
list.Should().HaveCount(2);
var expected = new string[] { "2019-06-23", "2015-06-23" }.Select(t => DateOnly.Parse(t)).ToList();
list.Select(i => i.Date).Should().OnlyContain(d => expected.Contains(d));
}
private static async Task Run(Options option)
{
Program.pseGetOption = option;
var fromDate = DateOnly.FromDateTime(DateTime.Today);
var toDate = DateOnly.FromDateTime(DateTime.Today);
if (!option.DateRange.Equals("today", StringComparison.OrdinalIgnoreCase))
{
var dateRange = option.DateRange.Split(':');
if (dateRange.Length == 0)
{
throw new Exception($"{option.DateRange} is not a valid date range.");
}
fromDate = DateOnly.Parse(dateRange[0].Trim());
toDate = DateOnly.Parse(dateRange[1].Trim());
if (toDate < fromDate)
{
throw new Exception("Invalid date range.");
}
}
var downloadDate = fromDate;
while (downloadDate <= toDate)
{
var pdfBytes = await DownloadReport(downloadDate);
if (pdfBytes != null)
{
Log.Information($"Converting to CSV...");
await ConvertPdfBytesToCsv(pdfBytes, downloadDate);
Log.Information("Done.");
}
downloadDate = downloadDate.AddDays(1);
}
Log.Information("Download complete.");
}
public static void BasicFormatParseTest()
{
DateOnly dateOnly = DateOnly.FromDateTime(DateTime.Today);
string s = dateOnly.ToString();
DateOnly parsedDateOnly = DateOnly.Parse(s);
Assert.True(DateOnly.TryParse(s, out DateOnly parsedDateOnly1));
Assert.Equal(dateOnly, parsedDateOnly);
Assert.Equal(dateOnly, parsedDateOnly1);
parsedDateOnly = DateOnly.Parse(s.AsSpan());
Assert.True(DateOnly.TryParse(s.AsSpan(), out parsedDateOnly1));
Assert.Equal(dateOnly, parsedDateOnly);
Assert.Equal(dateOnly, parsedDateOnly1);
s = dateOnly.ToString(CultureInfo.InvariantCulture);
parsedDateOnly = DateOnly.Parse(s, CultureInfo.InvariantCulture);
Assert.True(DateOnly.TryParse(s.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedDateOnly1));
Assert.Equal(dateOnly, parsedDateOnly);
Assert.Equal(dateOnly, parsedDateOnly1);
parsedDateOnly = DateOnly.Parse(s.AsSpan(), CultureInfo.InvariantCulture);
Assert.True(DateOnly.TryParse(s.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedDateOnly1));
Assert.Equal(dateOnly, parsedDateOnly);
Assert.Equal(dateOnly, parsedDateOnly1);
Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out parsedDateOnly1));
Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal));
Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsedDateOnly1));
Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal));
Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out parsedDateOnly1));
Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal));
Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault, out parsedDateOnly1));
Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault));
s = " " + s + " ";
parsedDateOnly = DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces);
Assert.Equal(dateOnly, parsedDateOnly);
parsedDateOnly = DateOnly.Parse(s.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces);
Assert.Equal(dateOnly, parsedDateOnly);
}
/// <summary>
/// Converts the given value object to a <see cref='System.DateOnly'/> object.
/// </summary>
/// <inheritdoc />
public override object?ConvertFrom(ITypeDescriptorContext?context, CultureInfo?culture, object value)
{
if (value is string text)
{
text = text.Trim();
if (text.Length == 0)
{
return(DateOnly.MinValue);
}
try
{
// See if we have a culture info to parse with. If so, then use it.
DateTimeFormatInfo?formatInfo = null;
if (culture != null)
{
formatInfo = (DateTimeFormatInfo?)culture.GetFormat(typeof(DateTimeFormatInfo));
}
if (formatInfo != null)
{
return(DateOnly.Parse(text, formatInfo));
}
else
{
return(DateOnly.Parse(text, culture));
}
}
catch (FormatException e)
{
throw new FormatException(SR.Format(SR.ConvertInvalidPrimitive, (string)value, nameof(DateOnly)), e);
}
}
return(base.ConvertFrom(context, culture, value));
}
