public void ArgumentInRangeDateOnlyTest()
{
var lowerValue = new DateOnly(2021, 3, 3);
var upperValue = new DateOnly(2025, 3, 3);
var testValue = new DateOnly(2022, 3, 20);
var outOfRangeLowerValue = new DateOnly(1900, 3, 3);
var outOfRangeUpperValue = new DateOnly(1991, 3, 3);
try
{
var result = testValue.ArgumentInRange(lowerValue, upperValue);
}
catch
{
Assert.Fail();
}
// Test Exception
_ = Assert.ThrowsException <ArgumentOutOfRangeException>(() => testValue.ArgumentInRange(outOfRangeLowerValue, outOfRangeUpperValue));
}
public async Task GetAllDates_ShouldReplacePlaceholdereByHostAndPort_InRecordText()
{
var context = CreateContext();
await AddTestData(context);
var datesService = GetDatesService(10, context);
var hostAndPortService = new HostAndPortStub();
var list = await datesService.GetAllDates(DateOnly.FromDateTime(DateTime.UtcNow));
var r1 = list[2];
r1?.Text.Should().NotContain(hostAndPortService.GetHostAndPortPlaceholder());
r1?.Text.Should().Contain(hostAndPortService.GetHostAndPort());
var r2 = list[5];
r2?.Text.Should().NotContain(hostAndPortService.GetHostAndPortPlaceholder());
r2?.Text.Should().Contain(hostAndPortService.GetHostAndPort());
}
public static void AddDaysTest()
{
DateOnly dateOnly = DateOnly.MinValue.AddDays(1);
Assert.Equal(1, dateOnly.DayNumber);
dateOnly = dateOnly.AddDays(1);
Assert.Equal(2, dateOnly.DayNumber);
dateOnly = dateOnly.AddDays(100);
Assert.Equal(102, dateOnly.DayNumber);
dateOnly = DateOnly.MaxValue.AddDays(-1);
Assert.Equal(DateOnly.MaxValue.DayNumber - 1, dateOnly.DayNumber);
dateOnly = dateOnly.AddDays(-1);
Assert.Equal(DateOnly.MaxValue.DayNumber - 2, dateOnly.DayNumber);
dateOnly = dateOnly.AddDays(-100);
Assert.Equal(DateOnly.MaxValue.DayNumber - 102, dateOnly.DayNumber);
Assert.Throws <ArgumentOutOfRangeException>(() => DateOnly.MinValue.AddDays(-1));
Assert.Throws <ArgumentOutOfRangeException>(() => DateOnly.MaxValue.AddDays(1));
}
public static void ConvertFrom_DateOnlyInstanceDescriptor()
{
using (new ThreadCultureChange("fr-FR"))
{
DateOnly testDateOnly = DateOnly.FromDateTime(DateTime.UtcNow);
ConstructorInfo ctor = typeof(DateOnly).GetConstructor(new Type[]
{
typeof(int), typeof(int), typeof(int)
});
InstanceDescriptor descriptor = new InstanceDescriptor(ctor, new object[]
{
testDateOnly.Year, testDateOnly.Month, testDateOnly.Day
});
const string format = "dd MMM yyyy";
object o = s_converter.ConvertFrom(descriptor);
Assert.Equal(testDateOnly.ToString(format), ((DateOnly)o).ToString(format));
}
}
public void ConvertFromStringTest()
{
var converter = new DateOnlyConverter();
var propertyMapData = new MemberMapData(null);
propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
var row = new CsvReader(new ParserMock());
var date = DateOnly.FromDateTime(DateTime.Now);
// Valid conversions.
Assert.Equal(date.ToString(), converter.ConvertFromString(date.ToString(), null, propertyMapData).ToString());
Assert.Equal(date.ToString(), converter.ConvertFromString(date.ToString("o"), null, propertyMapData).ToString());
Assert.Equal(date.ToString(), converter.ConvertFromString(" " + date + " ", null, propertyMapData).ToString());
// Invalid conversions.
Assert.Throws <TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
}
public void CanArriveAtQueryStringPageWithDateTimeQuery()
{
var dateTime = new DateTime(2000, 1, 2, 3, 4, 5, 6);
var dateOnly = new DateOnly(2000, 1, 2);
var timeOnly = new TimeOnly(3, 4, 5, 6);
SetUrlViaPushState($"/WithQueryParameters/Abc?NullableDateTimeValue=2000-01-02%2003:04:05&NullableDateOnlyValue=2000-01-02&NullableTimeOnlyValue=03:04:05");
var app = Browser.MountTestComponent <TestRouter>();
Assert.Equal("Hello Abc .", app.FindElement(By.Id("test-info")).Text);
Assert.Equal("0", app.FindElement(By.Id("value-QueryInt")).Text);
Assert.Equal(dateTime.ToString("hh:mm:ss on yyyy-MM-dd", CultureInfo.InvariantCulture), app.FindElement(By.Id("value-NullableDateTimeValue")).Text);
Assert.Equal(dateOnly.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture), app.FindElement(By.Id("value-NullableDateOnlyValue")).Text);
Assert.Equal(timeOnly.ToString("hh:mm:ss", CultureInfo.InvariantCulture), app.FindElement(By.Id("value-NullableTimeOnlyValue")).Text);
Assert.Equal(string.Empty, app.FindElement(By.Id("value-StringValue")).Text);
Assert.Equal("0 values ()", app.FindElement(By.Id("value-LongValues")).Text);
AssertHighlightedLinks("With query parameters (none)", "With query parameters (passing Date Time values)");
}
public async Task <List <DateListItem> > GetDatesFromRange(DateOnly today, bool withEmptyDates)
{
var daysCount = (await _appSettingsService.GetAppSettingInt(AppSettingsKey.ImportantDaysDisplayRange)) ?? throw new Exception("Setting 'ImportantDaysDisplayRange' does not exists");
var allRecords = await GetAllDates(today);
var startDate = today.AddDays(-daysCount);
var datesRange = Enumerable.Range(0, daysCount * 2)
.Select(i => startDate.AddDays(i))
.Select(d => new DateListItem(Guid.Empty, d, d, "", "", ""))
.ToList();
var datesFromRange = new List <DateListItem>();
var emptyDates = new HashSet <DateListItem>();
foreach (var rec in allRecords)
{
var emptyDate = datesRange.SingleOrDefault(d => d.TransferredDate.Month == rec.TransferredDate.Month && d.TransferredDate.Day == rec.TransferredDate.Day);
if (emptyDate == null)
{
continue;
}
datesFromRange.Add(rec with {
TransferredDate = emptyDate.TransferredDate
});
if (!emptyDates.Contains(emptyDate))
{
emptyDates.Add(emptyDate);
}
}
if (!withEmptyDates)
{
return(datesFromRange.OrderBy(d => d.TransferredDate).ToList());
}
datesRange = datesRange.Except(emptyDates).ToList();
datesRange.AddRange(datesFromRange);
return(datesRange.OrderBy(d => d.TransferredDate).ToList());
}
public async Task RevokeRoleAsync()
{
var birthdayRoleId = (DiscordRoleId)_dynamicConfiguration.DiscordMapping[BirthdayRoleIdKey];
var birthdayUsers = await _birthdayProvider.GetBirthdaysAsync(DateOnly.FromDateTime(DateTime.UtcNow));
foreach (var userId in birthdayUsers)
{
if (!_discordAccess.CanManageRolesForUser(userId))
{
continue;
}
var(success, _) = await _discordAccess.TryRevokeNonMemberRole(userId, birthdayRoleId);
if (!success)
{
await _discordAccess.LogToDiscord($"{_discordAccess.GetLeadershipMention()}: "
+ $"Failed to revoke role {birthdayRoleId.ToMention()} from {userId.ToMention()}.");
}
}
}
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 static Arbitrary <DateExpression> DateExpressions()
{
Gen <DateExpression> dateTimeGenerator = GetArbitraryFor <DateTime>()
.Generator
.Select(dateTime => new DateExpression(year: dateTime.Year, month: dateTime.Month, day: dateTime.Day));
#if NET6_0_OR_GREATER
Gen <DateExpression> dateOnlyGenerator = GetArbitraryFor <DateTime>()
.Generator
.Select(dateTime => DateOnly.FromDateTime(dateTime))
.Select(date => new DateExpression(year: date.Year, month: date.Month, day: date.Day));
#endif
#if !NET6_0_OR_GREATER
return(dateTimeGenerator
.ToArbitrary());
#else
return(Gen.OneOf(dateTimeGenerator, dateOnlyGenerator)
.ToArbitrary());
#endif
}
public async Task SoftDeleting_GetAllDates_ShouldNotReturnRecordsWithRemovedThemes()
{
var context = CreateContext();
context.SoftDeleting = true;
var(scopes, records) = await AddTestData(context);
var themeId = scopes[0].Themes.ElementAt(1).Id;
var recordId = records[0].Id;
var tr = await context.RecordThemes.SingleOrDefaultAsync(tr => tr.RecordId == recordId && tr.ThemeId == themeId);
tr.Deleted = true;
await context.SaveChangesAsync();
var datesService = GetDatesService(10, context);
var list = await datesService.GetAllDates(DateOnly.FromDateTime(DateTime.UtcNow));
list.Should().HaveCount(7);
list.Should().NotContain(item => item.Id == records[0].Id);
}
public async Task GetRecordsCount_ByDateAndName_ShouldReturn2()
{
string searchName = "SearchТекстІї*01";
const int matchesInRange = 2;
var dateFrom = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(-14));
var dateTo = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(-9));
var context = CreateContext();
Create_20Records(context, GetNamesList(), GetDatesList(20));
var searchService = GetRecordsSearchService(context);
var filters = new RecordsFilter
{
FilterName = searchName,
FromDate = dateFrom,
ToDate = dateTo
};
int count = await searchService.GetRecordsCount(filters);
count.Should().Be(matchesInRange);
}
public static void OperatorsTest()
{
Assert.True(DateOnly.MinValue != DateOnly.MaxValue);
Assert.True(DateOnly.MinValue < DateOnly.MaxValue);
Assert.True(DateOnly.MinValue <= DateOnly.MaxValue);
Assert.True(DateOnly.MaxValue > DateOnly.MinValue);
Assert.True(DateOnly.MaxValue >= DateOnly.MinValue);
DateOnly dateOnly1 = new DateOnly(2021, 10, 10);
DateOnly dateOnly2 = new DateOnly(2021, 10, 11);
DateOnly dateOnly3 = new DateOnly(2021, 10, 10);
Assert.True(dateOnly1 == dateOnly3);
Assert.True(dateOnly1 >= dateOnly3);
Assert.True(dateOnly1 <= dateOnly3);
Assert.True(dateOnly1 != dateOnly2);
Assert.True(dateOnly1 < dateOnly2);
Assert.True(dateOnly1 <= dateOnly2);
Assert.True(dateOnly2 > dateOnly1);
Assert.True(dateOnly2 >= dateOnly1);
}
public IActionResult Put(int key, [FromBody] Delta <DateOnyTimeOnlyModel> dt)
{
Assert.Equal(new[] { "Birthday", "CreatedTime" }, dt.GetChangedPropertyNames());
// Birthday
object value;
bool success = dt.TryGetPropertyValue("Birthday", out value);
Assert.True(success);
DateOnly dateOnly = Assert.IsType <DateOnly>(value);
Assert.Equal(new DateOnly(2199, 1, 2), dateOnly);
// CreatedTime
success = dt.TryGetPropertyValue("CreatedTime", out value);
Assert.True(success);
TimeOnly timeOnly = Assert.IsType <TimeOnly>(value);
Assert.Equal(new TimeOnly(14, 13, 15, 179), timeOnly);
return(Updated(dt));
}
public void ToObject_DateOnlyColumn(string dataSourceName, DataSourceType mode)
{
var dataSource = DataSource(dataSourceName, mode);
try
{
var cust = new CustomerWithDate()
{
FullName = Guid.NewGuid().ToString(), State = "XX", BirthDay = DateOnly.FromDateTime(DateTime.Now)
};
var key = dataSource.Insert(CustomerTableName, cust).ToInt32().Execute();
var lookup = dataSource.GetByKey(CustomerTableName, key).ToObject <CustomerWithDate>().Execute();
Assert.AreEqual(cust.BirthDay, lookup.BirthDay);
}
finally
{
Release(dataSource);
}
}
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));
}
TsDateData <TKey, TAssetId, TValue1, TValue2> m_data; // this m_data pointer can be swapped in an atomic instruction after update
static void HowToUseThisClassExamples()
{
DateOnly[] dates = new DateOnly[2] {
new DateOnly(2020, 05, 05), new DateOnly(2020, 05, 06)
};
var dict1 = new Dictionary <TickType, float[]>()
{
{ TickType.SplitDivAdjClose, new float[2] {
10.1f, 12.1f
} }
};
var dict2 = new Dictionary <TickType, uint[]>();
uint assetId = 1;
var data = new Dictionary <uint, Tuple <Dictionary <TickType, float[]>, Dictionary <TickType, uint[]> > >()
{
{ assetId, new Tuple <Dictionary <TickType, float[]>, Dictionary <TickType, uint[]> >(dict1, dict2) }
};
var ts1 = new CompactFinTimeSeries <DateOnly, uint, float, uint>();
ts1.ChangeData(dates, data);
}
bool GetField <T>(string fieldName, out T value, T defaultValue)
{
var obj = GetField(fieldName);
if (obj != null)
{
try {
//if (typeof(T) == typeof(Currency)) {
// value = Currency.ToCurrency(obj);
//}
////FIXME
//if (obj.GetType() == typeof(DateTime))
// obj = ((DateTime)obj).ToLocalTime();
if (typeof(T) == typeof(DateOnly))
{
obj = DateOnly.ToDateOnly(obj);
}
if (obj is T _value)
{
value = _value;
}
else
{
obj = Convert.ChangeType(obj, typeof(T));
value = (T)obj;
}
return(true);
}
catch (Exception exc) {
//Debug.ExceptionCaught(exc);
Debug.Print("Exception caught in AirRecord.GetField(): fieldName={0}, obj={1}: {2}", fieldName, obj, exc);
}
}
value = defaultValue;
return(false);
}
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);
}
internal static object ConvertPrimitiveValue(object value, IEdmPrimitiveTypeReference primitiveType, TimeZoneInfo timeZoneInfo)
{
if (value == null)
{
return(null);
}
Type type = value.GetType();
if (primitiveType != null && primitiveType.IsDate() && TypeHelper.IsDateTime(type))
{
Date dt = (DateTime)value;
return(dt);
}
if (primitiveType != null && primitiveType.IsTimeOfDay() && TypeHelper.IsTimeSpan(type))
{
TimeOfDay tod = (TimeSpan)value;
return(tod);
}
#if NET6_0
// Since ODL doesn't support "DateOnly", we have to use Date defined in ODL.
if (primitiveType != null && primitiveType.IsDate() && TypeHelper.IsDateOnly(type))
{
DateOnly dateOnly = (DateOnly)value;
return(new Date(dateOnly.Year, dateOnly.Month, dateOnly.Day));
}
// Since ODL doesn't support "TimeOnly", we have to use TimeOfDay defined in ODL.
if (primitiveType != null && primitiveType.IsTimeOfDay() && TypeHelper.IsTimeOnly(type))
{
TimeOnly timeOnly = (TimeOnly)value;
return(new TimeOfDay(timeOnly.Hour, timeOnly.Minute, timeOnly.Second, timeOnly.Millisecond));
}
#endif
return(ConvertUnsupportedPrimitives(value, timeZoneInfo));
}
public static void AddYearsTest()
{
DateOnly dateOnly = new DateOnly(2021, 1, 31);
for (int i = 2021; i < 2040; i++)
{
Assert.Equal(i, dateOnly.Year);
dateOnly = dateOnly.AddYears(1);
}
for (int i = dateOnly.Year; i > 2020; i--)
{
Assert.Equal(i, dateOnly.Year);
dateOnly = dateOnly.AddYears(-1);
}
DateTime dt = DateTime.Today;
dateOnly = DateOnly.FromDayNumber((int)(dt.Ticks / TimeSpan.TicksPerDay));
Assert.Equal(dt.Year, dateOnly.Year);
Assert.Equal(dt.Month, dateOnly.Month);
Assert.Equal(dt.Day, dateOnly.Day);
dt = dt.AddYears(1);
dateOnly = dateOnly.AddYears(1);
Assert.Equal(dt.Year, dateOnly.Year);
dt = dt.AddYears(50);
dateOnly = dateOnly.AddYears(50);
Assert.Equal(dt.Year, dateOnly.Year);
dt = dt.AddYears(-150);
dateOnly = dateOnly.AddYears(-150);
Assert.Equal(dt.Year, dateOnly.Year);
Assert.Throws <ArgumentOutOfRangeException>(() => DateOnly.MinValue.AddYears(-1));
Assert.Throws <ArgumentOutOfRangeException>(() => DateOnly.MaxValue.AddYears(1));
}
public static void DateTimeConversionTest()
{
DateTime dt = DateTime.Today;
DateOnly dateOnly = DateOnly.FromDateTime(dt);
Assert.Equal(dt.Year, dateOnly.Year);
Assert.Equal(dt.Month, dateOnly.Month);
Assert.Equal(dt.Day, dateOnly.Day);
dt = dateOnly.ToDateTime(new TimeOnly(1, 10, 20));
Assert.Equal(dateOnly.Year, dt.Year);
Assert.Equal(dateOnly.Month, dt.Month);
Assert.Equal(dateOnly.Day, dt.Day);
Assert.Equal(1, dt.Hour);
Assert.Equal(10, dt.Minute);
Assert.Equal(20, dt.Second);
Assert.Equal(DateTimeKind.Unspecified, dt.Kind);
dt = dateOnly.ToDateTime(new TimeOnly(23, 59, 59), DateTimeKind.Utc);
Assert.Equal(dateOnly.Year, dt.Year);
Assert.Equal(dateOnly.Month, dt.Month);
Assert.Equal(dateOnly.Day, dt.Day);
Assert.Equal(23, dt.Hour);
Assert.Equal(59, dt.Minute);
Assert.Equal(59, dt.Second);
Assert.Equal(DateTimeKind.Utc, dt.Kind);
dt = dateOnly.ToDateTime(new TimeOnly(23, 59, 59), DateTimeKind.Local);
Assert.Equal(DateTimeKind.Local, dt.Kind);
dateOnly = DateOnly.FromDateTime(dt);
Assert.Equal(dt.Year, dateOnly.Year);
Assert.Equal(dt.Month, dateOnly.Month);
Assert.Equal(dt.Day, dateOnly.Day);
}
public async Task ApplyRoleAsync()
{
var birthdayRoleId = (DiscordRoleId)_dynamicConfiguration.DiscordMapping[BirthdayRoleIdKey];
var birthdayUsers = await _birthdayProvider.GetBirthdaysAsync(DateOnly.FromDateTime(DateTime.UtcNow));
var userIdsWithAppliedRole = new List <DiscordUserId>(birthdayUsers.Length);
foreach (var userId in birthdayUsers)
{
if (!_discordAccess.CanManageRolesForUser(userId))
{
continue;
}
var(success, _) = await _discordAccess.TryAddNonMemberRole(userId, birthdayRoleId);
if (success)
{
userIdsWithAppliedRole.Add(userId);
}
else
{
await _discordAccess.LogToDiscord($"{_discordAccess.GetLeadershipMention()}: "
+ $"Failed to apply role {birthdayRoleId.ToMention()} to {userId.ToMention()}.");
}
}
if (userIdsWithAppliedRole.Count == 0)
{
return;
}
var birthdayAnnouncementChannelId = (DiscordChannelId)_dynamicConfiguration.DiscordMapping[BirthdayAnnouncementChannelIdKey];
var messages = userIdsWithAppliedRole.Select(m => "HoU wishes a Happy Birthday to our latest Birthday Yata, "
+ $"{m.ToMention()}. Have an amazing day filled with fun!!!")
.ToArray();
await _discordAccess.CreateBotMessagesInChannelAsync(birthdayAnnouncementChannelId, messages);
}
public void Should_respect_deviating_weekend_definition()
{
var saturday = new DateOnly(2022, 4, 23);
var sunday = saturday.AddDays(1);
var monday = sunday.AddDays(1);
var tuesday = monday.AddDays(1);
var wednesday = tuesday.AddDays(1);
var thursday = wednesday.AddDays(1);
var friday = thursday.AddDays(1);
//weekend is WED + FRI
var nwd = new NonWorkingDays {
Weekend = new List <DayOfWeek> {
DayOfWeek.Wednesday, DayOfWeek.Friday
}
};
var customWeekendIsWedAndFri = !saturday.isWeekend(nwd) &&
!sunday.isWeekend(nwd) &&
!monday.isWeekend(nwd) &&
!tuesday.isWeekend(nwd) &&
wednesday.isWeekend(nwd) &&
!thursday.isWeekend(nwd) &&
friday.isWeekend(nwd);
//there is no weekend
var nwd2 = new NonWorkingDays {
Weekend = new List <DayOfWeek>()
};
var thereIsNoWeekend = !saturday.isWeekend(nwd2) &&
!sunday.isWeekend(nwd2) &&
!monday.isWeekend(nwd2) &&
!tuesday.isWeekend(nwd2) &&
!wednesday.isWeekend(nwd2) &&
!thursday.isWeekend(nwd2) &&
!friday.isWeekend(nwd2);
Assert.True(customWeekendIsWedAndFri && thereIsNoWeekend);
}
private static object ConvertObjectToDateTime(object source, Type targetType)
{
object dateTime = null;
if (targetType == typeof(DateTime) || targetType == typeof(DateTime?))
{
if (DateTime.TryParse(source?.ToString(), out DateTime result))
{
dateTime = result;
}
else if (targetType == typeof(DateTime?))
{
dateTime = null;
}
}
else if (targetType == typeof(DateTimeOffset) || targetType == typeof(DateTimeOffset?))
{
if (DateTimeOffset.TryParse(source?.ToString(), out DateTimeOffset result))
{
dateTime = result;
}
else if (targetType == typeof(DateTimeOffset?))
{
dateTime = null;
}
}
#if NET6_0_OR_GREATER
else if (targetType == typeof(DateOnly) || targetType == typeof(DateOnly))
{
if (DateOnly.TryParse(source?.ToString(), out DateOnly result))
{
dateTime = result;
}
}
#endif
return(dateTime);
}
public void DateOnly_Iss338_Test_Should_Succeed()
{
var serializer = new DefaultJsonSerializer("json", new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
Converters = new List <JsonConverter>()
{
new DateOnlyJsonConverter()
}
});
var dateTime = DateTime.Parse("2021-12-21 12:12:12");
var date = DateOnly.FromDateTime(dateTime);
DateOnlyModel m = new DateOnlyModel {
Name = "Joe User", Date = date
};
var @byte = serializer.Serialize(m);
var @obj = serializer.Deserialize <DateOnlyModel>(@byte);
Assert.Equal(date, obj.Date);
}
public async Task GetRecordsList_ByDateAndName_ShouldReturn2Records()
{
string searchName = "SearchТекстІї*01";
var dateFrom = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(-14));
var dateTo = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(-9));
var context = CreateContext();
Create_20Records(context, GetNamesList(), GetDatesList(20));
var svc = GetRecordsSearchService(context);
var filters = new RecordsFilter
{
FilterName = searchName,
FromDate = dateFrom,
ToDate = dateTo
};
var resList = await svc.GetRecordsList(filters);
resList.Should().OnlyContain(rec =>
rec.Name.IndexOf(searchName, StringComparison.InvariantCultureIgnoreCase) != -1 &&
rec.Date >= dateFrom &&
rec.Date <= dateTo);
}
public override void FormatValue(StringBuilder queryStringBuilder, object?value)
{
if (value == null || value is DBNull)
{
throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"The ClickHouse type \"{ComplexTypeName}\" does not allow null values");
}
DateOnly dateOnlyValue = value switch
{
DateOnly theValue => theValue,
DateTime theValue => DateOnly.FromDateTime(theValue),
_ => throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"The type \"{value.GetType()}\" can't be converted to the ClickHouse type \"{ComplexTypeName}\"."),
};
var days = dateOnlyValue == default ? 0 : dateOnlyValue.DayNumber - UnixEpoch.DayNumber;
if (days < 0 || days > ushort.MaxValue)
{
throw new OverflowException("The value must be in range [1970-01-01, 2149-06-06].");
}
queryStringBuilder.Append(days.ToString(CultureInfo.InvariantCulture));
}
/// <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));
}
