├── .github
    ├── FUNDING.yml
    ├── dependabot.yml
    ├── workflows
    │   └── build.yml
    ├── copilot-instructions.md
    └── instructions
    │   ├── testing.instructions.md
    │   └── general.instructions.md
├── .vscode
    ├── settings.json
    └── tasks.json
├── tests
    └── Exceptionless.DateTimeExtensions.Tests
    │   ├── Properties
    │       └── AssemblyInfo.cs
    │   ├── RandomHelper.cs
    │   ├── Exceptionless.DateTimeExtensions.Tests.csproj
    │   ├── FormatParsers
    │       ├── PartParsers
    │       │   ├── YearPartParserTests.cs
    │       │   ├── MonthPartParserTests.cs
    │       │   ├── NamedDayPartParserTests.cs
    │       │   ├── PartParserTestsBase.cs
    │       │   ├── MonthDayPartParserTests.cs
    │       │   ├── AmountTimeRelationPartParserTests.cs
    │       │   ├── MonthRelationPartParserTests.cs
    │       │   ├── ExplicitDatePartParserTests.cs
    │       │   ├── SingleTimeRelationPartParserTests.cs
    │       │   ├── WildcardPartParserTests.cs
    │       │   └── DateMathPartParserTests.cs
    │       ├── YearFormatParserTests.cs
    │       ├── NamedDayFormatParserTests.cs
    │       ├── MonthFormatParserTests.cs
    │       ├── MonthDayFormatParserTests.cs
    │       ├── FormatParserTestsBase.cs
    │       ├── RelationAmountTimeFormatParserTests.cs
    │       ├── MonthRelationFormatParserTests.cs
    │       ├── SingleTimeRelationFormatParserTests.cs
    │       ├── ExplicitDateFormatParserTests.cs
    │       └── TwoPartFormatParserTests.cs
    │   ├── DateTimeExtensionsTests.cs
    │   ├── TimeSpanExtensionTests.cs
    │   ├── TimeUnitTests.cs
    │   ├── BusinessDayTests.cs
    │   └── DateTimeRangeTests.cs
├── src
    └── Exceptionless.DateTimeExtensions
    │   ├── Exceptionless.DateTimeExtensions.csproj
    │   ├── FormatParsers
    │       └── FormatParsers
    │       │   ├── IFormatParser.cs
    │       │   ├── PriorityAttribute.cs
    │       │   ├── PartParsers
    │       │       ├── IPartParser.cs
    │       │       ├── YearPartParser.cs
    │       │       ├── WildcardPartParser.cs
    │       │       ├── MonthPartParser.cs
    │       │       ├── SingleTimeRelationPartParser.cs
    │       │       ├── MonthDayPartParser.cs
    │       │       ├── NamedDayPartParser.cs
    │       │       ├── DateMathPartParser.cs
    │       │       ├── ExplicitDatePartParser.cs
    │       │       ├── MonthRelationPartParser.cs
    │       │       └── AmountTimeRelationPartParser.cs
    │       │   ├── YearFormatParser.cs
    │       │   ├── SingleTimeRelationFormatParser.cs
    │       │   ├── MonthFormatParser.cs
    │       │   ├── MonthDayFormatParser.cs
    │       │   ├── NamedDayFormatParser.cs
    │       │   ├── ExplicitDateFormatParser.cs
    │       │   ├── Helper.cs
    │       │   ├── MonthRelationFormatParser.cs
    │       │   ├── RelationAmountTimeFormatParser.cs
    │       │   └── TwoPartFormatParser.cs
    │   ├── Properties
    │       └── AssemblyInfo.cs
    │   ├── TypeHelper.cs
    │   ├── BusinessDay.cs
    │   ├── TimeUnit.cs
    │   ├── DateTimeRange.cs
    │   ├── TimeSpanExtensions.cs
    │   ├── BusinessWeek.cs
    │   └── DateTimeExtensions.cs
├── Exceptionless.DateTimeExtensions.slnx
├── .gitattributes
├── .gitignore
├── .editorconfig
├── README.md
└── LICENSE.txt


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: exceptionless
2 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |     "cSpell.words": [
3 |         "millis",
4 |         "timespan"
5 |     ]
6 | }


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 | - package-ecosystem: nuget
4 |   directory: "/"
5 |   schedule:
6 |     interval: weekly
7 |   open-pull-requests-limit: 10


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | [assembly: Xunit.CollectionBehavior(DisableTestParallelization = true, MaxParallelThreads = 1)]
2 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/Exceptionless.DateTimeExtensions.csproj:
--------------------------------------------------------------------------------
1 | <Project Sdk="Microsoft.NET.Sdk">
2 |   <Import Project="..\..\build\common.props" />
3 | </Project>
4 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/IFormatParser.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | 
3 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
4 | 
5 | public interface IFormatParser
6 | {
7 |     DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime);
8 | }
9 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: Build
 2 | on: [push, pull_request]
 3 | 
 4 | jobs:
 5 |   build:
 6 |     uses: FoundatioFx/Foundatio/.github/workflows/build-workflow.yml@main
 7 |     with:
 8 |         org: exceptionless
 9 |     secrets:
10 |       NUGET_KEY: ${{ secrets.NUGET_KEY }}
11 |       FEEDZ_KEY: ${{ secrets.FEEDZ_KEY }}
12 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PriorityAttribute.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 4 | 
 5 | public class PriorityAttribute : Attribute
 6 | {
 7 |     public PriorityAttribute(int priority)
 8 |     {
 9 |         Priority = priority;
10 |     }
11 | 
12 |     public int Priority { get; private set; }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/IPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | public interface IPartParser
 7 | {
 8 |     Regex Regex { get; }
 9 |     DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit);
10 | }
11 | 


--------------------------------------------------------------------------------
/Exceptionless.DateTimeExtensions.slnx:
--------------------------------------------------------------------------------
 1 | <Solution>
 2 |   <Folder Name="/Solution Items/">
 3 |     <File Path=".github/workflows/build.yml" />
 4 |     <File Path="build/common.props" />
 5 |     <File Path="README.md" />
 6 |   </Folder>
 7 |   <Project Path="src/Exceptionless.DateTimeExtensions/Exceptionless.DateTimeExtensions.csproj" />
 8 |   <Project Path="tests/Exceptionless.DateTimeExtensions.Tests/Exceptionless.DateTimeExtensions.Tests.csproj" />
 9 | </Solution>
10 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Runtime.CompilerServices;
2 | 
3 | [assembly: InternalsVisibleTo("Exceptionless.DateTimeExtensions.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a9357232b9bcad78fd310297fdb41bf42816ee2ca9ccdace999889de2badb6f06df2de1d9f2c8cb17b21f5311f11d6bb328d55e0dd9fe8adc5e2dc4610028c1bdacb3355d2e239b81d0bb0ac83e615fc641f8a3ec49e4fad8e305994953d448ef7b38e8c256601e54af19c035b562e3e5e5461c2a93b8dd11936e451b05034a2")]
4 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/YearPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(70)]
 7 | public class YearPartParser : IPartParser
 8 | {
 9 |     private static readonly Regex _parser = new(@"\G(?<year>\d{4})", RegexOptions.Compiled);
10 |     public Regex Regex => _parser;
11 | 
12 |     public DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
13 |     {
14 |         int year = Int32.Parse(match.Groups["year"].Value);
15 |         return isUpperLimit ? relativeBaseTime.ChangeYear(year).EndOfYear() : relativeBaseTime.ChangeYear(year).StartOfYear();
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/WildcardPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(1)]
 7 | public class WildcardPartParser : IPartParser
 8 | {
 9 |     private static readonly Regex _wildcardRegex = new(@"\G\s*\*(?=\s|\]|\}|$)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 | 
11 |     public Regex Regex => _wildcardRegex;
12 | 
13 |     public DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
14 |     {
15 |         if (!match.Success)
16 |             return null;
17 | 
18 |         return isUpperLimit ? DateTimeOffset.MaxValue : DateTimeOffset.MinValue;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/RandomHelper.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Exceptionless.DateTimeExtensions.Tests;
 4 | 
 5 | public static class RandomHelper
 6 | {
 7 |     static readonly Random _rnd = new();
 8 | 
 9 |     public static DateTime GetRandomDate(DateTime from, DateTime to)
10 |     {
11 |         var range = to - from;
12 | 
13 |         var randTimeSpan = new TimeSpan((long)(_rnd.NextDouble() * range.Ticks));
14 | 
15 |         return from + randTimeSpan;
16 |     }
17 | 
18 |     public static DateTimeOffset GetRandomDate(DateTimeOffset from, DateTimeOffset to)
19 |     {
20 |         var range = to - from;
21 | 
22 |         var randTimeSpan = new TimeSpan((long)(_rnd.NextDouble() * range.Ticks));
23 | 
24 |         return from + randTimeSpan;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/YearFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 5 | 
 6 | [Priority(80)]
 7 | public class YearFormatParser : IFormatParser
 8 | {
 9 |     private static readonly Regex _parser = new(@"^\s*(?<year>\d{4})\s*$", RegexOptions.Compiled);
10 | 
11 |     public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
12 |     {
13 |         var m = _parser.Match(content);
14 |         if (!m.Success)
15 |             return null;
16 | 
17 |         int year = Int32.Parse(m.Groups["year"].Value);
18 |         return new DateTimeRange(relativeBaseTime.ChangeYear(year).StartOfYear(), relativeBaseTime.ChangeYear(year).EndOfYear());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/SingleTimeRelationFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 5 | 
 6 | [Priority(70)]
 7 | public class SingleTimeRelationFormatParser : RelationAmountTimeFormatParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"^\s*(?<relation>{0})\s+(?<time>{1})\s*$", Helper.RelationNames, Helper.SingularTimeNames), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 | 
11 |     public override DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
12 |     {
13 |         var m = _parser.Match(content);
14 |         if (!m.Success)
15 |             return null;
16 | 
17 |         return FromRelationAmountTime(m.Groups["relation"].Value, 1, m.Groups["time"].Value, relativeBaseTime);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | * text=auto
 2 | 
 3 | *.doc diff=astextplain
 4 | *.DOC diff=astextplain
 5 | *.docx diff=astextplain
 6 | *.DOCX diff=astextplain
 7 | *.dot diff=astextplain
 8 | *.DOT diff=astextplain
 9 | *.pdf diff=astextplain
10 | *.PDF diff=astextplain
11 | *.rtf diff=astextplain
12 | *.RTF diff=astextplain
13 | 
14 | *.bmp binary
15 | *.gif binary
16 | *.jpg binary
17 | *.png binary
18 | 
19 | *.ascx text
20 | *.cmd text
21 | *.coffee text
22 | *.config text
23 | *.cs text diff=csharp
24 | *.csproj text merge=union
25 | *.css text
26 | *.cshtml text
27 | *.htm text
28 | *.html text
29 | *.htm text
30 | *.js text
31 | *.msbuild text
32 | *.resx text merge=union
33 | *.ruleset text
34 | *.Stylecop text
35 | *.targets text
36 | *.tt text
37 | *.txt text
38 | *.vb text
39 | *.vbhtml text
40 | *.vbproj text merge=union
41 | *.xml text
42 | *.xunit text
43 | 
44 | *.slnx text eol=crlf merge=union
45 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/MonthPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(40)]
 7 | public class MonthPartParser : MonthRelationPartParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"\G(?<month>{0})", Helper.GetMonthNames()), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 |     public override Regex Regex => _parser;
11 | 
12 |     public override DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
13 |     {
14 |         int month = Helper.GetMonthNumber(match.Groups["month"].Value);
15 |         string relation = relativeBaseTime.Month > month ? "last" : "this";
16 |         return FromMonthRelation(relation, month, relativeBaseTime, isUpperLimit);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/MonthFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 5 | 
 6 | [Priority(60)]
 7 | public class MonthFormatParser : MonthRelationFormatParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"^\s*(?<month>{0})\s*$", Helper.GetMonthNames()), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 | 
11 |     public override DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
12 |     {
13 |         var m = _parser.Match(content);
14 |         if (!m.Success)
15 |             return null;
16 | 
17 |         int month = Helper.GetMonthNumber(m.Groups["month"].Value);
18 |         string relation = relativeBaseTime.Month > month ? "last" : "this";
19 |         return FromMonthRelation(relation, month, relativeBaseTime);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/SingleTimeRelationPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(80)]
 7 | public class SingleTimeRelationPartParser : AmountTimeRelationPartParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"\G(?:a|an)\s+(?<time>{0})\s+(?<relation>ago|from now)", Helper.SingularTimeNames), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 |     public override Regex Regex => _parser;
11 | 
12 |     public override DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
13 |     {
14 |         return FromRelationAmountTime(
15 |                 match.Groups["relation"].Value,
16 |                 1,
17 |                 match.Groups["time"].Value,
18 |                 relativeBaseTime,
19 |                 isUpperLimit);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/MonthDayPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(60)]
 7 | public class MonthDayPartParser : IPartParser
 8 | {
 9 |     private static readonly Regex _parser = new(@"\G(?<month>\d{2})-(?<day>\d{2})", RegexOptions.Compiled);
10 |     public Regex Regex => _parser;
11 | 
12 |     public DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
13 |     {
14 |         int month = Int32.Parse(match.Groups["month"].Value);
15 |         int day = Int32.Parse(match.Groups["day"].Value);
16 | 
17 |         try
18 |         {
19 |             return isUpperLimit ? relativeBaseTime.ChangeMonth(month).ChangeDay(day).EndOfDay() : relativeBaseTime.ChangeMonth(month).ChangeDay(day).StartOfDay();
20 |         }
21 |         catch
22 |         {
23 |             return null;
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/MonthDayFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 5 | 
 6 | [Priority(50)]
 7 | public class MonthDayFormatParser : IFormatParser
 8 | {
 9 |     private static readonly Regex _parser = new(@"^\s*(?<month>\d{2})-(?<day>\d{2})\s*$", RegexOptions.Compiled);
10 | 
11 |     public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
12 |     {
13 |         var m = _parser.Match(content);
14 |         if (!m.Success)
15 |             return null;
16 | 
17 |         int month = Int32.Parse(m.Groups["month"].Value);
18 |         int day = Int32.Parse(m.Groups["day"].Value);
19 |         try
20 |         {
21 |             return new DateTimeRange(relativeBaseTime.ChangeMonth(month).ChangeDay(day).StartOfDay(), relativeBaseTime.ChangeMonth(month).ChangeDay(day).EndOfDay());
22 |         }
23 |         catch
24 |         {
25 |             return null;
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/Exceptionless.DateTimeExtensions.Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <Import Project="..\..\build\common.props" />
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net8.0</TargetFramework>
 5 |     <IsPackable>False</IsPackable>
 6 |   </PropertyGroup>
 7 |   <ItemGroup>
 8 |     <ProjectReference Include="..\..\src\Exceptionless.DateTimeExtensions\Exceptionless.DateTimeExtensions.csproj" />
 9 |   </ItemGroup>
10 |   <ItemGroup>
11 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
12 |     <PackageReference Include="xunit" Version="2.9.3" />
13 |     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
14 |       <PrivateAssets>all</PrivateAssets>
15 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
16 |     </PackageReference>
17 |     <PackageReference Include="Foundatio.Xunit" Version="12.0.0" />
18 |     <PackageReference Include="GitHubActionsTestLogger" Version="3.0.1" PrivateAssets="All" />
19 |   </ItemGroup>
20 | </Project>
21 | 


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "2.0.0",
 3 |   "tasks": [
 4 |     {
 5 |       "label": "build",
 6 |       "command": "dotnet",
 7 |       "type": "process",
 8 |       "group": {
 9 |         "kind": "build",
10 |         "isDefault": true
11 |       },
12 |       "args": [
13 |         "build",
14 |         "${workspaceFolder}",
15 |         "/p:GenerateFullPaths=true",
16 |         "/consoleloggerparameters:NoSummary"
17 |       ],
18 |       "problemMatcher": "$msCompile"
19 |     },
20 |     {
21 |       "label": "test",
22 |       "command": "dotnet",
23 |       "type": "process",
24 |       "group": {
25 |         "kind": "test",
26 |         "isDefault": true
27 |       },
28 |       "args": [
29 |         "test",
30 |         "${workspaceFolder}",
31 |         "/p:GenerateFullPaths=true",
32 |         "/consoleloggerparameters:NoSummary"
33 |       ],
34 |       "problemMatcher": "$msCompile"
35 |     },
36 |     {
37 |       "label": "pack", 
38 |       "command": "dotnet pack -c Release -o ${workspaceFolder}/artifacts",
39 |       "type": "shell",
40 |       "problemMatcher": []
41 |     }
42 |   ]
43 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # User-specific files
 2 | *.suo
 3 | *.user
 4 | 
 5 | # Build results
 6 | [Bb]in/
 7 | [Oo]bj/
 8 | artifacts
 9 | .vs/
10 | 
11 | # MSTest test Results
12 | [Tt]est[Rr]esult*/
13 | 
14 | # ReSharper is a .NET coding add-in
15 | _ReSharper*/
16 | *.[Rr]e[Ss]harper
17 | *.DotSettings.user
18 | 
19 | # JustCode is a .NET coding addin-in
20 | .JustCode
21 | 
22 | # DotCover is a Code Coverage Tool
23 | *.dotCover
24 | 
25 | # NCrunch
26 | _NCrunch_*
27 | .*crunch*.local.xml
28 | 
29 | # NuGet Packages
30 | *.nupkg
31 | 
32 | .DS_Store
33 | 
34 | # Rider
35 | 
36 | # User specific
37 | **/.idea/**/workspace.xml
38 | **/.idea/**/tasks.xml
39 | **/.idea/shelf/*
40 | **/.idea/dictionaries
41 | 
42 | # Sensitive or high-churn files
43 | **/.idea/**/dataSources/
44 | **/.idea/**/dataSources.ids
45 | **/.idea/**/dataSources.xml
46 | **/.idea/**/dataSources.local.xml
47 | **/.idea/**/sqlDataSources.xml
48 | **/.idea/**/dynamic.xml
49 | 
50 | # Rider
51 | # Rider auto-generates .iml files, and contentModel.xml
52 | **/.idea/**/*.iml
53 | **/.idea/**/contentModel.xml
54 | **/.idea/**/modules.xml
55 | .idea/.idea.Exceptionless.DateTimeExtensions/.idea/
56 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/YearPartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class YearPartParserTests : PartParserTestsBase
10 | {
11 |     public YearPartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new YearPartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs =>
21 |     [
22 |         ["2013",      false, _now.ChangeYear(2013).StartOfYear()],
23 |         ["2013",      true,  _now.ChangeYear(2013).EndOfYear()],
24 |         ["2012",      false, _now.ChangeYear(2012).StartOfYear()],
25 |         ["2012",      true,  _now.ChangeYear(2012).EndOfYear()],
26 |         ["blah",      false, null],
27 |         ["blah blah", true,  null]
28 |     ];
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/YearFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class YearFormatParserTests : FormatParserTestsBase
10 | {
11 |     public YearFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new YearFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["2013",      _now.ChangeYear(2013).StartOfYear(), _now.ChangeYear(2013).EndOfYear()],
27 |                 ["2012",      _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2012).EndOfYear()],
28 |                 ["blah",      null, null],
29 |                 ["blah blah", null, null]
30 |             ];
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/NamedDayFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 5 | 
 6 | [Priority(20)]
 7 | public class NamedDayFormatParser : IFormatParser
 8 | {
 9 |     private static readonly Regex _parser = new(@"^\s*(?<name>today|yesterday|tomorrow)\s*$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 | 
11 |     public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
12 |     {
13 |         var m = _parser.Match(content);
14 |         if (!m.Success)
15 |             return null;
16 | 
17 |         string value = m.Groups["name"].Value.ToLower();
18 |         if (value == "today")
19 |             return new DateTimeRange(relativeBaseTime.StartOfDay(), relativeBaseTime.EndOfDay());
20 |         if (value == "yesterday")
21 |             return new DateTimeRange(relativeBaseTime.SubtractDays(1).StartOfDay(), relativeBaseTime.SubtractDays(1).EndOfDay());
22 |         if (value == "tomorrow")
23 |             return new DateTimeRange(relativeBaseTime.AddDays(1).StartOfDay(), relativeBaseTime.AddDays(1).EndOfDay());
24 | 
25 |         return null;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/NamedDayPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(10)]
 7 | public class NamedDayPartParser : IPartParser
 8 | {
 9 |     private static readonly Regex _parser = new(@"\G(?<name>now|today|yesterday|tomorrow)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 | 
11 |     public Regex Regex => _parser;
12 | 
13 |     public DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
14 |     {
15 |         string value = match.Groups["name"].Value.ToLower();
16 |         if (value == "now")
17 |             return relativeBaseTime;
18 |         if (value == "today")
19 |             return isUpperLimit ? relativeBaseTime.EndOfDay() : relativeBaseTime.StartOfDay();
20 |         if (value == "yesterday")
21 |             return isUpperLimit ? relativeBaseTime.SubtractDays(1).EndOfDay() : relativeBaseTime.SubtractDays(1).StartOfDay();
22 |         if (value == "tomorrow")
23 |             return isUpperLimit ? relativeBaseTime.AddDays(1).EndOfDay() : relativeBaseTime.AddDays(1).StartOfDay();
24 | 
25 |         return null;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/NamedDayFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class NamedDayFormatParserTests : FormatParserTestsBase
10 | {
11 |     public NamedDayFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new NamedDayFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["yesterday", _now.SubtractDays(1).StartOfDay(), _now.SubtractDays(1).EndOfDay()],
27 |                 ["today",     _now.StartOfDay(), _now.EndOfDay()],
28 |                 ["tomorrow",  _now.AddDays(1).StartOfDay(), _now.AddDays(1).EndOfDay()],
29 |                 ["blah",      null, null],
30 |                 ["blah blah", null, null]
31 |             ];
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/MonthFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class MonthFormatParserTests : FormatParserTestsBase
10 | {
11 |     public MonthFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new MonthFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["jan",       _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(1).EndOfMonth()],
27 |                 ["nov",       _now.StartOfMonth(), _now.EndOfMonth()],
28 |                 ["decemBer",  _now.ChangeMonth(12).StartOfMonth(), _now.ChangeMonth(12).EndOfMonth()],
29 |                 ["blah",      null, null],
30 |                 ["blah blah", null, null]
31 |             ];
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/DateMathPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | /// <summary>
 7 | /// Parses Elasticsearch date math expressions using the DateMath utility class.
 8 | /// This is a thin wrapper that adapts the DateMath utility for use within the format parser framework.
 9 | ///
10 | /// Supports: now, explicit dates with ||, operations (+, -, /), and time units (y, M, w, d, h, H, m, s).
11 | /// Examples: now+1h, now-1d/d, 2001.02.01||+1M/d, 2025-01-01T01:25:35Z||+3d/d
12 | ///
13 | /// For more details about date math functionality, see <see cref="DateMath"/>.
14 | /// </summary>
15 | [Priority(5)]
16 | public class DateMathPartParser : IPartParser
17 | {
18 |     public Regex Regex => DateMath.Parser;
19 | 
20 |     public DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
21 |     {
22 |         // Since we already have a successful regex match, use the efficient TryParseFromMatch method
23 |         // to avoid redundant regex matching and validation
24 |         return DateMath.TryParseFromMatch(match, relativeBaseTime, isUpperLimit, out DateTimeOffset result)
25 |             ? result
26 |             : null;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/MonthDayFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class MonthDayFormatParserTests : FormatParserTestsBase
10 | {
11 |     public MonthDayFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new MonthDayFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["02-01",     _now.Change(null, 2, 1).StartOfDay(), _now.Change(null, 2, 1).EndOfDay()],
27 |                 ["11-06",     _now.Change(null, 11, 6).StartOfDay(), _now.Change(null, 11, 6).EndOfDay()],
28 |                 ["12-24",     _now.Change(null, 12, 24).StartOfDay(), _now.Change(null, 12, 24).EndOfDay()],
29 |                 ["12-45",     null, null],
30 |                 ["blah",      null, null],
31 |                 ["blah blah", null, null]
32 |             ];
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/FormatParserTestsBase.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Exceptionless.DateTimeExtensions.FormatParsers;
 3 | using Foundatio.Xunit;
 4 | using Microsoft.Extensions.Logging;
 5 | using Xunit;
 6 | using Xunit.Abstractions;
 7 | 
 8 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 9 | 
10 | public abstract class FormatParserTestsBase : TestWithLoggingBase
11 | {
12 |     protected static readonly DateTime _now;
13 | 
14 |     protected FormatParserTestsBase(ITestOutputHelper output) : base(output) { }
15 | 
16 |     static FormatParserTestsBase()
17 |     {
18 |         _now = RandomHelper.GetRandomDate(new DateTime(2014, 11, 1), new DateTime(2014, 12, 1).SubtractMilliseconds(1));
19 |     }
20 | 
21 |     public void ValidateInput(IFormatParser parser, string input, DateTime? start, DateTime? end)
22 |     {
23 |         _logger.LogInformation("Input: {Input}, Now: {Now}, Start: {Start}, End: {End}", input, _now, start, end);
24 | 
25 |         var range = parser.Parse(input, _now);
26 |         _logger.LogInformation("Parsed range: Start: {Start}, End: {End}", range?.Start, range?.End);
27 | 
28 |         if (range == null)
29 |         {
30 |             Assert.Null(start);
31 |             Assert.Null(end);
32 |             return;
33 |         }
34 | 
35 |         Assert.Equal(start, range.Start);
36 |         Assert.Equal(end, range.End);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/RelationAmountTimeFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class RelationAmountTimeFormatParserTests : FormatParserTestsBase
10 | {
11 |     public RelationAmountTimeFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new RelationAmountTimeFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["last 5 minutes",   _now.StartOfMinute().SubtractMinutes(5), _now],
27 |                 ["last 30 days",     _now.StartOfDay().SubtractDays(30),  _now],
28 |                 ["next 5 weeks",     _now, _now.AddWeeks(5).EndOfDay()],
29 |                 ["this 3 hours",     _now, _now.AddHours(3).EndOfHour()],
30 |                 ["previous 3 years", _now.SubtractYears(3).StartOfDay(), _now],
31 |                 ["blah",             null, null],
32 |                 ["blah blah",        null,  null]
33 |             ];
34 |         }
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/MonthPartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class MonthPartParserTests : PartParserTestsBase
10 | {
11 |     public MonthPartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new MonthPartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["jan",       false, _now.ChangeMonth(1).StartOfMonth()],
27 |                 ["jan",       true,  _now.ChangeMonth(1).EndOfMonth()],
28 |                 ["nov",       false, _now.StartOfMonth()],
29 |                 ["nov",       true,  _now.EndOfMonth()],
30 |                 ["decemBer",  false, _now.ChangeMonth(12).StartOfMonth()],
31 |                 ["dec",       true,  _now.ChangeMonth(12).EndOfMonth()],
32 |                 ["blah",      false, null],
33 |                 ["blah blah", true,  null]
34 |             ];
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/.github/copilot-instructions.md:
--------------------------------------------------------------------------------
 1 | # Copilot AI Coding Agent Instructions for Foundatio.RabbitMQ
 2 | 
 3 | ## Key Principles
 4 | 
 5 | All contributions must respect existing formatting and conventions specified in the `.editorconfig` file. You are a distinguished engineer and are expected to deliver high-quality code that adheres to the guidelines in the instruction files.
 6 | 
 7 | Let's keep pushing for clarity, usability, and excellence—both in code and user experience.
 8 | 
 9 | **See also:**
10 | - [General Coding Guidelines](instructions/general.instructions.md)
11 | - [Testing Guidelines](instructions/testing.instructions.md)
12 | 
13 | ## Key Directories & Files
14 | - `src/Exceptionless.DateTimeExtensions/` — Main library code for DateTime extensions.
15 | - `tests/Exceptionless.DateTimeExtensions.Tests/` — Unit and integration tests for DateTime extension features.
16 | - `build/` — Shared build props, strong naming key, and assets.
17 | - `Exceptionless.DateTimeExtensions.slnx` — Solution file for development.
18 | 
19 | ## Developer Workflows
20 | - **Build:** Use the VS Code task `build` or run `dotnet build` at the repo root.
21 | - **Test:** Use the VS Code task `test` or run `dotnet test tests/Exceptionless.DateTimeExtensions.Tests`.
22 | 
23 | ## References & Further Reading
24 | - [README.md](../README.md) — Full documentation.
25 | 
26 | ---
27 | 
28 | **If you are unsure about a pattern or workflow, check the README or look for similar patterns in the `src/` and `tests/` folders.**
29 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/NamedDayPartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class NamedDayPartParserTests : PartParserTestsBase
10 | {
11 |     public NamedDayPartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new NamedDayPartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["now",       false, _now],
27 |                 ["now",       true,  _now],
28 |                 ["yesterday", false, _now.SubtractDays(1).StartOfDay()],
29 |                 ["yesterday", true,  _now.SubtractDays(1).EndOfDay()],
30 |                 ["today",     false, _now.StartOfDay()],
31 |                 ["today",     true,  _now.EndOfDay()],
32 |                 ["tomorrow",  false, _now.AddDays(1).StartOfDay()],
33 |                 ["tomorrow",  true,  _now.AddDays(1).EndOfDay()],
34 |                 ["blah",      false, null],
35 |                 ["blah blah", true,  null]
36 |             ];
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/ExplicitDatePartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Text.RegularExpressions;
 4 | 
 5 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 6 | 
 7 | [Priority(50)]
 8 | public class ExplicitDatePartParser : IPartParser
 9 | {
10 |     private static readonly Regex _parser = new(@"\G(?<date>\d{4}-\d{2}-\d{2}(?:T(?:\d{2}\:\d{2}\:\d{2}(?:\.\d{3})?|\d{2}\:\d{2}|\d{2})Z?)?)", RegexOptions.Compiled);
11 |     public Regex Regex => _parser;
12 | 
13 |     public DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
14 |     {
15 |         string value = match.Groups["date"].Value;
16 |         if (value.Length == 13)
17 |             value += ":00:00";
18 |         if (value.Length == 16)
19 |             value += ":00";
20 | 
21 |         // NOTE: AssumeUniversal here because this might parse a date (E.G., 03/22/2023). If no offset is specified, we assume it's UTC.
22 |         if (!DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var date))
23 |             return null;
24 | 
25 |         if (relativeBaseTime.Offset != date.Offset)
26 |             date = date.ChangeOffset(relativeBaseTime.Offset);
27 | 
28 |         if (!isUpperLimit)
29 |             return date;
30 | 
31 |         return match.Length switch
32 |         {
33 |             10 => date.EndOfDay(),
34 |             13 => date.EndOfHour(),
35 |             16 => date.EndOfMinute(),
36 |             _ => date
37 |         };
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/PartParserTestsBase.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 3 | using Foundatio.Xunit;
 4 | using Microsoft.Extensions.Logging;
 5 | using Xunit;
 6 | using Xunit.Abstractions;
 7 | 
 8 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 9 | 
10 | public abstract class PartParserTestsBase : TestWithLoggingBase
11 | {
12 |     protected static readonly DateTimeOffset _now;
13 | 
14 |     protected PartParserTestsBase(ITestOutputHelper output) : base(output) { }
15 | 
16 |     static PartParserTestsBase()
17 |     {
18 |         _now = RandomHelper.GetRandomDate(new DateTimeOffset(2014, 11, 1, 0, 0, 0, TimeSpan.FromHours(1)), new DateTimeOffset(2014, 12, 1, 0, 0, 0, TimeSpan.FromHours(1)).SubtractMilliseconds(1));
19 |     }
20 | 
21 |     public void ValidateInput(IPartParser parser, string input, bool isUpperLimit, DateTimeOffset? expected)
22 |     {
23 |         _logger.LogInformation("Input: {Input}, Now: {Now}, IsUpperLimit: {IsUpperLimit}, Expected: {Expected}", input, _now, isUpperLimit, expected);
24 |         var match = parser.Regex.Match(input);
25 |         if (!match.Success)
26 |         {
27 |             Assert.Null(expected);
28 |             return;
29 |         }
30 | 
31 |         var result = parser.Parse(match, _now, isUpperLimit);
32 |         if (expected == null)
33 |         {
34 |             Assert.Null(result);
35 |         }
36 |         else
37 |         {
38 |             Assert.Equal(expected, result.Value);
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/.github/instructions/testing.instructions.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | description: "C# testing guidelines"
 3 | applyTo: "tests/**/*.cs"
 4 | ---
 5 | 
 6 | # Testing Guidelines (C#)
 7 | 
 8 | ## Framework & Best Practices
 9 | 
10 | - Follow Microsoft's [unit testing best practices](https://learn.microsoft.com/en-us/dotnet/core/testing/unit-testing-best-practices).
11 | - Use xUnit as the primary testing framework.
12 | 
13 | ## Test Principles
14 | 
15 | - **Fast & Isolated**: Tests should execute quickly and not depend on external factors or the order of execution.
16 | - **Repeatable & Self-Checking**: Tests must be consistent and validate their own outcomes without manual checks.
17 | - **Timely**: Write tests alongside your code to ensure relevance and improve design.
18 | 
19 | ## Test Structure & Naming
20 | 
21 | - Write complete, runnable tests—no placeholders or TODOs.
22 | - Use clear, descriptive naming conventions for test methods:
23 |     - `MethodName_StateUnderTest_ExpectedBehavior`
24 | - Follow AAA pattern (Arrange, Act, Assert).
25 | 
26 | ## Test Organization
27 | 
28 | - Use `[Theory]` and `[InlineData]` for parameterized tests.
29 | - Implement proper setup and teardown using constructors and `IDisposable`.
30 | - Tests are organized to mirror the main code structure (e.g., `FormatParsers/` in both `src` and `tests`).
31 | 
32 | ## Integration Testing
33 | 
34 | - Inject `ITestOutputHelper` into the test class constructor to get access to the test output.
35 | - Isolate dependencies using test containers, in-memory providers, or stubs to ensure reliable test execution.
36 | - Verify data persistence and side effects.
37 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/MonthDayPartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class MonthDayPartParserTests : PartParserTestsBase
10 | {
11 |     public MonthDayPartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new MonthDayPartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["02-01",     false, _now.ChangeMonth(2).ChangeDay(1).StartOfDay()],
27 |                 ["02-01",     true,  _now.ChangeMonth(2).ChangeDay(1).EndOfDay()],
28 |                 ["11-06",     false, _now.ChangeMonth(11).ChangeDay(6).StartOfDay()],
29 |                 ["11-06",     true,  _now.ChangeMonth(11).ChangeDay(6).EndOfDay()],
30 |                 ["12-24",     false, _now.ChangeMonth(12).ChangeDay(24).StartOfDay()],
31 |                 ["12-24",     true,  _now.ChangeMonth(12).ChangeDay(24).EndOfDay()],
32 |                 ["12-45",     true,  null],
33 |                 ["blah",      false, null],
34 |                 ["blah blah", true,  null]
35 |             ];
36 |         }
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/ExplicitDateFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Text.RegularExpressions;
 4 | 
 5 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 6 | 
 7 | [Priority(30)]
 8 | public class ExplicitDateFormatParser : IFormatParser
 9 | {
10 |     private static readonly Regex _parser = new(@"^\s*(?<date>\d{4}-\d{2}-\d{2}(?:T(?:\d{2}\:\d{2}\:\d{2}(?:\.\d{3})?|\d{2}\:\d{2}|\d{2})Z?)?)\s*$", RegexOptions.Compiled);
11 | 
12 |     public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
13 |     {
14 |         content = content.Trim();
15 |         var m = _parser.Match(content);
16 |         if (!m.Success)
17 |             return null;
18 | 
19 |         string value = m.Groups["date"].Value;
20 |         if (value.Length == 13)
21 |             value += ":00:00";
22 |         if (value.Length == 16)
23 |             value += ":00";
24 | 
25 |         // NOTE: AssumeUniversal here because this might parse a date (E.G., 03/22/2023). If no offset is specified, we assume it's UTC.
26 |         if (!DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var date))
27 |             return null;
28 | 
29 |         if (relativeBaseTime.Offset != date.Offset)
30 |             date = date.ChangeOffset(relativeBaseTime.Offset);
31 | 
32 |         return content.Length switch
33 |         {
34 |             10 => new DateTimeRange(date, date.EndOfDay()),
35 |             13 => new DateTimeRange(date, date.EndOfHour()),
36 |             16 => new DateTimeRange(date, date.EndOfMinute()),
37 |             _ => new DateTimeRange(date, date.EndOfSecond())
38 |         };
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/AmountTimeRelationPartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class AmountTimeRelationPartParserTests : PartParserTestsBase
10 | {
11 |     public AmountTimeRelationPartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new AmountTimeRelationPartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["1 minute ago",      false, _now.SubtractMinutes(1).StartOfMinute()],
27 |                 ["1 minute ago",      true,  _now.SubtractMinutes(1).EndOfMinute()],
28 |                 ["1 minute from now", false, _now.AddMinutes(1).StartOfMinute()],
29 |                 ["1 minute from now", true,  _now.AddMinutes(1).EndOfMinute()],
30 |                 ["22 hours ago",      false, _now.SubtractHours(22).StartOfHour()],
31 |                 ["22 hours ago",      true,  _now.SubtractHours(22).EndOfHour()],
32 |                 ["12 days from now",  false, _now.AddDays(12).StartOfDay()],
33 |                 ["12 days from now",  true,  _now.AddDays(12).EndOfDay()],
34 |                 ["blah",              false, null],
35 |                 ["blah blah",         true,  null]
36 |             ];
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/MonthRelationFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class MonthRelationFormatParserTests : FormatParserTestsBase
10 | {
11 |     public MonthRelationFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new MonthRelationFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["this janUary",  _now.AddYears(1).ChangeMonth(1).StartOfMonth(), _now.AddYears(1).ChangeMonth(1).EndOfMonth()
27 |                 ],
28 |                 ["last jan",      _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(1).EndOfMonth()],
29 |                 ["next januaRY",  _now.AddYears(1).ChangeMonth(1).StartOfMonth(), _now.AddYears(1).ChangeMonth(1).EndOfMonth()],
30 |                 ["this november", _now.StartOfMonth(), _now.EndOfMonth()],
31 |                 ["next november", _now.AddYears(1).StartOfMonth(), _now.AddYears(1).EndOfMonth()],
32 |                 ["this december", _now.ChangeMonth(12).StartOfMonth(), _now.ChangeMonth(12).EndOfMonth()],
33 |                 ["last november", _now.SubtractYears(1).StartOfMonth(), _now.SubtractYears(1).EndOfMonth()],
34 |                 ["blah",          null, null],
35 |                 ["blah blah",     null, null]
36 |             ];
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/TypeHelper.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Diagnostics;
 4 | using System.Linq;
 5 | using System.Reflection;
 6 | using Exceptionless.DateTimeExtensions.FormatParsers;
 7 | 
 8 | namespace Exceptionless.DateTimeExtensions;
 9 | 
10 | internal static class TypeHelper
11 | {
12 |     internal static IList<Type> SortByPriority(this IEnumerable<Type> types)
13 |     {
14 |         return types.OrderBy(t =>
15 |         {
16 |             var priorityAttribute = t.GetTypeInfo().GetCustomAttributes(typeof(PriorityAttribute), true).FirstOrDefault() as PriorityAttribute;
17 |             return priorityAttribute != null ? priorityAttribute.Priority : 0;
18 |         }).ToList();
19 |     }
20 | 
21 |     internal static IEnumerable<Type> GetDerivedTypes<TAction>(IEnumerable<Assembly> assemblies = null)
22 |     {
23 |         if (assemblies == null)
24 |             assemblies = [typeof(TypeHelper).GetTypeInfo().Assembly];
25 | 
26 |         var types = new List<Type>();
27 |         foreach (var assembly in assemblies)
28 |         {
29 |             try
30 |             {
31 |                 types.AddRange(from type in assembly.GetTypes() where type.GetTypeInfo().IsClass && !type.GetTypeInfo().IsNotPublic && !type.GetTypeInfo().IsAbstract && typeof(TAction).IsAssignableFrom(type) select type);
32 |             }
33 |             catch (ReflectionTypeLoadException ex)
34 |             {
35 |                 string loaderMessages = String.Join(", ", ex.LoaderExceptions.ToList().Select(le => le.Message));
36 |                 Debug.WriteLine("Unable to search types from assembly \"{0}\" for plugins of type \"{1}\": {2}", assembly.FullName, typeof(TAction).Name, loaderMessages);
37 |             }
38 |         }
39 | 
40 |         return types;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/Helper.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | 
 5 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 6 | 
 7 | internal static class Helper
 8 | {
 9 |     internal static readonly string SingularTimeNames = "minute|hour|day|week|month|year";
10 |     internal static readonly string PluralTimeNames = "minutes|hours|days|weeks|months|years";
11 |     internal static readonly string AllTimeNames = SingularTimeNames + "|" + PluralTimeNames;
12 |     internal static readonly string RelationNames = "this|past|last|next|previous";
13 |     internal static readonly List<string> MonthNames =
14 |     [
15 |         ..new[]
16 |         {
17 |             "january", "february", "march", "april", "may", "june", "july", "august", "september", "october",
18 |             "november", "december"
19 |         }
20 |     ];
21 | 
22 |     internal static TimeSpan GetTimeSpanFromName(string name)
23 |     {
24 |         return name.ToLower() switch
25 |         {
26 |             "minutes" => TimeSpan.FromMinutes(1),
27 |             "minute" => TimeSpan.FromMinutes(1),
28 |             "hours" => TimeSpan.FromHours(1),
29 |             "hour" => TimeSpan.FromHours(1),
30 |             "days" => TimeSpan.FromDays(1),
31 |             "day" => TimeSpan.FromDays(1),
32 |             _ => TimeSpan.Zero
33 |         };
34 |     }
35 | 
36 |     internal static int GetMonthNumber(string name)
37 |     {
38 |         int index = MonthNames.FindIndex(m => m.Equals(name, StringComparison.OrdinalIgnoreCase) || m.Substring(0, 3).Equals(name, StringComparison.OrdinalIgnoreCase));
39 |         return index >= 0 ? index + 1 : -1;
40 |     }
41 | 
42 |     internal static string GetMonthNames()
43 |     {
44 |         return String.Join("|", MonthNames) + "|" + String.Join("|", MonthNames.Where(m => m.Length > 3).Select(m => m.Substring(0, 3)));
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/SingleTimeRelationFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class SingleTimeRelationFormatParserTests : FormatParserTestsBase
10 | {
11 |     public SingleTimeRelationFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new SingleTimeRelationFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["past minute",   _now.SubtractMinutes(1).StartOfMinute(), _now],
27 |                 ["next minute",   _now, _now.AddMinutes(1).EndOfMinute()],
28 |                 ["last hour",     _now.SubtractHours(1).StartOfHour(), _now],
29 |                 ["next hour",     _now, _now.AddHours(1).EndOfHour()],
30 |                 ["previous day",  _now.SubtractDays(1).StartOfDay(), _now],
31 |                 ["next day",      _now, _now.AddDays(1).EndOfDay()],
32 |                 ["next month",    _now, _now.AddMonths(1).EndOfDay()],
33 |                 ["last month",    _now.SubtractMonths(1).StartOfDay(), _now],
34 |                 ["previous week", _now.SubtractWeeks(1).StartOfDay(), _now],
35 |                 ["next week",     _now, _now.AddWeeks(1).EndOfDay()],
36 |                 ["past year",     _now.SubtractYears(1).StartOfDay(), _now],
37 |                 ["next year",     _now, _now.AddYears(1).EndOfDay()],
38 |                 ["blah",          null, null],
39 |                 ["blah blah",     null, null]
40 |             ];
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/MonthRelationPartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class MonthRelationPartParserTests : PartParserTestsBase
10 | {
11 |     public MonthRelationPartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new MonthRelationPartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["this jan",      false, _now.AddYears(1).ChangeMonth(1).StartOfMonth()],
27 |                 ["this janUary",  true,  _now.AddYears(1).ChangeMonth(1).EndOfMonth()],
28 |                 ["last jan",      false, _now.ChangeMonth(1).StartOfMonth()],
29 |                 ["last jan",      true,  _now.ChangeMonth(1).EndOfMonth()],
30 |                 ["next januaRY",  false, _now.AddYears(1).ChangeMonth(1).StartOfMonth()],
31 |                 ["next jan",      true,  _now.AddYears(1).ChangeMonth(1).EndOfMonth()],
32 |                 ["this november", false, _now.StartOfMonth()],
33 |                 ["this november", true,  _now.EndOfMonth()],
34 |                 ["next november", false, _now.AddYears(1).StartOfMonth()],
35 |                 ["next november", true,  _now.AddYears(1).EndOfMonth()],
36 |                 ["this december", true,  _now.ChangeMonth(12).EndOfMonth()],
37 |                 ["last november", false, _now.SubtractYears(1).StartOfMonth()],
38 |                 ["blah",          false, null],
39 |                 ["blah blah",     true,  null]
40 |             ];
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/ExplicitDateFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class ExplicitDateFormatParserTests : FormatParserTestsBase
10 | {
11 |     public ExplicitDateFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new ExplicitDateFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["2014-02-01",               _now.Change(null, 2, 1).StartOfDay(), _now.Change(null, 2, 1).EndOfDay()],
27 |                 ["2014-02-01T05",            _now.Change(null, 2, 1, 5).StartOfHour(), _now.Change(null, 2, 1, 5).EndOfHour()],
28 |                 ["2014-02-01T05:30",         _now.Change(null, 2, 1, 5, 30).StartOfMinute(), _now.Change(null, 2, 1, 5, 30).EndOfMinute()],
29 |                 ["2014-02-01T05:30:20",      _now.Change(null, 2, 1, 5, 30, 20).StartOfSecond(), _now.Change(null, 2, 1, 5, 30, 20).EndOfSecond()],
30 |                 ["2014-02-01T05:30:20.000",  _now.Change(null, 2, 1, 5, 30, 20).StartOfSecond(), _now.Change(null, 2, 1, 5, 30, 20).EndOfSecond()],
31 |                 ["2014-02-01T05:30:20.000Z", _now.Change(null, 2, 1, 5, 30, 20).StartOfSecond(), _now.Change(null, 2, 1, 5, 30, 20).EndOfSecond()],
32 |                 ["2014-11-06",               _now.Change(null, 11, 6).StartOfDay(), _now.Change(null, 11, 6).EndOfDay()],
33 |                 ["2014-12-24",               _now.Change(null, 12, 24).StartOfDay(), _now.Change(null, 12, 24).EndOfDay()],
34 |                 ["2014-12-45",               null, null],
35 |                 ["blah",                     null, null],
36 |                 ["blah blah",                null, null]
37 |             ];
38 |         }
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/MonthRelationFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 5 | 
 6 | [Priority(40)]
 7 | public class MonthRelationFormatParser : IFormatParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"^\s*(?<relation>{0})\s+(?<month>{1})\s*$", Helper.RelationNames, Helper.GetMonthNames()), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 | 
11 |     public virtual DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
12 |     {
13 |         var m = _parser.Match(content);
14 |         if (!m.Success)
15 |             return null;
16 | 
17 |         string relation = m.Groups["relation"].Value.ToLower();
18 |         int month = Helper.GetMonthNumber(m.Groups["month"].Value);
19 |         return FromMonthRelation(relation, month, relativeBaseTime);
20 |     }
21 | 
22 |     protected DateTimeRange FromMonthRelation(string relation, int month, DateTimeOffset relativeBaseTime)
23 |     {
24 |         switch (relation)
25 |         {
26 |             case "this":
27 |                 {
28 |                     var start = relativeBaseTime.Month == month ? relativeBaseTime.StartOfMonth() : relativeBaseTime.Month < month ? relativeBaseTime.StartOfMonth().ChangeMonth(month) : relativeBaseTime.StartOfMonth().AddYears(1).ChangeMonth(month);
29 |                     return new DateTimeRange(start, start.EndOfMonth());
30 |                 }
31 |             case "last":
32 |             case "past":
33 |             case "previous":
34 |                 {
35 |                     var start = relativeBaseTime.Month > month ? relativeBaseTime.StartOfMonth().ChangeMonth(month) : relativeBaseTime.StartOfMonth().SubtractYears(1).ChangeMonth(month);
36 |                     return new DateTimeRange(start, start.EndOfMonth());
37 |                 }
38 |             case "next":
39 |                 {
40 |                     var start = relativeBaseTime.Month < month ? relativeBaseTime.StartOfMonth().ChangeMonth(month) : relativeBaseTime.StartOfMonth().AddYears(1).ChangeMonth(month);
41 |                     return new DateTimeRange(start, start.EndOfMonth());
42 |                 }
43 |         }
44 | 
45 |         return null;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/MonthRelationPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(30)]
 7 | public class MonthRelationPartParser : IPartParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"\G(?<relation>{0})\s+(?<month>{1})", Helper.RelationNames, Helper.GetMonthNames()), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 |     public virtual Regex Regex => _parser;
11 | 
12 |     public virtual DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
13 |     {
14 |         string relation = match.Groups["relation"].Value.ToLower();
15 |         int month = Helper.GetMonthNumber(match.Groups["month"].Value);
16 |         return FromMonthRelation(relation, month, relativeBaseTime, isUpperLimit);
17 |     }
18 | 
19 |     protected DateTimeOffset? FromMonthRelation(string relation, int month, DateTimeOffset relativeBaseTime, bool isUpperLimit)
20 |     {
21 |         switch (relation)
22 |         {
23 |             case "this":
24 |                 {
25 |                     var start = relativeBaseTime.Month == month ? relativeBaseTime.StartOfMonth() : relativeBaseTime.Month < month ? relativeBaseTime.StartOfMonth().ChangeMonth(month) : relativeBaseTime.StartOfMonth().AddYears(1).ChangeMonth(month);
26 |                     return isUpperLimit ? start.EndOfMonth() : start;
27 |                 }
28 |             case "last":
29 |             case "past":
30 |             case "previous":
31 |                 {
32 |                     var start = relativeBaseTime.Month > month ? relativeBaseTime.StartOfMonth().ChangeMonth(month) : relativeBaseTime.StartOfMonth().SubtractYears(1).ChangeMonth(month);
33 |                     return isUpperLimit ? start.EndOfMonth() : start;
34 |                 }
35 |             case "next":
36 |                 {
37 |                     var start = relativeBaseTime.Month < month ? relativeBaseTime.StartOfMonth().ChangeMonth(month) : relativeBaseTime.StartOfMonth().AddYears(1).ChangeMonth(month);
38 |                     return isUpperLimit ? start.EndOfMonth() : start;
39 |                 }
40 |         }
41 | 
42 |         return null;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/ExplicitDatePartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class ExplicitDatePartParserTests : PartParserTestsBase
10 | {
11 |     public ExplicitDatePartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new ExplicitDatePartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["2014-02-01",               false, _now.Change(null, 2, 1).StartOfDay()],
27 |                 ["2014-02-01",               true,  _now.Change(null, 2, 1).EndOfDay()],
28 |                 ["2014-02-01T05",            false, _now.Change(null, 2, 1, 5).StartOfHour()],
29 |                 ["2014-02-01T05",            true,  _now.Change(null, 2, 1, 5).EndOfHour()],
30 |                 ["2014-02-01T05:30",         false, _now.Change(null, 2, 1, 5, 30).StartOfMinute()],
31 |                 ["2014-02-01T05:30",         true,  _now.Change(null, 2, 1, 5, 30).EndOfMinute()],
32 |                 ["2014-02-01T05:30:20",      false, _now.Change(null, 2, 1, 5, 30, 20).StartOfSecond()],
33 |                 ["2014-02-01T05:30:20",      true,  _now.Change(null, 2, 1, 5, 30, 20).StartOfSecond()],
34 |                 ["2014-02-01T05:30:20.000",  false, _now.Change(null, 2, 1, 5, 30, 20).StartOfSecond()],
35 |                 ["2014-02-01T05:30:20.999",  true,  _now.Change(null, 2, 1, 5, 30, 20).EndOfSecond()],
36 |                 ["2014-02-01T05:30:20.000Z", false, _now.Change(null, 2, 1, 5, 30, 20).StartOfSecond()],
37 |                 ["2014-02-01T05:30:20.999Z", true,  _now.Change(null, 2, 1, 5, 30, 20).EndOfSecond()],
38 |                 ["2014-11-06",               false, _now.Change(null, 11, 6).StartOfDay()],
39 |                 ["2014-11-06",               true,  _now.Change(null, 11, 6).EndOfDay()],
40 |                 ["2014-12-24",               false, _now.Change(null, 12, 24).StartOfDay()],
41 |                 ["2014-12-24",               true,  _now.Change(null, 12, 24).EndOfDay()],
42 |                 ["2014-12-45",               true,  null],
43 |                 ["blah",                     false, null],
44 |                 ["blah blah",                true,  null]
45 |             ];
46 |         }
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/SingleTimeRelationPartParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
 8 | 
 9 | public class SingleTimeRelationPartParserTests : PartParserTestsBase
10 | {
11 |     public SingleTimeRelationPartParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
16 |     {
17 |         ValidateInput(new SingleTimeRelationPartParser(), input, isUpperLimit, expected);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 ["a minute ago",      false, _now.SubtractMinutes(1).StartOfMinute()],
27 |                 ["a minute ago",      true,  _now.SubtractMinutes(1).EndOfMinute()],
28 |                 ["a minute from now", false, _now.AddMinutes(1).StartOfMinute()],
29 |                 ["a minute from now", true,  _now.AddMinutes(1).EndOfMinute()],
30 |                 ["an hour ago",       false, _now.SubtractHours(1).StartOfHour()],
31 |                 ["an hour ago",       true,  _now.SubtractHours(1).EndOfHour()],
32 |                 ["an hour from now",  false, _now.AddHours(1).StartOfHour()],
33 |                 ["an hour from now",  true,  _now.AddHours(1).EndOfHour()],
34 |                 ["a day ago",         false, _now.SubtractDays(1).StartOfDay()],
35 |                 ["a day ago",         true,  _now.SubtractDays(1).EndOfDay()],
36 |                 ["a day from now",    false, _now.AddDays(1).StartOfDay()],
37 |                 ["a day from now",    true,  _now.AddDays(1).EndOfDay()],
38 |                 ["a month ago",       false, _now.SubtractMonths(1).StartOfDay()],
39 |                 ["a month ago",       true,  _now.SubtractMonths(1).EndOfDay()],
40 |                 ["a month from now",  false, _now.AddMonths(1).StartOfDay()],
41 |                 ["a month from now",  true,  _now.AddMonths(1).EndOfDay()],
42 |                 ["a week ago",        false, _now.SubtractWeeks(1).StartOfDay()],
43 |                 ["a week ago",        true,  _now.SubtractWeeks(1).EndOfDay()],
44 |                 ["a week from now",   false, _now.AddWeeks(1).StartOfDay()],
45 |                 ["a week from now",   true,  _now.AddWeeks(1).EndOfDay()],
46 |                 ["a year ago",        false, _now.SubtractYears(1).StartOfDay()],
47 |                 ["a year ago",        true,  _now.SubtractYears(1).EndOfDay()],
48 |                 ["a year from now",   false, _now.AddYears(1).StartOfDay()],
49 |                 ["a year from now",   true,  _now.AddYears(1).EndOfDay()],
50 |                 ["blah",              false, null],
51 |                 ["blah blah",         true,  null]
52 |             ];
53 |         }
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/BusinessDay.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Diagnostics;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions;
 5 | 
 6 | /// <summary>
 7 | /// A class defining a business day.
 8 | /// </summary>
 9 | [DebuggerDisplay("DayOfWeek={DayOfWeek}, StartTime={StartTime}, EndTime={EndTime}")]
10 | public class BusinessDay
11 | {
12 |     /// <summary>
13 |     /// Initializes a new instance of the <see cref="BusinessDay"/> class.
14 |     /// </summary>
15 |     /// <param name="dayOfWeek">The day of week this business day represents.</param>
16 |     public BusinessDay(DayOfWeek dayOfWeek)
17 |     {
18 |         StartTime = TimeSpan.FromHours(9); // 9am
19 |         EndTime = TimeSpan.FromHours(17); // 5pm
20 |         DayOfWeek = dayOfWeek;
21 |     }
22 | 
23 |     /// <summary>
24 |     /// Initializes a new instance of the <see cref="BusinessDay"/> class.
25 |     /// </summary>
26 |     /// <param name="dayOfWeek">The day of week this business day represents.</param>
27 |     /// <param name="startTime">The start time of the business day.</param>
28 |     /// <param name="endTime">The end time of the business day.</param>
29 |     public BusinessDay(DayOfWeek dayOfWeek, TimeSpan startTime, TimeSpan endTime)
30 |     {
31 |         if (startTime.TotalDays >= 1)
32 |             throw new ArgumentOutOfRangeException(nameof(startTime), startTime, "The startTime argument must be less then one day.");
33 | 
34 |         if (endTime.TotalDays > 1)
35 |             throw new ArgumentOutOfRangeException(nameof(endTime), endTime, "The endTime argument must be less then one day.");
36 | 
37 |         if (endTime <= startTime)
38 |             throw new ArgumentOutOfRangeException(nameof(endTime), endTime, "The endTime argument must be greater then startTime.");
39 | 
40 |         DayOfWeek = dayOfWeek;
41 |         StartTime = startTime;
42 |         EndTime = endTime;
43 |     }
44 | 
45 |     /// <summary>
46 |     /// Gets the day of week this business day represents..
47 |     /// </summary>
48 |     /// <value>The day of week.</value>
49 |     public DayOfWeek DayOfWeek { get; private set; }
50 | 
51 |     /// <summary>
52 |     /// Gets the start time of the business day.
53 |     /// </summary>
54 |     /// <value>The start time of the business day.</value>
55 |     public TimeSpan StartTime { get; private set; }
56 | 
57 |     /// <summary>
58 |     /// Gets the end time of the business day.
59 |     /// </summary>
60 |     /// <value>The end time of the business day.</value>
61 |     public TimeSpan EndTime { get; private set; }
62 | 
63 |     /// <summary>
64 |     /// Determines whether the specified date falls in the business day.
65 |     /// </summary>
66 |     /// <param name="date">The date to check.</param>
67 |     /// <returns>
68 |     /// 	<c>true</c> if the specified date falls in the business day; otherwise, <c>false</c>.
69 |     /// </returns>
70 |     public bool IsBusinessDay(DateTime date)
71 |     {
72 |         if (date.DayOfWeek != DayOfWeek)
73 |             return false;
74 | 
75 |         if (date.TimeOfDay < StartTime)
76 |             return false;
77 | 
78 |         if (date.TimeOfDay > EndTime)
79 |             return false;
80 | 
81 |         return true;
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/.github/instructions/general.instructions.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | description: "General coding guidelines"
 3 | applyTo: "**"
 4 | ---
 5 | 
 6 | # General Coding Guidelines
 7 | 
 8 | You are a distinguished engineer and are expected to deliver high-quality code that adheres to the guidelines below.
 9 | All contributions must respect existing formatting and conventions specified in the `.editorconfig` file and
10 | Microsoft's [coding conventions](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions).
11 | 
12 | Code can be formatted with `dotnet format` and checked for errors with `dotnet build`.
13 | 
14 | Use context7 for documentation
15 | 
16 | ## Code Style & Minimal Diffs
17 | 
18 | - Match the file's existing style; use `.editorconfig` when unsure.
19 | - Preserve extra spaces, comments, and minimize diffs.
20 | - Always ask before creating new files, directories, or changing existing structures.
21 | - Always look at existing usages before refactoring or changing code to prevent new code from breaking existing code.
22 | - Assume any existing uncommitted code is correct and ask before changing it.
23 | - Don't add code comments unless necessary. Code should be self-explanatory.
24 | - Don't use deprecated or insecure libraries, algorithms or features.
25 | 
26 | ## Modern Code Practices
27 | 
28 | - Write complete, runnable code—no placeholders or TODOs.
29 | - Use modern language features, clear naming conventions, and defensive coding when necessary.
30 | - Follow SOLID, DRY, and clean code principles. Remove unused code.
31 | 
32 | ## Behavior Management
33 | 
34 | - Flag any user-visible changes for review.
35 | - Deliver exactly what's requested—avoid adding unnecessary features unless explicitly instructed.
36 | 
37 | ## Security Guidelines
38 | 
39 | - Sanitize all user inputs and rigorously validate data.
40 | - Follow OWASP guidelines and implement a robust Content Security Policy.
41 | - Adopt Shift-Left security practices to identify vulnerabilities early.
42 | 
43 | ## Developer Planning & Reflection
44 | 
45 | ### Pre-Coding Reflection
46 | 
47 | 1. Identify the problem or feature you're solving.
48 | 2. Consider three possible approaches.
49 | 3. Choose the simplest approach that satisfies all requirements.
50 | 4. Clarify:
51 |     - Can the solution be modularized into smaller functions?
52 |     - Are there unnecessary abstractions?
53 |     - Will the implementation be clear to a junior developer?
54 | 
55 | ### Post-Coding Reflection
56 | 
57 | 1. Review for refactor opportunities—can clarity or maintainability be improved?
58 | 2. Identify potential edge cases or areas prone to bugs.
59 | 3. Verify robust error handling and validation mechanisms.
60 | 
61 | ## Code Reviews
62 | 
63 | - Ensure adherence to complexity, consistency, and clean code standards.
64 | - Validate robust error handling and defensive coding practices.
65 | - Check for duplication and maintainable solutions.
66 | 
67 | ## Debugging Guidelines
68 | 
69 | 1. **Reproduce** the issue with minimal steps and code.
70 | 2. **Understand** the underlying problem thoroughly.
71 | 3. **Form Hypotheses** about the cause.
72 | 4. **Test & Verify** potential solutions.
73 | 5. **Document** fixes and adjustments clearly for future reference.
74 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/DateTimeExtensionsTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Xunit;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.Tests;
 5 | 
 6 | public class DateTimeExtensionsTests
 7 | {
 8 |     [Fact]
 9 |     public void ToAge()
10 |     {
11 |         var date = DateTime.Now.SubtractMinutes(5);
12 |         Assert.Equal("5 minutes", date.ToAgeString());
13 | 
14 |         date = DateTime.Now.SubtractDays(3).SubtractMinutes(12);
15 |         Assert.Equal("3 days 12 minutes", date.ToAgeString());
16 |     }
17 | 
18 |     [Fact]
19 |     public void ToApproximateAge()
20 |     {
21 |         Assert.Equal("59 minutes from now", DateTime.Now.Ceiling(TimeSpan.FromMinutes(1)).AddMinutes(59).ToApproximateAgeString());
22 |         Assert.Equal("59 minutes ago", DateTime.Now.Floor(TimeSpan.FromMinutes(1)).SubtractMinutes(59).ToApproximateAgeString());
23 |         Assert.Equal("1 hour from now", DateTime.Now.Ceiling(TimeSpan.FromMinutes(1)).AddHours(1).ToApproximateAgeString());
24 |         Assert.Equal("1 hour ago", DateTime.Now.Floor(TimeSpan.FromMinutes(1)).SubtractHours(1).ToApproximateAgeString());
25 |     }
26 | 
27 |     [Fact]
28 |     public void EndOfHour()
29 |     {
30 |         Assert.Equal(new DateTime(2014, 1, 1, 5, 59, 59, 999), new DateTime(2014, 1, 1, 5, 0, 0, 1).EndOfHour());
31 |         Assert.Equal(new DateTime(2014, 1, 1, 5, 59, 59, 999), new DateTime(2014, 1, 1, 5, 0, 0, 0).EndOfHour());
32 |     }
33 | 
34 |     [Fact]
35 |     public void EndOfDay()
36 |     {
37 |         Assert.Equal(new DateTime(2014, 11, 7).Subtract(TimeSpan.FromMilliseconds(1)), new DateTime(2014, 11, 6).EndOfDay());
38 |         Assert.Equal(new DateTime(2014, 11, 8).Subtract(TimeSpan.FromMilliseconds(1)), new DateTime(2014, 11, 6, 1, 12, 12).AddDays(1).EndOfDay());
39 | 
40 |         Assert.Equal(new DateTime(2014, 11, 6), new DateTime(2014, 11, 6).StartOfDay());
41 |         Assert.Equal(new DateTime(2011, 11, 6), new DateTime(2014, 11, 6).SubtractYears(3).StartOfDay());
42 |     }
43 | 
44 |     [Fact]
45 |     public void SafeAdd()
46 |     {
47 |         Assert.Equal(DateTime.MinValue.AddHours(1), DateTime.MinValue.SafeAdd(TimeSpan.FromHours(1)));
48 |         Assert.Equal(DateTime.MinValue, DateTime.MinValue.SafeAdd(TimeSpan.FromHours(-1)));
49 |         Assert.Equal(DateTime.MaxValue, DateTime.MaxValue.SafeAdd(TimeSpan.FromHours(1)));
50 |         Assert.Equal(DateTime.MaxValue, DateTime.MaxValue.SubtractHours(1).SafeAdd(TimeSpan.FromHours(1)));
51 |         Assert.Equal(DateTime.MaxValue, DateTime.MaxValue.SubtractHours(1).SafeAdd(TimeSpan.FromHours(2)));
52 |     }
53 | 
54 |     [Fact]
55 |     public void SafeSubtract()
56 |     {
57 |         Assert.Equal(DateTime.MinValue, DateTime.MinValue.SafeSubtract(TimeSpan.FromHours(1)));
58 |         Assert.Equal(DateTime.MaxValue.SubtractHours(1), DateTime.MaxValue.SafeSubtract(TimeSpan.FromHours(1)));
59 |     }
60 | 
61 |     [Fact]
62 |     public void Intersects()
63 |     {
64 |         Assert.True(DateTime.UtcNow.IntersectsDay(DateTime.UtcNow));
65 |         Assert.True(DateTime.UtcNow.IntersectsDay(DateTime.UtcNow.StartOfDay()));
66 |         Assert.True(DateTime.UtcNow.IntersectsDay(DateTime.UtcNow.EndOfDay()));
67 |         Assert.False(DateTime.UtcNow.IntersectsDay(DateTime.UtcNow.AddDays(1)));
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/TwoPartFormatParserTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using Exceptionless.DateTimeExtensions.FormatParsers;
 4 | using Xunit;
 5 | using Xunit.Abstractions;
 6 | 
 7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers;
 8 | 
 9 | public class TwoPartFormatParserTests : FormatParserTestsBase
10 | {
11 |     public TwoPartFormatParserTests(ITestOutputHelper output) : base(output) { }
12 | 
13 |     [Theory]
14 |     [MemberData(nameof(Inputs))]
15 |     public void ParseInput(string input, DateTime? start, DateTime? end)
16 |     {
17 |         ValidateInput(new TwoPartFormatParser(), input, start, end);
18 |     }
19 | 
20 |     public static IEnumerable<object[]> Inputs
21 |     {
22 |         get
23 |         {
24 |             return
25 |             [
26 |                 // Original dash delimiter syntax
27 |                 ["2012-2013",        _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2013).EndOfYear()],
28 |                 ["5 days ago - now", _now.SubtractDays(5).StartOfDay(), _now],
29 |                 ["jan-feb",          _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
30 |                 ["now-this feb",     _now, _now.AddYears(1).ChangeMonth(2).EndOfMonth()],
31 | 
32 |                 // TO delimiter syntax (case-insensitive)
33 |                 ["2012 TO 2013",     _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2013).EndOfYear()],
34 |                 ["jan to feb",       _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
35 |                 ["5 days ago TO now", _now.SubtractDays(5).StartOfDay(), _now],
36 | 
37 |                 // Elasticsearch bracket syntax
38 |                 ["[2012 TO 2013]",   _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2013).EndOfYear()],
39 |                 ["{jan TO feb}",     _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
40 |                 ["[2012-2013]",      _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2013).EndOfYear()],
41 | 
42 |                 // Wildcard support
43 |                 ["* TO 2013",        DateTime.MinValue, _now.ChangeYear(2013).EndOfYear()],
44 |                 ["2012 TO *",        _now.ChangeYear(2012).StartOfYear(), DateTime.MaxValue],
45 |                 ["[* TO 2013]",      DateTime.MinValue, _now.ChangeYear(2013).EndOfYear()],
46 |                 ["{2012 TO *}",      _now.ChangeYear(2012).StartOfYear(), DateTime.MaxValue],
47 | 
48 |                 // Invalid inputs
49 |                 ["blah",             null, null],
50 |                 ["[invalid",         null, null],
51 |                 ["invalid}",         null, null],
52 | 
53 |                 // Mismatched bracket validation
54 |                 ["{2012 TO 2013]",   null, null], // Opening brace with closing bracket
55 |                 ["[2012 TO 2013}",   null, null], // Opening bracket with closing brace
56 |                 ["}2012 TO 2013{",   null, null], // Wrong orientation
57 |                 ["]2012 TO 2013[",   null, null], // Wrong orientation
58 |                 ["[2012 TO 2013",    null, null], // Missing closing bracket
59 |                 ["2012 TO 2013]",    null, null] // Missing opening bracket
60 |             ];
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/TimeUnit.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Exceptionless.DateTimeExtensions;
 4 | 
 5 | public static class TimeUnit
 6 | {
 7 |     public static TimeSpan Parse(string value)
 8 |     {
 9 |         if (String.IsNullOrEmpty(value))
10 |             throw new ArgumentNullException(nameof(value));
11 | 
12 |         var time = ParseTime(value);
13 |         if (time.HasValue)
14 |             return time.Value;
15 | 
16 |         throw new ArgumentException($"Unable to parse value '{value}' as a valid time value.");
17 |     }
18 | 
19 |     public static bool TryParse(string value, out TimeSpan? time)
20 |     {
21 |         time = null;
22 |         if (String.IsNullOrEmpty(value))
23 |             return false;
24 | 
25 |         time = ParseTime(value);
26 |         return time.HasValue;
27 |     }
28 | 
29 |     private static TimeSpan? ParseTime(string value)
30 |     {
31 |         if (String.IsNullOrWhiteSpace(value))
32 |             return null;
33 | 
34 |         string normalized = value.Trim();
35 | 
36 |         // bail if we have any weird characters
37 |         foreach (char c in normalized)
38 |             if (!Char.IsLetterOrDigit(c) && c != '-' && c != '+' && !Char.IsWhiteSpace(c))
39 |                 return null;
40 | 
41 |         // Handle years (y) - using average days in a year
42 |         if (normalized.EndsWith("y") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int years))
43 |             return new TimeSpan((int)(years * TimeSpanExtensions.AvgDaysInAYear), 0, 0, 0);
44 | 
45 |         // Handle months (M) - using average days in a month, case-sensitive uppercase M
46 |         if (normalized.EndsWith("M") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int months))
47 |             return new TimeSpan((int)(months * TimeSpanExtensions.AvgDaysInAMonth), 0, 0, 0);
48 | 
49 |         // Handle weeks (w)
50 |         if (normalized.EndsWith("w") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int weeks))
51 |             return new TimeSpan(weeks * 7, 0, 0, 0);
52 | 
53 |         // Handle minutes (m) - lowercase m for minutes
54 |         if (normalized.EndsWith("m") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int minutes))
55 |             return new TimeSpan(0, minutes, 0);
56 | 
57 |         if (normalized.EndsWith("h") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int hours))
58 |             return new TimeSpan(hours, 0, 0);
59 | 
60 |         if (normalized.EndsWith("d") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int days))
61 |             return new TimeSpan(days, 0, 0, 0);
62 | 
63 |         if (normalized.EndsWith("nanos", StringComparison.OrdinalIgnoreCase) && Int32.TryParse(normalized.Substring(0, normalized.Length - 5), out int nanoseconds))
64 |             return new TimeSpan((int)Math.Round(nanoseconds / 100d));
65 | 
66 |         if (normalized.EndsWith("micros", StringComparison.OrdinalIgnoreCase) && Int32.TryParse(normalized.Substring(0, normalized.Length - 6), out int microseconds))
67 |             return new TimeSpan(microseconds * 10);
68 | 
69 |         if (normalized.EndsWith("ms") && Int32.TryParse(normalized.Substring(0, normalized.Length - 2), out int milliseconds))
70 |             return new TimeSpan(0, 0, 0, 0, milliseconds);
71 | 
72 |         if (normalized.EndsWith("s") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int seconds))
73 |             return new TimeSpan(0, 0, seconds);
74 | 
75 |         return null;
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/PartParsers/AmountTimeRelationPartParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
 5 | 
 6 | [Priority(20)]
 7 | public class AmountTimeRelationPartParser : IPartParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"\G(?<amount>\d+)\s+(?<size>{0})\s+(?<relation>ago|from now)", Helper.AllTimeNames), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 |     public virtual Regex Regex => _parser;
11 | 
12 |     public virtual DateTimeOffset? Parse(Match match, DateTimeOffset relativeBaseTime, bool isUpperLimit)
13 |     {
14 |         return FromRelationAmountTime(
15 |             match.Groups["relation"].Value,
16 |             Int32.Parse(match.Groups["amount"].Value),
17 |             match.Groups["size"].Value,
18 |             relativeBaseTime,
19 |             isUpperLimit);
20 |     }
21 | 
22 |     protected DateTimeOffset? FromRelationAmountTime(string relation, int amount, string size, DateTimeOffset relativeBaseTime, bool isUpperLimit)
23 |     {
24 |         relation = relation.ToLower();
25 |         size = size.ToLower();
26 |         if (amount < 1)
27 |             throw new ArgumentException("Time amount can't be 0.");
28 |         var intervalSpan = Helper.GetTimeSpanFromName(size);
29 | 
30 |         if (intervalSpan != TimeSpan.Zero)
31 |         {
32 |             var totalSpan = TimeSpan.FromTicks(intervalSpan.Ticks * amount);
33 |             switch (relation)
34 |             {
35 |                 case "ago":
36 |                     return isUpperLimit ? relativeBaseTime.SafeSubtract(totalSpan).Ceiling(intervalSpan).SubtractMilliseconds(1) : relativeBaseTime.SafeSubtract(totalSpan).Floor(intervalSpan);
37 |                 case "from now":
38 |                     return isUpperLimit ? relativeBaseTime.SafeAdd(totalSpan).Ceiling(intervalSpan).SubtractMilliseconds(1) : relativeBaseTime.SafeAdd(totalSpan).Floor(intervalSpan);
39 |             }
40 |         }
41 |         else if (size == "week" || size == "weeks")
42 |         {
43 |             switch (relation)
44 |             {
45 |                 case "ago":
46 |                     return isUpperLimit ? relativeBaseTime.SubtractWeeks(amount).EndOfDay() : relativeBaseTime.SubtractWeeks(amount).StartOfDay();
47 |                 case "from now":
48 |                     return isUpperLimit ? relativeBaseTime.AddWeeks(amount).EndOfDay() : relativeBaseTime.AddWeeks(amount).StartOfDay();
49 |             }
50 |         }
51 |         else if (size == "month" || size == "months")
52 |         {
53 |             switch (relation)
54 |             {
55 |                 case "ago":
56 |                     return isUpperLimit ? relativeBaseTime.SubtractMonths(amount).EndOfDay() : relativeBaseTime.SubtractMonths(amount).StartOfDay();
57 |                 case "from now":
58 |                     return isUpperLimit ? relativeBaseTime.AddMonths(amount).EndOfDay() : relativeBaseTime.AddMonths(amount).StartOfDay();
59 |             }
60 |         }
61 |         else if (size == "year" || size == "years")
62 |         {
63 |             switch (relation)
64 |             {
65 |                 case "ago":
66 |                     return isUpperLimit ? relativeBaseTime.SubtractYears(amount).EndOfDay() : relativeBaseTime.SubtractYears(amount).StartOfDay();
67 |                 case "from now":
68 |                     return isUpperLimit ? relativeBaseTime.AddYears(amount).EndOfDay() : relativeBaseTime.AddYears(amount).StartOfDay();
69 |             }
70 |         }
71 | 
72 |         return null;
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/RelationAmountTimeFormatParser.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
 5 | 
 6 | [Priority(10)]
 7 | public class RelationAmountTimeFormatParser : IFormatParser
 8 | {
 9 |     private static readonly Regex _parser = new(String.Format(@"^\s*(?<relation>{0})\s+(?<amount>\d+)\s+(?<size>{1})\s*$", Helper.RelationNames, Helper.AllTimeNames), RegexOptions.Compiled | RegexOptions.IgnoreCase);
10 | 
11 |     public virtual DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
12 |     {
13 |         var m = _parser.Match(content);
14 |         if (!m.Success)
15 |             return null;
16 | 
17 |         return FromRelationAmountTime(m.Groups["relation"].Value, Int32.Parse(m.Groups["amount"].Value), m.Groups["size"].Value, relativeBaseTime);
18 |     }
19 | 
20 |     protected DateTimeRange FromRelationAmountTime(string relation, int amount, string size, DateTimeOffset relativeBaseTime)
21 |     {
22 |         relation = relation.ToLower();
23 |         size = size.ToLower();
24 |         if (amount < 1)
25 |             throw new ArgumentException("Time amount can't be 0.");
26 | 
27 |         var intervalSpan = Helper.GetTimeSpanFromName(size);
28 | 
29 |         if (intervalSpan != TimeSpan.Zero)
30 |         {
31 |             var totalSpan = TimeSpan.FromTicks(intervalSpan.Ticks * amount);
32 |             switch (relation)
33 |             {
34 |                 case "last":
35 |                 case "past":
36 |                 case "previous":
37 |                     return new DateTimeRange(relativeBaseTime.Floor(intervalSpan).SafeSubtract(totalSpan), relativeBaseTime);
38 |                 case "this":
39 |                 case "next":
40 |                     return new DateTimeRange(relativeBaseTime, relativeBaseTime.SafeAdd(totalSpan).Ceiling(intervalSpan).SubtractMilliseconds(1));
41 |             }
42 |         }
43 |         else if (size == "week" || size == "weeks")
44 |         {
45 |             switch (relation)
46 |             {
47 |                 case "last":
48 |                 case "past":
49 |                 case "previous":
50 |                     return new DateTimeRange(relativeBaseTime.SubtractWeeks(amount).StartOfDay(), relativeBaseTime);
51 |                 case "this":
52 |                 case "next":
53 |                     return new DateTimeRange(relativeBaseTime, relativeBaseTime.AddWeeks(amount).EndOfDay());
54 |             }
55 |         }
56 |         else if (size == "month" || size == "months")
57 |         {
58 |             switch (relation)
59 |             {
60 |                 case "last":
61 |                 case "past":
62 |                 case "previous":
63 |                     return new DateTimeRange(relativeBaseTime.SubtractMonths(amount).StartOfDay(), relativeBaseTime);
64 |                 case "this":
65 |                 case "next":
66 |                     return new DateTimeRange(relativeBaseTime, relativeBaseTime.AddMonths(amount).EndOfDay());
67 |             }
68 |         }
69 |         else if (size == "year" || size == "years")
70 |         {
71 |             switch (relation)
72 |             {
73 |                 case "last":
74 |                 case "past":
75 |                 case "previous":
76 |                     return new DateTimeRange(relativeBaseTime.SubtractYears(amount).StartOfDay(), relativeBaseTime);
77 |                 case "this":
78 |                 case "next":
79 |                     return new DateTimeRange(relativeBaseTime, relativeBaseTime.AddYears(amount).EndOfDay());
80 |             }
81 |         }
82 | 
83 |         return null;
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/TwoPartFormatParser.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Text.RegularExpressions;
  4 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
  5 | 
  6 | namespace Exceptionless.DateTimeExtensions.FormatParsers;
  7 | 
  8 | [Priority(25)]
  9 | public class TwoPartFormatParser : IFormatParser
 10 | {
 11 |     private static readonly Regex _beginRegex = new(@"^\s*([\[\{])?\s*", RegexOptions.Compiled);
 12 |     private static readonly Regex _delimiterRegex = new(@"\G(?:\s*-\s*|\s+TO\s+)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
 13 |     private static readonly Regex _endRegex = new(@"\G\s*([\]\}])?\s*$", RegexOptions.Compiled);
 14 | 
 15 |     public TwoPartFormatParser()
 16 |     {
 17 |         Parsers = new List<IPartParser>(DateTimeRange.PartParsers);
 18 |     }
 19 | 
 20 |     public TwoPartFormatParser(IEnumerable<IPartParser> parsers, bool includeDefaults = false)
 21 |     {
 22 |         Parsers = new List<IPartParser>(parsers);
 23 |         if (includeDefaults)
 24 |             Parsers.AddRange(DateTimeRange.PartParsers);
 25 |     }
 26 | 
 27 |     public List<IPartParser> Parsers { get; private set; }
 28 | 
 29 |     public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
 30 |     {
 31 |         int index = 0;
 32 |         var begin = _beginRegex.Match(content, index);
 33 |         if (!begin.Success)
 34 |             return null;
 35 | 
 36 |         // Capture the opening bracket if present
 37 |         string openingBracket = begin.Groups[1].Value;
 38 | 
 39 |         index += begin.Length;
 40 |         DateTimeOffset? start = null;
 41 |         foreach (var parser in Parsers)
 42 |         {
 43 |             var match = parser.Regex.Match(content, index);
 44 |             if (!match.Success)
 45 |                 continue;
 46 | 
 47 |             start = parser.Parse(match, relativeBaseTime, false);
 48 |             if (start == null)
 49 |                 continue;
 50 | 
 51 |             index += match.Length;
 52 |             break;
 53 |         }
 54 | 
 55 |         var delimiter = _delimiterRegex.Match(content, index);
 56 |         if (!delimiter.Success)
 57 |             return null;
 58 | 
 59 |         index += delimiter.Length;
 60 | 
 61 |         DateTimeOffset? end = null;
 62 |         foreach (var parser in Parsers)
 63 |         {
 64 |             var match = parser.Regex.Match(content, index);
 65 |             if (!match.Success)
 66 |                 continue;
 67 | 
 68 |             end = parser.Parse(match, relativeBaseTime, true);
 69 |             if (end == null)
 70 |                 continue;
 71 | 
 72 |             index += match.Length;
 73 |             break;
 74 |         }
 75 | 
 76 |         var endMatch = _endRegex.Match(content, index);
 77 |         if (!endMatch.Success)
 78 |             return null;
 79 | 
 80 |         // Validate bracket matching
 81 |         string closingBracket = endMatch.Groups[1].Value;
 82 |         if (!IsValidBracketPair(openingBracket, closingBracket))
 83 |             return null;
 84 | 
 85 |         return new DateTimeRange(start ?? DateTime.MinValue, end ?? DateTime.MaxValue);
 86 |     }
 87 | 
 88 |     /// <summary>
 89 |     /// Validates that opening and closing brackets are properly matched.
 90 |     /// </summary>
 91 |     /// <param name="opening">The opening bracket character</param>
 92 |     /// <param name="closing">The closing bracket character</param>
 93 |     /// <returns>True if brackets are properly matched, false otherwise</returns>
 94 |     private static bool IsValidBracketPair(string opening, string closing)
 95 |     {
 96 |         // Both empty - valid (no brackets)
 97 |         if (String.IsNullOrEmpty(opening) && String.IsNullOrEmpty(closing))
 98 |             return true;
 99 | 
100 |         // One empty, one not - invalid (unbalanced)
101 |         if (String.IsNullOrEmpty(opening) || String.IsNullOrEmpty(closing))
102 |             return false;
103 | 
104 |         // Check for proper matching pairs
105 |         return (opening == "[" && closing == "]") ||
106 |                (opening == "{" && closing == "}");
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/WildcardPartParserTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
  4 | using Microsoft.Extensions.Logging;
  5 | using Xunit;
  6 | using Xunit.Abstractions;
  7 | 
  8 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
  9 | 
 10 | public class WildcardPartParserTests : PartParserTestsBase
 11 | {
 12 |     public WildcardPartParserTests(ITestOutputHelper output) : base(output) { }
 13 | 
 14 |     [Theory]
 15 |     [MemberData(nameof(ParseInputs))]
 16 |     public void ParseInput(string input, bool isUpperLimit, DateTimeOffset? expected)
 17 |     {
 18 |         var parser = new WildcardPartParser();
 19 |         _logger.LogInformation("Testing input: '{Input}', IsUpperLimit: {IsUpperLimit}, Expected: {Expected}", input, isUpperLimit, expected);
 20 | 
 21 |         var match = parser.Regex.Match(input);
 22 |         _logger.LogInformation("Regex match success: {Success}, Value: '{Value}', Index: {Index}, Length: {Length}", match.Success, match.Value, match.Index, match.Length);
 23 | 
 24 |         var result = parser.Parse(match, _now, isUpperLimit);
 25 |         _logger.LogInformation("Parse result: {Result}", result);
 26 | 
 27 |         if (expected == null)
 28 |         {
 29 |             Assert.Null(result);
 30 |         }
 31 |         else
 32 |         {
 33 |             Assert.NotNull(result);
 34 |             Assert.Equal(expected.Value.DateTime, result.Value.DateTime);
 35 |         }
 36 |     }
 37 | 
 38 |     public static IEnumerable<object[]> ParseInputs
 39 |     {
 40 |         get
 41 |         {
 42 |             return
 43 |             [
 44 |                 // Valid wildcard inputs
 45 |                 ["*", false, DateTimeOffset.MinValue],
 46 |                 ["*", true, DateTimeOffset.MaxValue],
 47 |                 [" * ", false, DateTimeOffset.MinValue],
 48 |                 [" * ", true, DateTimeOffset.MaxValue],
 49 |                 ["  *  ", false, DateTimeOffset.MinValue],
 50 |                 ["  *  ", true, DateTimeOffset.MaxValue],
 51 | 
 52 |                 // Invalid inputs (patterns that should not match a complete wildcard)
 53 |                 ["blah", false, null],
 54 |                 ["blah", true, null],
 55 |                 ["2012", false, null],
 56 |                 ["2012", true, null],
 57 |                 ["**", false, null],
 58 | 
 59 |                 // This should match the first * in a two-part context like "* *"
 60 |                 ["* *", false, DateTimeOffset.MinValue]
 61 |             ];
 62 |         }
 63 |     }
 64 | 
 65 |     [Fact]
 66 |     public void RegexPatternTest()
 67 |     {
 68 |         var parser = new WildcardPartParser();
 69 |         var regex = parser.Regex;
 70 | 
 71 |         _logger.LogInformation("Regex pattern: {Pattern}", regex);
 72 | 
 73 |         // Test various inputs
 74 |         string[] testInputs = ["*", " * ", "  *  ", "blah", "2012", "**", "* *", ""];
 75 | 
 76 |         foreach (string input in testInputs)
 77 |         {
 78 |             var match = regex.Match(input);
 79 |             _logger.LogInformation("Input: '{Input}' -> Success: {Success}, Value: '{Value}', Index: {Index}, Length: {Length}", input, match.Success, match.Value, match.Index, match.Length);
 80 |         }
 81 |     }
 82 | 
 83 |     [Fact]
 84 |     public void TestInTwoPartContext()
 85 |     {
 86 |         var parser = new WildcardPartParser();
 87 | 
 88 |         // Test how it behaves in a two-part parsing context
 89 |         string[] inputs = ["* TO 2013", "2012 TO *", "[* TO 2013]", "{2012 TO *}"];
 90 | 
 91 |         foreach (string input in inputs)
 92 |         {
 93 |             _logger.LogInformation("Testing two-part context for: '{Input}'", input);
 94 | 
 95 |             // Test parsing at the beginning
 96 |             var match = parser.Regex.Match(input, 0);
 97 |             _logger.LogInformation("  At position 0: Success: {Success}, Value: '{Value}', Index: {Index}, Length: {Length}", match.Success, match.Value, match.Index, match.Length);
 98 | 
 99 |             // Test parsing after bracket
100 |             if (input.StartsWith("[") || input.StartsWith("{"))
101 |             {
102 |                 match = parser.Regex.Match(input, 1);
103 |                 _logger.LogInformation("  At position 1: Success: {Success}, Value: '{Value}', Index: {Index}, Length: {Length}", match.Success, match.Value, match.Index, match.Length);
104 |             }
105 | 
106 |             // Find TO and test parsing after it
107 |             int toIndex = input.IndexOf(" TO ", StringComparison.OrdinalIgnoreCase);
108 |             if (toIndex >= 0)
109 |             {
110 |                 int afterTo = toIndex + 4;
111 |                 match = parser.Regex.Match(input, afterTo);
112 |                 _logger.LogInformation("  After TO at position {Position}: Success: {Success}, Value: '{Value}', Index: {Index}, Length: {Length}", afterTo, match.Success, match.Value, match.Index, match.Length);
113 |             }
114 |         }
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/TimeSpanExtensionTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using Xunit;
  3 | 
  4 | namespace Exceptionless.DateTimeExtensions.Tests;
  5 | 
  6 | public class TimeSpanExtensionTests
  7 | {
  8 |     [Fact]
  9 |     public void ToWords()
 10 |     {
 11 |         var value = TimeSpan.FromMilliseconds(100);
 12 |         Assert.Equal("100 milliseconds", value.ToWords());
 13 | 
 14 |         value = TimeSpan.FromMilliseconds(-100);
 15 |         Assert.Equal("-100 milliseconds", value.ToWords());
 16 | 
 17 |         value = TimeSpan.FromMilliseconds(100);
 18 |         Assert.Equal("100ms", value.ToWords(true));
 19 | 
 20 |         value = TimeSpan.FromMilliseconds(2500);
 21 |         Assert.Equal("2.5 seconds", value.ToWords());
 22 | 
 23 |         value = TimeSpan.FromMilliseconds(2500);
 24 |         Assert.Equal("2.5s", value.ToWords(true));
 25 | 
 26 |         value = TimeSpan.FromMilliseconds(16500);
 27 |         Assert.Equal("16 seconds", value.ToWords());
 28 | 
 29 |         value = TimeSpan.FromMilliseconds(16500);
 30 |         Assert.Equal("16s", value.ToWords(true));
 31 | 
 32 |         value = TimeSpan.FromHours(6);
 33 |         Assert.Equal("6 hours", value.ToWords());
 34 | 
 35 |         value = TimeSpan.FromHours(-6);
 36 |         Assert.Equal("-6 hours", value.ToWords());
 37 | 
 38 |         value = TimeSpan.FromHours(6);
 39 |         Assert.Equal("6h", value.ToWords(true));
 40 | 
 41 |         value = TimeSpan.FromMinutes(186);
 42 |         Assert.Equal("3 hours 6 minutes", value.ToWords());
 43 | 
 44 |         value = TimeSpan.FromMinutes(-186);
 45 |         Assert.Equal("-3 hours 6 minutes", value.ToWords());
 46 | 
 47 |         value = TimeSpan.FromMinutes(186);
 48 |         Assert.Equal("3h 6m", value.ToWords(true));
 49 | 
 50 |         value = TimeSpan.FromDays(10.15);
 51 |         Assert.Equal("1 week 3 days", value.ToWords(false, 2));
 52 | 
 53 |         value = TimeSpan.FromDays(10.15);
 54 |         Assert.Equal("1w 3d 3h 36m", value.ToWords(true));
 55 |     }
 56 | 
 57 |     [Fact]
 58 |     public void ApproximateAge()
 59 |     {
 60 |         Assert.Equal("Just now", DateTime.Now.AddMilliseconds(-100).ToApproximateAgeString());
 61 |         Assert.Equal("Just now", DateTime.Now.AddSeconds(-50).ToApproximateAgeString());
 62 |         Assert.Equal("1 minute ago", DateTime.Now.AddSeconds(-65).ToApproximateAgeString());
 63 |         Assert.Equal("1 hour ago", DateTime.Now.AddMinutes(-61).ToApproximateAgeString());
 64 |         Assert.Equal("1 day ago", DateTime.Now.AddHours(-24).ToApproximateAgeString());
 65 |         Assert.Equal("2 days ago", DateTime.Now.AddHours(-48).ToApproximateAgeString());
 66 |         Assert.Equal("1 week ago", DateTime.Now.AddDays(-7).ToApproximateAgeString());
 67 |     }
 68 | 
 69 |     [Fact]
 70 |     public void SubtractSaturating_WithLargerValue_ReturnsNormalSubtraction()
 71 |     {
 72 |         var timeSpan1 = TimeSpan.FromHours(5);
 73 |         var timeSpan2 = TimeSpan.FromHours(2);
 74 | 
 75 |         var result = timeSpan1.SubtractSaturating(timeSpan2);
 76 | 
 77 |         Assert.Equal(TimeSpan.FromHours(3), result);
 78 |     }
 79 | 
 80 |     [Fact]
 81 |     public void SubtractSaturating_WithSmallerValue_ReturnsZero()
 82 |     {
 83 |         var timeSpan1 = TimeSpan.FromHours(2);
 84 |         var timeSpan2 = TimeSpan.FromHours(5);
 85 | 
 86 |         var result = timeSpan1.SubtractSaturating(timeSpan2);
 87 | 
 88 |         Assert.Equal(TimeSpan.Zero, result);
 89 |     }
 90 | 
 91 |     [Fact]
 92 |     public void SubtractSaturating_WithEqualValues_ReturnsZero()
 93 |     {
 94 |         var timeSpan1 = TimeSpan.FromMinutes(30);
 95 |         var timeSpan2 = TimeSpan.FromMinutes(30);
 96 | 
 97 |         var result = timeSpan1.SubtractSaturating(timeSpan2);
 98 | 
 99 |         Assert.Equal(TimeSpan.Zero, result);
100 |     }
101 | 
102 |     [Fact]
103 |     public void SubtractSaturating_WithZeroValue_ReturnsOriginalValue()
104 |     {
105 |         var timeSpan = TimeSpan.FromSeconds(10);
106 | 
107 |         var result = timeSpan.SubtractSaturating(TimeSpan.Zero);
108 | 
109 |         Assert.Equal(TimeSpan.FromSeconds(10), result);
110 |     }
111 | 
112 |     [Fact]
113 |     public void SubtractSaturating_WithZeroAsBase_ReturnsZero()
114 |     {
115 |         var result1 = TimeSpan.Zero.SubtractSaturating(TimeSpan.FromSeconds(5));
116 |         var result2 = TimeSpan.Zero.SubtractSaturating(TimeSpan.Zero);
117 | 
118 |         Assert.Equal(TimeSpan.Zero, result1);
119 |         Assert.Equal(TimeSpan.Zero, result2);
120 |     }
121 | 
122 |     [Fact]
123 |     public void SubtractSaturating_WithLargeValues_ReturnsCorrectResult()
124 |     {
125 |         var largeTimeSpan1 = TimeSpan.FromDays(100);
126 |         var largeTimeSpan2 = TimeSpan.FromDays(50);
127 | 
128 |         var result = largeTimeSpan1.SubtractSaturating(largeTimeSpan2);
129 | 
130 |         Assert.Equal(TimeSpan.FromDays(50), result);
131 |     }
132 | 
133 |     [Fact]
134 |     public void SubtractSaturating_WithNegativeBase_ReturnsZero()
135 |     {
136 |         var negativeTimeSpan = TimeSpan.FromHours(-2);
137 |         var positiveTimeSpan = TimeSpan.FromHours(1);
138 | 
139 |         var result = negativeTimeSpan.SubtractSaturating(positiveTimeSpan);
140 | 
141 |         Assert.Equal(TimeSpan.Zero, result);
142 |     }
143 | 
144 |     [Fact]
145 |     public void SubtractSaturating_WithNegativeSubtrahend_ReturnsAddedValue()
146 |     {
147 |         var timeSpan = TimeSpan.FromHours(3);
148 |         var negativeTimeSpan = TimeSpan.FromHours(-2);
149 | 
150 |         var result = timeSpan.SubtractSaturating(negativeTimeSpan);
151 | 
152 |         Assert.Equal(TimeSpan.FromHours(5), result);
153 |     }
154 | }
155 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/DateTimeRange.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.Linq;
  5 | using Exceptionless.DateTimeExtensions.FormatParsers;
  6 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
  7 | 
  8 | namespace Exceptionless.DateTimeExtensions;
  9 | 
 10 | [DebuggerDisplay("{Start} {DefaultSeparator} {End}")]
 11 | public class DateTimeRange : IEquatable<DateTimeRange>, IComparable<DateTimeRange>
 12 | {
 13 |     public static readonly DateTimeRange Empty = new(DateTime.MinValue, DateTime.MaxValue);
 14 | 
 15 |     public const string DefaultSeparator = " - ";
 16 | 
 17 |     public DateTimeRange(DateTime start, DateTime end)
 18 |     {
 19 |         Start = start < end ? start : end;
 20 |         UtcStart = Start != DateTime.MinValue ? Start.ToUniversalTime() : Start;
 21 |         End = end > start ? end : start;
 22 |         UtcEnd = End != DateTime.MaxValue ? End.ToUniversalTime() : End;
 23 |     }
 24 | 
 25 |     public DateTimeRange(DateTimeOffset start, DateTimeOffset end)
 26 |     {
 27 |         Start = (start = start < end ? start : end).DateTime;
 28 |         UtcStart = start.UtcDateTime;
 29 |         End = (end = end > start ? end : start).DateTime;
 30 |         UtcEnd = end.UtcDateTime;
 31 |     }
 32 | 
 33 |     public DateTime Start { get; }
 34 |     public DateTime End { get; }
 35 | 
 36 |     public DateTime UtcStart { get; }
 37 |     public DateTime UtcEnd { get; }
 38 | 
 39 |     public static bool operator ==(DateTimeRange left, DateTimeRange right)
 40 |     {
 41 |         if (ReferenceEquals(left, right))
 42 |             return true;
 43 | 
 44 |         if (((object)left == null) || ((object)right == null))
 45 |             return false;
 46 | 
 47 |         return (left.Start == right.Start) && (left.End == right.End);
 48 |     }
 49 | 
 50 |     public static bool operator !=(DateTimeRange left, DateTimeRange right)
 51 |     {
 52 |         return !(left == right);
 53 |     }
 54 | 
 55 |     public override bool Equals(object obj)
 56 |     {
 57 |         if (obj == null)
 58 |             return false;
 59 | 
 60 |         var other = obj as DateTimeRange;
 61 |         if ((object)other == null)
 62 |             return false;
 63 | 
 64 |         return (Start == other.Start) && (End == other.End);
 65 |     }
 66 | 
 67 |     public bool Equals(DateTimeRange other)
 68 |     {
 69 |         if ((object)other == null)
 70 |             return false;
 71 | 
 72 |         return (Start == other.Start) && (End == other.End);
 73 |     }
 74 | 
 75 |     public override int GetHashCode()
 76 |     {
 77 |         return (Start.Ticks + End.Ticks).GetHashCode();
 78 |     }
 79 | 
 80 |     public override string ToString()
 81 |     {
 82 |         return ToString(DefaultSeparator);
 83 |     }
 84 | 
 85 |     public string ToString(string separator)
 86 |     {
 87 |         return Start + separator + End;
 88 |     }
 89 | 
 90 |     public int CompareTo(DateTimeRange other)
 91 |     {
 92 |         if (other == null)
 93 |             return 1;
 94 | 
 95 |         if (Equals(other))
 96 |             return 0;
 97 | 
 98 |         return Start.CompareTo(other.End);
 99 |     }
100 | 
101 |     public DateTimeRange Add(TimeSpan timeSpan)
102 |     {
103 |         var offset = Start - UtcStart;
104 |         return new DateTimeRange(new DateTimeOffset(Start.SafeAdd(timeSpan), offset), new DateTimeOffset(End.SafeAdd(timeSpan), offset));
105 |     }
106 | 
107 |     public DateTimeRange Subtract(TimeSpan timeSpan)
108 |     {
109 |         var offset = Start - UtcStart;
110 |         return new DateTimeRange(new DateTimeOffset(Start.SafeSubtract(timeSpan), offset), new DateTimeOffset(End.SafeSubtract(timeSpan), offset));
111 |     }
112 | 
113 |     public bool Intersects(DateTimeRange other)
114 |     {
115 |         return Contains(other.UtcStart) || Contains(other.UtcEnd);
116 |     }
117 | 
118 |     public DateTimeRange Intersection(DateTimeRange other)
119 |     {
120 |         var greatestStart = Start > other.Start ? Start : other.Start;
121 |         var smallestEnd = End < other.End ? End : other.End;
122 | 
123 |         if (greatestStart > smallestEnd)
124 |             return null;
125 | 
126 |         return new DateTimeRange(greatestStart, smallestEnd);
127 |     }
128 | 
129 |     public bool Contains(DateTime time)
130 |     {
131 |         if (time.Kind == DateTimeKind.Utc)
132 |             return time >= UtcStart && time <= UtcEnd;
133 | 
134 |         return time >= Start && time <= End;
135 |     }
136 | 
137 |     private static List<IFormatParser> _formatParsers;
138 | 
139 |     public static List<IFormatParser> FormatParsers
140 |     {
141 |         get
142 |         {
143 |             if (_formatParsers == null)
144 |             {
145 |                 var formatParserTypes = TypeHelper.GetDerivedTypes<IFormatParser>().SortByPriority();
146 |                 _formatParsers = new List<IFormatParser>(formatParserTypes.Select(t => Activator.CreateInstance(t) as IFormatParser));
147 |             }
148 | 
149 |             return _formatParsers;
150 |         }
151 |     }
152 | 
153 |     private static List<IPartParser> _partParsers;
154 | 
155 |     public static List<IPartParser> PartParsers
156 |     {
157 |         get
158 |         {
159 |             if (_partParsers == null)
160 |             {
161 |                 var partParserTypes = TypeHelper.GetDerivedTypes<IPartParser>().SortByPriority();
162 |                 _partParsers = new List<IPartParser>(partParserTypes.Select(t => Activator.CreateInstance(t) as IPartParser));
163 |             }
164 | 
165 |             return _partParsers;
166 |         }
167 |     }
168 | 
169 |     /// <summary>
170 |     /// Parses the date range from the passed in content.
171 |     /// </summary>
172 |     /// <param name="content">String date range</param>
173 |     public static DateTimeRange Parse(string content)
174 |     {
175 |         return Parse(content, DateTimeOffset.Now);
176 |     }
177 | 
178 |     /// <summary>
179 |     /// Parses the date range from the passed in content.
180 |     /// </summary>
181 |     /// <param name="content">String date range</param>
182 |     /// <param name="relativeBaseTime">Relative dates will be base on this time.</param>
183 |     public static DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
184 |     {
185 |         if (String.IsNullOrEmpty(content))
186 |             return Empty;
187 | 
188 |         foreach (var parser in FormatParsers)
189 |         {
190 |             var range = parser.Parse(content, relativeBaseTime);
191 |             if (range != null)
192 |                 return range;
193 |         }
194 | 
195 |         return Empty;
196 |     }
197 | }
198 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/TimeUnitTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using Xunit;
  4 | 
  5 | namespace Exceptionless.DateTimeExtensions.Tests;
  6 | 
  7 | public class TimeUnitTests
  8 | {
  9 |     public static IEnumerable<object[]> TestData =>
 10 |     [
 11 |         ["1000 nanos", new TimeSpan(10)],
 12 |         ["1000nanos", new TimeSpan(10)],
 13 |         ["1000 NANOS", new TimeSpan(10)],
 14 |         ["1000NANOS", new TimeSpan(10)],
 15 |         ["10micros", new TimeSpan(100)],
 16 |         ["10ms", new TimeSpan(0, 0, 0, 0, 10)],
 17 |         ["10s", new TimeSpan(0, 0, 10)],
 18 |         ["-10s", new TimeSpan(0, 0, -10)],
 19 |         ["10m", new TimeSpan(0, 10, 0)],
 20 |         ["10h", new TimeSpan(10, 0, 0)],
 21 |         ["10d", new TimeSpan(10, 0, 0, 0)],
 22 |         ["1w", new TimeSpan(7, 0, 0, 0)],
 23 |         ["2w", new TimeSpan(14, 0, 0, 0)],
 24 |         ["-1w", new TimeSpan(-7, 0, 0, 0)],
 25 |         ["1M", new TimeSpan((int)TimeSpanExtensions.AvgDaysInAMonth, 0, 0, 0)],
 26 |         ["2M", new TimeSpan((int)(2 * TimeSpanExtensions.AvgDaysInAMonth), 0, 0, 0)],
 27 |         ["-1M", new TimeSpan((int)(-1 * TimeSpanExtensions.AvgDaysInAMonth), 0, 0, 0)],
 28 |         ["1y", new TimeSpan((int)TimeSpanExtensions.AvgDaysInAYear, 0, 0, 0)],
 29 |         ["2y", new TimeSpan((int)(2 * TimeSpanExtensions.AvgDaysInAYear), 0, 0, 0)],
 30 |         ["-1y", new TimeSpan((int)(-1 * TimeSpanExtensions.AvgDaysInAYear), 0, 0, 0)],
 31 |         // Whitespace trimming tests
 32 |         [" 1y ", new TimeSpan((int)TimeSpanExtensions.AvgDaysInAYear, 0, 0, 0)],
 33 |         ["  2M  ", new TimeSpan((int)(2 * TimeSpanExtensions.AvgDaysInAMonth), 0, 0, 0)],
 34 |         ["\t3w\t", new TimeSpan(21, 0, 0, 0)],
 35 |         [" -1y ", new TimeSpan((int)(-1 * TimeSpanExtensions.AvgDaysInAYear), 0, 0, 0)]
 36 |     ];
 37 | 
 38 |     [Theory]
 39 |     [MemberData(nameof(TestData))]
 40 |     public void Parse_ValidInput_ReturnsExpectedTimeSpan(string value, TimeSpan expected)
 41 |     {
 42 |         Assert.Equal(expected, TimeUnit.Parse(value));
 43 |     }
 44 | 
 45 |     [Theory]
 46 |     [InlineData(null)]
 47 |     [InlineData("1.234h")] // fractional time
 48 |     [InlineData("1234")] // missing unit
 49 |     [InlineData("12unknownunit")]
 50 |     [InlineData("12h.")]
 51 |     [InlineData("")] // empty string
 52 |     [InlineData("   ")] // whitespace only
 53 |     [InlineData("\t\t")] // tabs only
 54 |     [InlineData("1y@")] // special character after unit
 55 |     [InlineData("1M!")] // special character after unit
 56 |     [InlineData("1w#")] // special character after unit
 57 |     [InlineData("1@y")] // special character in middle
 58 |     public void Parse_InvalidInput_ThrowsException(string value)
 59 |     {
 60 |         Assert.ThrowsAny<Exception>(() => TimeUnit.Parse(value));
 61 |     }
 62 | 
 63 |     [Theory]
 64 |     [InlineData("1000 nanos", true)]
 65 |     [InlineData("1000nanos", true)]
 66 |     [InlineData("1000 NANOS", true)]
 67 |     [InlineData("1000NANOS", true)]
 68 |     [InlineData("10micros", true)]
 69 |     [InlineData("10ms", true)]
 70 |     [InlineData("10s", true)]
 71 |     [InlineData("-10s", true)]
 72 |     [InlineData("10m", true)]
 73 |     [InlineData("10h", true)]
 74 |     [InlineData("10d", true)]
 75 |     [InlineData("1w", true)]
 76 |     [InlineData("2w", true)]
 77 |     [InlineData("-1w", true)]
 78 |     [InlineData("1M", true)]
 79 |     [InlineData("2M", true)]
 80 |     [InlineData("-1M", true)]
 81 |     [InlineData("1y", true)]
 82 |     [InlineData("2y", true)]
 83 |     [InlineData("-1y", true)]
 84 |     // Whitespace tests
 85 |     [InlineData(" 1y ", true)]
 86 |     [InlineData("  2M  ", true)]
 87 |     [InlineData("\t3w\t", true)]
 88 |     [InlineData(" -1M ", true)]
 89 |     // Special character and edge case tests
 90 |     [InlineData("", false)]
 91 |     [InlineData("   ", false)]
 92 |     [InlineData("\t\t", false)]
 93 |     [InlineData("1y@", false)]
 94 |     [InlineData("1M!", false)]
 95 |     [InlineData("1w#", false)]
 96 |     [InlineData("1@y", false)]
 97 |     [InlineData(null, false)]
 98 |     [InlineData("1.234h", false)] // fractional time
 99 |     [InlineData("1234", false)] // missing unit
100 |     [InlineData("12unknownunit", false)]
101 |     [InlineData("12h.", false)]
102 |     [InlineData("Blah/Blahs", false)]
103 |     public void TryParse_VariousInputs_ReturnsExpectedResult(string value, bool expected)
104 |     {
105 |         bool success = TimeUnit.TryParse(value, out var result);
106 |         Assert.Equal(expected, success);
107 |     }
108 | 
109 |     [Fact]
110 |     public void Parse_UppercaseM_ParsesAsMonths()
111 |     {
112 |         // Arrange
113 |         var input = "1M";
114 |         var expectedDays = (int)TimeSpanExtensions.AvgDaysInAMonth;
115 |         var expected = new TimeSpan(expectedDays, 0, 0, 0);
116 | 
117 |         // Act
118 |         var result = TimeUnit.Parse(input);
119 | 
120 |         // Assert
121 |         Assert.Equal(expected, result);
122 |     }
123 | 
124 |     [Fact]
125 |     public void Parse_LowercaseM_ParsesAsMinutes()
126 |     {
127 |         // Arrange
128 |         var input = "1m";
129 |         var expected = new TimeSpan(0, 1, 0);
130 | 
131 |         // Act
132 |         var result = TimeUnit.Parse(input);
133 | 
134 |         // Assert
135 |         Assert.Equal(expected, result);
136 |     }
137 | 
138 |     [Fact]
139 |     public void Parse_MonthsAndMinutes_ProduceDifferentResults()
140 |     {
141 |         // Act
142 |         var monthResult = TimeUnit.Parse("1M");
143 |         var minuteResult = TimeUnit.Parse("1m");
144 | 
145 |         // Assert
146 |         Assert.NotEqual(monthResult, minuteResult);
147 |     }
148 | 
149 |     [Theory]
150 |     [InlineData("1y")]
151 |     [InlineData("2y")]
152 |     [InlineData("-1y")]
153 |     public void Parse_YearUnit_ReturnsExpectedDays(string input)
154 |     {
155 |         // Act
156 |         var result = TimeUnit.Parse(input);
157 |         var expectedDays = int.Parse(input.Substring(0, input.Length - 1)) * TimeSpanExtensions.AvgDaysInAYear;
158 | 
159 |         // Assert
160 |         Assert.True(Math.Abs(result.TotalDays - expectedDays) < 1,
161 |             $"Year conversion should be close to {expectedDays} days, got {result.TotalDays}");
162 |     }
163 | 
164 |     [Theory]
165 |     [InlineData("1M")]
166 |     [InlineData("3M")]
167 |     [InlineData("-1M")]
168 |     public void Parse_MonthUnit_ReturnsExpectedDays(string input)
169 |     {
170 |         // Act
171 |         var result = TimeUnit.Parse(input);
172 |         var expectedDays = int.Parse(input.Substring(0, input.Length - 1)) * TimeSpanExtensions.AvgDaysInAMonth;
173 | 
174 |         // Assert
175 |         Assert.True(Math.Abs(result.TotalDays - expectedDays) < 1,
176 |             $"Month conversion should be close to {expectedDays} days, got {result.TotalDays}");
177 |     }
178 | 
179 |     [Theory]
180 |     [InlineData("1w", 7)]
181 |     [InlineData("2w", 14)]
182 |     [InlineData("4w", 28)]
183 |     [InlineData("-1w", -7)]
184 |     public void Parse_WeekUnit_ReturnsExpectedDays(string input, int expectedDays)
185 |     {
186 |         // Act
187 |         var result = TimeUnit.Parse(input);
188 | 
189 |         // Assert
190 |         Assert.Equal(expectedDays, result.TotalDays);
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/BusinessDayTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Diagnostics;
  3 | using Xunit;
  4 | 
  5 | namespace Exceptionless.DateTimeExtensions.Tests;
  6 | 
  7 | public class BusinessDayTests
  8 | {
  9 |     [Fact]
 10 |     public void BusinessHours()
 11 |     {
 12 |         var date = DateTime.Now.StartOfDay().AddHours(8);
 13 | 
 14 |         var day = new BusinessDay(date.Date.DayOfWeek, date.Subtract(TimeSpan.FromHours(1)).TimeOfDay, date.AddHours(1).TimeOfDay);
 15 | 
 16 |         bool isDay = day.IsBusinessDay(date);
 17 |         Assert.True(isDay);
 18 | 
 19 |         // day of week test
 20 |         isDay = day.IsBusinessDay(date.AddDays(1));
 21 |         Assert.False(isDay);
 22 | 
 23 |         // to early test
 24 |         isDay = day.IsBusinessDay(date.Date);
 25 |         Assert.False(isDay);
 26 | 
 27 |         // to late test
 28 |         isDay = day.IsBusinessDay(date.AddHours(2));
 29 |         Assert.False(isDay);
 30 |     }
 31 | 
 32 |     [Fact]
 33 |     public void TotalBusinessHours()
 34 |     {
 35 |         var startDate = new DateTime(2010, 1, 1);
 36 |         var endDate = new DateTime(2010, 1, 2);
 37 |         var businessWeek = BusinessWeek.DefaultWeek;
 38 | 
 39 |         var time = businessWeek.GetBusinessTime(startDate, endDate);
 40 |         // workday friday
 41 |         Assert.Equal(8, time.TotalHours);
 42 | 
 43 |         startDate = new DateTime(2010, 1, 1);
 44 |         endDate = new DateTime(2010, 1, 3);
 45 | 
 46 |         time = businessWeek.GetBusinessTime(startDate, endDate);
 47 |         // workday friday
 48 |         Assert.Equal(8, time.TotalHours);
 49 | 
 50 |         startDate = new DateTime(2010, 1, 1, 12, 0, 0);
 51 |         endDate = new DateTime(2010, 1, 1, 16, 0, 0);
 52 | 
 53 |         time = businessWeek.GetBusinessTime(startDate, endDate);
 54 |         Assert.Equal(4, time.TotalHours);
 55 | 
 56 |         startDate = new DateTime(2010, 1, 1, 6, 0, 0);
 57 |         endDate = new DateTime(2010, 1, 1, 12, 0, 0);
 58 | 
 59 |         time = businessWeek.GetBusinessTime(startDate, endDate);
 60 |         Assert.Equal(3, time.TotalHours);
 61 | 
 62 |         startDate = new DateTime(2010, 1, 3, 0, 0, 0);
 63 |         endDate = new DateTime(2010, 1, 10, 0, 0, 0);
 64 | 
 65 |         time = businessWeek.GetBusinessTime(startDate, endDate);
 66 |         Assert.Equal(40, time.TotalHours);
 67 |     }
 68 | 
 69 |     [Fact]
 70 |     public void NextBusinessDay()
 71 |     {
 72 |         var businessWeek = BusinessWeek.DefaultWeek;
 73 | 
 74 |         bool result = businessWeek.NextBusinessDay(new DateTime(2010, 1, 1, 2, 0, 0), out var resultDate, out var businessDay);
 75 |         Assert.True(result);
 76 |         Assert.Equal(new DateTime(2010, 1, 1, 9, 0, 0), resultDate);
 77 |         Assert.NotNull(businessDay);
 78 |         Assert.Equal(DayOfWeek.Friday, businessDay.DayOfWeek);
 79 | 
 80 |         result = businessWeek.NextBusinessDay(new DateTime(2010, 1, 1, 11, 0, 0), out resultDate, out businessDay);
 81 |         Assert.True(result);
 82 |         Assert.Equal(new DateTime(2010, 1, 1, 11, 0, 0), resultDate);
 83 |         Assert.NotNull(businessDay);
 84 |         Assert.Equal(DayOfWeek.Friday, businessDay.DayOfWeek);
 85 | 
 86 |         result = businessWeek.NextBusinessDay(new DateTime(2010, 1, 2, 11, 0, 0), out resultDate, out businessDay);
 87 |         Assert.True(result);
 88 |         Assert.Equal(new DateTime(2010, 1, 4, 9, 0, 0), resultDate);
 89 |         Assert.NotNull(businessDay);
 90 |         Assert.Equal(DayOfWeek.Monday, businessDay.DayOfWeek);
 91 | 
 92 |     }
 93 | 
 94 |     [Fact]
 95 |     public void GetBusinessTime()
 96 |     {
 97 |         var startDate = new DateTime(2010, 1, 4, 9, 31, 30);
 98 |         var endDate = new DateTime(2010, 1, 6, 13, 14, 16);
 99 |         var businessWeek = BusinessWeek.DefaultWeek;
100 | 
101 |         var watch = Stopwatch.StartNew();
102 |         var time = businessWeek.GetBusinessTime(startDate, endDate);
103 |         watch.Stop();
104 | 
105 |         Console.WriteLine("Business Time: {0}", time);
106 |         Console.WriteLine("Time: {0} ms", watch.ElapsedMilliseconds);
107 |         Assert.Equal(new TimeSpan(19, 42, 46), time);
108 | 
109 |         startDate = new DateTime(2010, 1, 4, 9, 31, 30);
110 |         endDate = new DateTime(2010, 1, 30, 13, 14, 16);
111 | 
112 |         watch.Reset();
113 |         watch.Start();
114 |         time = businessWeek.GetBusinessTime(startDate, endDate);
115 |         watch.Stop();
116 | 
117 |         Console.WriteLine("Business Time: {0}", time);
118 |         Console.WriteLine("Time: {0} ms", watch.ElapsedMilliseconds);
119 |         Assert.Equal(new TimeSpan(6, 15, 28, 30), time);
120 | 
121 |         startDate = new DateTime(2010, 1, 4, 9, 31, 30);
122 |         endDate = new DateTime(2010, 6, 30, 13, 14, 16);
123 | 
124 |         watch.Reset();
125 |         watch.Start();
126 |         time = businessWeek.GetBusinessTime(startDate, endDate);
127 |         watch.Stop();
128 | 
129 |         Console.WriteLine("Business Time: {0}", time);
130 |         Console.WriteLine("Time: {0} ms", watch.ElapsedMilliseconds);
131 |         Assert.Equal(new TimeSpan(42, 11, 42, 46), time);
132 |     }
133 | 
134 |     [Fact]
135 |     public void GetBusinessDate()
136 |     {
137 |         var startDate = new DateTime(2010, 1, 1);
138 |         var endDate = new DateTime(2010, 1, 4, 11, 0, 0);
139 |         var businessWeek = BusinessWeek.DefaultWeek;
140 | 
141 |         var watch = Stopwatch.StartNew();
142 |         var resultDate = businessWeek.GetBusinessEndDate(startDate, TimeSpan.FromHours(10));
143 |         watch.Stop();
144 |         Console.WriteLine("Business Date: {0}", resultDate);
145 |         Console.WriteLine("Time: {0} ms", watch.ElapsedMilliseconds);
146 | 
147 |         Assert.Equal(endDate, resultDate);
148 | 
149 |         startDate = new DateTime(2010, 1, 4, 9, 31, 30);
150 | 
151 |         watch.Reset();
152 |         watch.Start();
153 |         resultDate = businessWeek.GetBusinessEndDate(startDate, new TimeSpan(60, 10, 15, 28));
154 |         watch.Stop();
155 | 
156 |         Console.WriteLine("Business Date: {0}", resultDate);
157 |         Console.WriteLine("Time: {0} ms", watch.ElapsedMilliseconds);
158 |     }
159 | 
160 |     [Fact]
161 |     public void ThridShift()
162 |     {
163 |         var businessWeek = new BusinessWeek();
164 |         //day 1
165 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Sunday, TimeSpan.FromHours(22), TimeSpan.FromHours(24)));
166 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Monday, TimeSpan.Zero, TimeSpan.FromHours(6)));
167 |         //day 2
168 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Monday, TimeSpan.FromHours(22), TimeSpan.FromHours(24)));
169 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Tuesday, TimeSpan.Zero, TimeSpan.FromHours(6)));
170 |         //day 3
171 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Tuesday, TimeSpan.FromHours(22), TimeSpan.FromHours(24)));
172 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Wednesday, TimeSpan.Zero, TimeSpan.FromHours(6)));
173 |         //day 4
174 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Wednesday, TimeSpan.FromHours(22), TimeSpan.FromHours(24)));
175 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Thursday, TimeSpan.Zero, TimeSpan.FromHours(6)));
176 |         //day 5
177 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Thursday, TimeSpan.FromHours(22), TimeSpan.FromHours(24)));
178 |         businessWeek.BusinessDays.Add(new BusinessDay(DayOfWeek.Friday, TimeSpan.Zero, TimeSpan.FromHours(6)));
179 | 
180 | 
181 |         var startDate = new DateTime(2010, 1, 3, 22, 0, 0);
182 |         var endDate = new DateTime(2010, 1, 4, 6, 0, 0);
183 | 
184 |         var time = businessWeek.GetBusinessTime(startDate, endDate);
185 | 
186 |         Assert.Equal(8, time.TotalHours);
187 | 
188 |         startDate = new DateTime(2010, 1, 2, 0, 0, 0);
189 |         endDate = new DateTime(2010, 1, 9, 0, 0, 0);
190 | 
191 |         time = businessWeek.GetBusinessTime(startDate, endDate);
192 | 
193 |         Assert.Equal(40, time.TotalHours);
194 |     }
195 | }
196 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
  1 | # editorconfig.org (https://github.com/dotnet/runtime/blob/main/.editorconfig)
  2 | 
  3 | # top-most EditorConfig file
  4 | root = true
  5 | 
  6 | # Default settings:
  7 | # A newline ending every file
  8 | # Use 4 spaces as indentation
  9 | [*]
 10 | insert_final_newline = true
 11 | indent_style = space
 12 | indent_size = 4
 13 | trim_trailing_whitespace = true
 14 | 
 15 | [*.json]
 16 | insert_final_newline = false
 17 | 
 18 | # Generated code
 19 | [*{_AssemblyInfo.cs,.notsupported.cs,AsmOffsets.cs}]
 20 | generated_code = true
 21 | 
 22 | # C# files
 23 | [*.cs]
 24 | # New line preferences
 25 | csharp_new_line_before_open_brace = all
 26 | csharp_new_line_before_else = true
 27 | csharp_new_line_before_catch = true
 28 | csharp_new_line_before_finally = true
 29 | csharp_new_line_before_members_in_object_initializers = true
 30 | csharp_new_line_before_members_in_anonymous_types = true
 31 | csharp_new_line_between_query_expression_clauses = true
 32 | 
 33 | # Indentation preferences
 34 | csharp_indent_block_contents = true
 35 | csharp_indent_braces = false
 36 | csharp_indent_case_contents = true
 37 | csharp_indent_case_contents_when_block = true
 38 | csharp_indent_switch_labels = true
 39 | csharp_indent_labels = one_less_than_current
 40 | 
 41 | # Modifier preferences
 42 | csharp_preferred_modifier_order = public,private,protected,internal,file,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,required,volatile,async:suggestion
 43 | 
 44 | # avoid this. unless absolutely necessary
 45 | dotnet_style_qualification_for_field = false:error
 46 | dotnet_style_qualification_for_property = false:error
 47 | dotnet_style_qualification_for_method = false:error
 48 | dotnet_style_qualification_for_event = false:error
 49 | 
 50 | # Types: use keywords instead of BCL types, and permit var only when the type is clear
 51 | csharp_style_var_for_built_in_types = false:suggestion
 52 | csharp_style_var_when_type_is_apparent = false:none
 53 | csharp_style_var_elsewhere = true:suggestion
 54 | dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
 55 | dotnet_style_predefined_type_for_member_access = false:suggestion
 56 | 
 57 | # name all constant fields using PascalCase
 58 | dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion
 59 | dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols  = constant_fields
 60 | dotnet_naming_rule.constant_fields_should_be_pascal_case.style    = pascal_case_style
 61 | dotnet_naming_symbols.constant_fields.applicable_kinds   = field
 62 | dotnet_naming_symbols.constant_fields.required_modifiers = const
 63 | dotnet_naming_style.pascal_case_style.capitalization = pascal_case
 64 | 
 65 | # static fields should have s_ prefix
 66 | dotnet_naming_rule.static_fields_should_have_prefix.severity = false:none
 67 | dotnet_naming_rule.static_fields_should_have_prefix.symbols  = static_fields
 68 | dotnet_naming_rule.static_fields_should_have_prefix.style    = static_prefix_style
 69 | dotnet_naming_symbols.static_fields.applicable_kinds   = field
 70 | dotnet_naming_symbols.static_fields.required_modifiers = static
 71 | dotnet_naming_symbols.static_fields.applicable_accessibilities = private, internal, private_protected
 72 | dotnet_naming_style.static_prefix_style.required_prefix = s_
 73 | dotnet_naming_style.static_prefix_style.capitalization = camel_case
 74 | 
 75 | # internal and private fields should be _camelCase
 76 | dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion
 77 | dotnet_naming_rule.camel_case_for_private_internal_fields.symbols  = private_internal_fields
 78 | dotnet_naming_rule.camel_case_for_private_internal_fields.style    = camel_case_underscore_style
 79 | dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
 80 | dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
 81 | dotnet_naming_style.camel_case_underscore_style.required_prefix = _
 82 | dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case
 83 | 
 84 | # Code style defaults
 85 | csharp_using_directive_placement = outside_namespace:suggestion
 86 | dotnet_sort_system_directives_first = true
 87 | csharp_prefer_braces = true:silent
 88 | csharp_preserve_single_line_blocks = true:none
 89 | csharp_preserve_single_line_statements = false:none
 90 | csharp_prefer_static_local_function = true:suggestion
 91 | csharp_prefer_simple_using_statement = false:none
 92 | csharp_style_prefer_switch_expression = true:suggestion
 93 | dotnet_style_readonly_field = true:suggestion
 94 | 
 95 | # Expression-level preferences
 96 | dotnet_style_object_initializer = true:suggestion
 97 | dotnet_style_collection_initializer = true:suggestion
 98 | dotnet_style_explicit_tuple_names = true:suggestion
 99 | dotnet_style_coalesce_expression = true:suggestion
100 | dotnet_style_null_propagation = true:suggestion
101 | dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
102 | dotnet_style_prefer_inferred_tuple_names = true:suggestion
103 | dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
104 | dotnet_style_prefer_auto_properties = true:suggestion
105 | dotnet_style_prefer_conditional_expression_over_assignment = true:silent
106 | dotnet_style_prefer_conditional_expression_over_return = true:silent
107 | csharp_prefer_simple_default_expression = true:suggestion
108 | 
109 | # Expression-bodied members
110 | csharp_style_expression_bodied_methods = true:silent
111 | csharp_style_expression_bodied_constructors = true:silent
112 | csharp_style_expression_bodied_operators = true:silent
113 | csharp_style_expression_bodied_properties = true:silent
114 | csharp_style_expression_bodied_indexers = true:silent
115 | csharp_style_expression_bodied_accessors = true:silent
116 | csharp_style_expression_bodied_lambdas = true:silent
117 | csharp_style_expression_bodied_local_functions = true:silent
118 | 
119 | # Pattern matching
120 | csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
121 | csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
122 | csharp_style_inlined_variable_declaration = true:suggestion
123 | 
124 | # Null checking preferences
125 | csharp_style_throw_expression = true:suggestion
126 | csharp_style_conditional_delegate_call = true:suggestion
127 | 
128 | # Other features
129 | csharp_style_prefer_index_operator = false:none
130 | csharp_style_prefer_range_operator = false:none
131 | csharp_style_pattern_local_over_anonymous_function = false:none
132 | 
133 | # Space preferences
134 | csharp_space_after_cast = false
135 | csharp_space_after_colon_in_inheritance_clause = true
136 | csharp_space_after_comma = true
137 | csharp_space_after_dot = false
138 | csharp_space_after_keywords_in_control_flow_statements = true
139 | csharp_space_after_semicolon_in_for_statement = true
140 | csharp_space_around_binary_operators = before_and_after
141 | csharp_space_around_declaration_statements = do_not_ignore
142 | csharp_space_before_colon_in_inheritance_clause = true
143 | csharp_space_before_comma = false
144 | csharp_space_before_dot = false
145 | csharp_space_before_open_square_brackets = false
146 | csharp_space_before_semicolon_in_for_statement = false
147 | csharp_space_between_empty_square_brackets = false
148 | csharp_space_between_method_call_empty_parameter_list_parentheses = false
149 | csharp_space_between_method_call_name_and_opening_parenthesis = false
150 | csharp_space_between_method_call_parameter_list_parentheses = false
151 | csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
152 | csharp_space_between_method_declaration_name_and_open_parenthesis = false
153 | csharp_space_between_method_declaration_parameter_list_parentheses = false
154 | csharp_space_between_parentheses = false
155 | csharp_space_between_square_brackets = false
156 | 
157 | # Custom
158 | csharp_style_namespace_declarations = file_scoped:error
159 | dotnet_diagnostic.IDE0005.severity = error # Using directive is unnecessary.
160 | 
161 | # C++ Files
162 | [*.{cpp,h,in}]
163 | curly_bracket_next_line = true
164 | indent_brace_style = Allman
165 | 
166 | # Xml project files
167 | [*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,nativeproj,locproj}]
168 | indent_size = 2
169 | 
170 | [*.{csproj,vbproj,proj,nativeproj,locproj}]
171 | charset = utf-8
172 | 
173 | # Xml build files
174 | [*.builds]
175 | indent_size = 2
176 | 
177 | # Xml files
178 | [*.{xml,stylecop,resx,ruleset}]
179 | indent_size = 2
180 | 
181 | # Xml config files
182 | [*.{props,targets,config,nuspec}]
183 | indent_size = 2
184 | 
185 | # YAML config files
186 | [*.{yml,yaml}]
187 | indent_size = 2
188 | 
189 | # Shell scripts
190 | [*.sh]
191 | end_of_line = lf
192 | [*.{cmd,bat}]
193 | end_of_line = crlf
194 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/TimeSpanExtensions.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Text;
  3 | 
  4 | namespace Exceptionless.DateTimeExtensions;
  5 | 
  6 | public static class TimeSpanExtensions
  7 | {
  8 |     public const double AvgDaysInAYear = 365.2425d;
  9 |     public const double AvgDaysInAMonth = 30.436875d;
 10 | 
 11 |     public static int GetYears(this TimeSpan timespan)
 12 |     {
 13 |         return (int)(timespan.TotalDays / AvgDaysInAYear);
 14 |     }
 15 | 
 16 |     public static double GetTotalYears(this TimeSpan timespan)
 17 |     {
 18 |         return timespan.TotalDays / AvgDaysInAYear;
 19 |     }
 20 | 
 21 |     public static int GetMonths(this TimeSpan timespan)
 22 |     {
 23 |         return (int)((timespan.TotalDays % AvgDaysInAYear) / AvgDaysInAMonth);
 24 |     }
 25 | 
 26 |     public static double GetTotalMonths(this TimeSpan timespan)
 27 |     {
 28 |         return timespan.TotalDays / AvgDaysInAMonth;
 29 |     }
 30 | 
 31 |     public static int GetWeeks(this TimeSpan timespan)
 32 |     {
 33 |         return (int)(((timespan.TotalDays % AvgDaysInAYear) % AvgDaysInAMonth) / 7d);
 34 |     }
 35 | 
 36 |     public static double GetTotalWeeks(this TimeSpan timespan)
 37 |     {
 38 |         return timespan.TotalDays / 7d;
 39 |     }
 40 | 
 41 |     public static int GetDays(this TimeSpan timespan)
 42 |     {
 43 |         return (int)(timespan.TotalDays % 7d);
 44 |     }
 45 | 
 46 |     public static double GetMicroseconds(this TimeSpan span)
 47 |     {
 48 |         return span.Ticks / 10d;
 49 |     }
 50 | 
 51 |     public static double GetNanoseconds(this TimeSpan span)
 52 |     {
 53 |         return span.Ticks / 100d;
 54 |     }
 55 | 
 56 |     public static TimeSpan Round(this TimeSpan time, TimeSpan roundingInterval, MidpointRounding roundingType = MidpointRounding.ToEven)
 57 |     {
 58 |         return new TimeSpan(Convert.ToInt64(Math.Round(time.Ticks / (double)roundingInterval.Ticks, roundingType)) * roundingInterval.Ticks);
 59 |     }
 60 | 
 61 |     public static TimeSpan Floor(this TimeSpan time, TimeSpan roundingInterval)
 62 |     {
 63 |         return new TimeSpan(Convert.ToInt64(Math.Floor(time.Ticks / (double)roundingInterval.Ticks)) * roundingInterval.Ticks);
 64 |     }
 65 | 
 66 |     public static TimeSpan Ceiling(this TimeSpan time, TimeSpan roundingInterval)
 67 |     {
 68 |         return new TimeSpan(Convert.ToInt64(Math.Ceiling(time.Ticks / (double)roundingInterval.Ticks)) * roundingInterval.Ticks);
 69 |     }
 70 | 
 71 |     public static string ToWords(this TimeSpan span)
 72 |     {
 73 |         return ToWords(span, false, -1);
 74 |     }
 75 | 
 76 |     public static string ToWords(this TimeSpan span, bool shortForm)
 77 |     {
 78 |         return ToWords(span, shortForm, -1);
 79 |     }
 80 | 
 81 |     public static string ToWords(this TimeSpan span, bool shortForm, int maxParts)
 82 |     {
 83 |         var age = new AgeSpan(span);
 84 |         return age.ToString(maxParts, shortForm);
 85 |     }
 86 | 
 87 |     public static AgeSpan ToAgeSpan(this TimeSpan span)
 88 |     {
 89 |         return new AgeSpan(span);
 90 |     }
 91 | 
 92 |     /// <summary>
 93 |     /// Subtracts the specified TimeSpan from this TimeSpan, ensuring the result never goes below TimeSpan.Zero.
 94 |     /// </summary>
 95 |     /// <param name="self">The TimeSpan to subtract from.</param>
 96 |     /// <param name="other">The TimeSpan to subtract.</param>
 97 |     /// <returns>The result of the subtraction, or TimeSpan.Zero if the result would be negative.</returns>
 98 |     public static TimeSpan SubtractSaturating(this TimeSpan self, TimeSpan other)
 99 |     {
100 |         return self >= other ? self.Subtract(other) : TimeSpan.Zero;
101 |     }
102 | }
103 | 
104 | public struct AgeSpan
105 | {
106 |     public AgeSpan(TimeSpan span) : this()
107 |     {
108 |         TotalYears = span.GetTotalYears();
109 |         Years = span.GetYears();
110 |         TotalMonths = span.GetTotalMonths();
111 |         Months = span.GetMonths();
112 |         TotalWeeks = span.GetTotalWeeks();
113 |         Weeks = span.GetWeeks();
114 |         Days = span.GetDays();
115 |         TimeSpan = span;
116 |     }
117 | 
118 |     public double TotalYears { get; private set; }
119 |     public int Years { get; private set; }
120 |     public double TotalMonths { get; private set; }
121 |     public int Months { get; private set; }
122 |     public double TotalWeeks { get; private set; }
123 |     public int Weeks { get; private set; }
124 |     public double TotalDays => TimeSpan.TotalDays;
125 |     public int Days { get; private set; }
126 |     public double TotalHours => TimeSpan.TotalHours;
127 |     public int Hours => TimeSpan.Hours;
128 |     public double TotalMinutes => TimeSpan.TotalMinutes;
129 |     public int Minutes => TimeSpan.Minutes;
130 |     public double TotalSeconds => TimeSpan.TotalSeconds;
131 |     public int Seconds => TimeSpan.Seconds;
132 |     public double TotalMilliseconds => TimeSpan.TotalMilliseconds;
133 |     public int Milliseconds => TimeSpan.Milliseconds;
134 |     public TimeSpan TimeSpan { get; private set; }
135 | 
136 |     public override string ToString()
137 |     {
138 |         return ToString(Int32.MaxValue, false);
139 |     }
140 | 
141 |     public string ToString(int maxParts, bool shortForm = false, bool includeMilliseconds = false)
142 |     {
143 |         int partCount = 0;
144 |         if (maxParts <= 0)
145 |             maxParts = Int32.MaxValue;
146 |         var sb = new StringBuilder();
147 | 
148 |         if (AppendPart(sb, "year", Years, shortForm, ref partCount))
149 |             if (maxParts > 0 && partCount >= maxParts)
150 |                 return sb.ToString();
151 | 
152 |         if (AppendPart(sb, "month", Months, shortForm, ref partCount))
153 |             if (maxParts > 0 && partCount >= maxParts)
154 |                 return sb.ToString();
155 | 
156 |         if (AppendPart(sb, "week", Weeks, shortForm, ref partCount))
157 |             if (maxParts > 0 && partCount >= maxParts)
158 |                 return sb.ToString();
159 | 
160 |         if (AppendPart(sb, "day", Days, shortForm, ref partCount))
161 |             if (maxParts > 0 && partCount >= maxParts)
162 |                 return sb.ToString();
163 | 
164 |         if (AppendPart(sb, "hour", Hours, shortForm, ref partCount))
165 |             if (maxParts > 0 && partCount >= maxParts)
166 |                 return sb.ToString();
167 | 
168 |         if (AppendPart(sb, "minute", Minutes, shortForm, ref partCount))
169 |             if (maxParts > 0 && partCount >= maxParts)
170 |                 return sb.ToString();
171 | 
172 |         double seconds = includeMilliseconds || Math.Abs(TotalMinutes) > 1d ? Seconds : Math.Round(TotalSeconds, 2);
173 |         if (seconds > 10)
174 |             seconds = Math.Round(seconds);
175 | 
176 |         if (Math.Abs(TotalSeconds) > 2)
177 |         {
178 |             if (AppendPart(sb, "second", seconds, shortForm, ref partCount))
179 |                 if (maxParts > 0 && partCount >= maxParts)
180 |                     return sb.ToString();
181 | 
182 |             if (includeMilliseconds && AppendPart(sb, "millisecond", Milliseconds, shortForm, ref partCount))
183 |                 if (maxParts > 0 && partCount >= maxParts)
184 |                     return sb.ToString();
185 |         }
186 |         else
187 |         {
188 |             if (AppendPart(sb, "millisecond", TotalMilliseconds, shortForm, ref partCount))
189 |                 if (maxParts > 0 && partCount >= maxParts)
190 |                     return sb.ToString();
191 |         }
192 | 
193 |         return sb.ToString();
194 |     }
195 | 
196 |     private static bool AppendPart(StringBuilder builder, string partName, double partValue, bool shortForm, ref int partCount)
197 |     {
198 |         const string spacer = " ";
199 | 
200 |         if (Math.Abs(partValue) == 0)
201 |             return false;
202 | 
203 |         if (builder.Length > 0)
204 |             builder.Append(spacer);
205 | 
206 |         string partValueString = partCount > 0 ? Math.Abs(partValue).ToString("0.##") : partValue.ToString("0.##");
207 | 
208 |         if (shortForm && partName == "millisecond")
209 |             partName = "ms";
210 |         else if (shortForm)
211 |             partName = partName.Substring(0, 1);
212 | 
213 |         if (shortForm)
214 |             builder.AppendFormat("{0}{1}", partValueString, partName);
215 |         else
216 |             builder.AppendFormat("{0} {1}{2}", partValueString, partName, GetTense(partValue));
217 |         partCount++;
218 | 
219 |         return true;
220 |     }
221 | 
222 |     private static string GetTense(double value)
223 |     {
224 |         return Math.Abs(value) > 1 ? "s" : String.Empty;
225 |     }
226 | }
227 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/BusinessWeek.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | 
  5 | namespace Exceptionless.DateTimeExtensions;
  6 | 
  7 | /// <summary>
  8 | /// A class representing a business week.
  9 | /// </summary>
 10 | public class BusinessWeek
 11 | {
 12 |     /// <summary>
 13 |     /// Initializes a new instance of the <see cref="BusinessWeek"/> class.
 14 |     /// </summary>
 15 |     public BusinessWeek()
 16 |     {
 17 |         BusinessDays = new List<BusinessDay>();
 18 |     }
 19 | 
 20 |     /// <summary>
 21 |     /// Gets the business days for the week.
 22 |     /// </summary>
 23 |     /// <value>The business days for the week.</value>
 24 |     public IList<BusinessDay> BusinessDays { get; private set; }
 25 | 
 26 |     /// <summary>
 27 |     /// Determines whether the specified date falls on a business day.
 28 |     /// </summary>
 29 |     /// <param name="date">The date to check.</param>
 30 |     /// <returns>
 31 |     /// 	<c>true</c> if the specified date falls on a business day; otherwise, <c>false</c>.
 32 |     /// </returns>
 33 |     public bool IsBusinessDay(DateTime date)
 34 |     {
 35 |         return BusinessDays.Any(day => day.IsBusinessDay(date));
 36 |     }
 37 | 
 38 |     /// <summary>
 39 |     /// Gets the business time between the start date and end date.
 40 |     /// </summary>
 41 |     /// <param name="startDate">The start date.</param>
 42 |     /// <param name="endDate">The end date.</param>
 43 |     /// <returns>
 44 |     /// A TimeSpan of the amount of business time between the start and end date.
 45 |     /// </returns>
 46 |     /// <remarks>
 47 |     /// Business time is calculated by adding only the time that falls inside the business day range.
 48 |     /// If all the time between the start and end date fall outside the business day, the time will be zero.
 49 |     /// </remarks>
 50 |     public TimeSpan GetBusinessTime(DateTime startDate, DateTime endDate)
 51 |     {
 52 |         Validate(true);
 53 | 
 54 |         var businessTime = TimeSpan.Zero;
 55 |         var workingDate = startDate;
 56 | 
 57 |         while (workingDate < endDate)
 58 |         {
 59 | 
 60 |             // get start date
 61 |             if (!NextBusinessDay(workingDate, out var businessStart, out var businessDay))
 62 |                 break;
 63 | 
 64 |             // business start after end date
 65 |             if (businessStart > endDate)
 66 |                 break;
 67 | 
 68 |             if (businessDay == null)
 69 |                 break;
 70 | 
 71 |             var timeToEndOfDay = businessDay.EndTime.Subtract(businessStart.TimeOfDay);
 72 |             var businessEnd = businessStart.SafeAdd(timeToEndOfDay);
 73 | 
 74 |             if (endDate <= businessEnd)
 75 |             {
 76 |                 timeToEndOfDay = endDate.TimeOfDay.Subtract(businessStart.TimeOfDay);
 77 |                 businessTime = businessTime.Add(timeToEndOfDay);
 78 |                 return businessTime;
 79 |             }
 80 | 
 81 |             // still more time left, use business end date
 82 |             businessTime = businessTime.Add(timeToEndOfDay);
 83 |             workingDate = businessEnd;
 84 |         }
 85 | 
 86 |         return businessTime;
 87 |     }
 88 | 
 89 |     /// <summary>
 90 |     /// Gets the business end date using the specified time.
 91 |     /// </summary>
 92 |     /// <param name="startDate">The start date.</param>
 93 |     /// <param name="businessTime">The business time.</param>
 94 |     /// <returns></returns>
 95 |     public DateTime GetBusinessEndDate(DateTime startDate, TimeSpan businessTime)
 96 |     {
 97 |         Validate(true);
 98 | 
 99 |         var endDate = startDate;
100 |         var remainingTime = businessTime;
101 | 
102 |         while (remainingTime > TimeSpan.Zero)
103 |         {
104 | 
105 |             // get start date
106 |             if (!NextBusinessDay(endDate, out var businessStart, out var businessDay))
107 |                 break;
108 | 
109 |             var timeForDay = businessDay.EndTime.Subtract(businessStart.TimeOfDay);
110 |             if (remainingTime <= timeForDay)
111 |                 return businessStart.SafeAdd(remainingTime);
112 | 
113 |             // still more time left
114 |             remainingTime = remainingTime.Subtract(timeForDay);
115 |             endDate = businessStart.SafeAdd(timeForDay);
116 |         }
117 | 
118 |         return endDate;
119 |     }
120 | 
121 |     /// <summary>
122 |     /// Validates the business week.
123 |     /// </summary>
124 |     /// <param name="throwExcption">if set to <c>true</c> throw excption if invalid.</param>
125 |     /// <returns><c>true</c> if valid; otherwise <c>false</c>.</returns>
126 |     protected virtual bool Validate(bool throwExcption)
127 |     {
128 |         if (BusinessDays.Any())
129 |             return true;
130 | 
131 |         if (throwExcption)
132 |             throw new InvalidOperationException("The BusinessDays property must have at least one BusinessDay.");
133 | 
134 |         return false;
135 |     }
136 | 
137 |     internal bool NextBusinessDay(DateTime startDate, out DateTime nextDate, out BusinessDay businessDay)
138 |     {
139 |         nextDate = startDate;
140 |         businessDay = null;
141 | 
142 |         var tree = GetDayTree();
143 | 
144 |         // loop no more then 7 times
145 |         for (int x = 0; x < 7; x++)
146 |         {
147 |             var dayOfWeek = nextDate.DayOfWeek;
148 | 
149 |             if (!tree.ContainsKey(dayOfWeek))
150 |             {
151 |                 // no business days on this day of the week
152 |                 nextDate = nextDate.AddDays(1).Date;
153 |                 continue;
154 |             }
155 | 
156 |             var businessDays = tree[dayOfWeek];
157 |             if (businessDays == null)
158 |                 continue;
159 | 
160 |             foreach (var day in businessDays)
161 |             {
162 |                 if (day == null)
163 |                     continue;
164 | 
165 |                 var timeOfDay = nextDate.TimeOfDay;
166 | 
167 |                 if (timeOfDay >= day.StartTime && timeOfDay < day.EndTime)
168 |                 {
169 |                     // working date in range
170 |                     businessDay = day;
171 |                     return true;
172 |                 }
173 | 
174 |                 // past this business day, try other for this day
175 |                 if (timeOfDay >= day.StartTime)
176 |                     continue;
177 | 
178 |                 // move to start time.
179 |                 businessDay = day;
180 |                 nextDate = nextDate.Date.SafeAdd(day.StartTime);
181 | 
182 |                 return true;
183 |             }
184 | 
185 |             // next day
186 |             nextDate = nextDate.AddDays(1).Date;
187 |         }
188 | 
189 |         // should never reach here
190 |         return false;
191 |     }
192 | 
193 |     private Dictionary<DayOfWeek, IList<BusinessDay>> _dayTree;
194 | 
195 |     private Dictionary<DayOfWeek, IList<BusinessDay>> GetDayTree()
196 |     {
197 |         if (_dayTree != null)
198 |             return _dayTree;
199 | 
200 |         _dayTree = new Dictionary<DayOfWeek, IList<BusinessDay>>();
201 |         var days = BusinessDays.OrderBy(b => b.DayOfWeek).ThenBy(b => b.StartTime).ToList();
202 | 
203 |         foreach (var day in days)
204 |         {
205 |             if (!_dayTree.ContainsKey(day.DayOfWeek))
206 |                 _dayTree.Add(day.DayOfWeek, new List<BusinessDay>());
207 | 
208 |             _dayTree[day.DayOfWeek].Add(day);
209 |         }
210 | 
211 |         return _dayTree;
212 |     }
213 | 
214 |     /// <summary>
215 |     /// Gets the default BusinessWeek.
216 |     /// </summary>
217 |     public static BusinessWeek DefaultWeek => Nested.Current;
218 | 
219 |     /// <summary>
220 |     /// Nested class to lazy-load singleton.
221 |     /// </summary>
222 |     private class Nested
223 |     {
224 |         /// <summary>
225 |         /// Initializes the Nested class.
226 |         /// </summary>
227 |         /// <remarks>
228 |         /// Explicit static constructor to tell C# compiler not to mark type as beforefieldinit.
229 |         /// </remarks>
230 |         static Nested()
231 |         {
232 |             Current = new BusinessWeek();
233 |             Current.BusinessDays.Add(new BusinessDay(DayOfWeek.Monday));
234 |             Current.BusinessDays.Add(new BusinessDay(DayOfWeek.Tuesday));
235 |             Current.BusinessDays.Add(new BusinessDay(DayOfWeek.Wednesday));
236 |             Current.BusinessDays.Add(new BusinessDay(DayOfWeek.Thursday));
237 |             Current.BusinessDays.Add(new BusinessDay(DayOfWeek.Friday));
238 |         }
239 | 
240 |         /// <summary>
241 |         /// Current singleton instance.
242 |         /// </summary>
243 |         internal static readonly BusinessWeek Current;
244 |     }
245 | }
246 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Exceptionless.DateTimeExtensions
  2 | 
  3 | [![Build status](https://github.com/Exceptionless/Exceptionless.DateTimeExtensions/workflows/Build/badge.svg)](https://github.com/Exceptionless/Exceptionless.DateTimeExtensions/actions)
  4 | [![NuGet Version](http://img.shields.io/nuget/v/Exceptionless.DateTimeExtensions.svg?style=flat)](https://www.nuget.org/packages/Exceptionless.DateTimeExtensions/)
  5 | [![Discord](https://img.shields.io/discord/715744504891703319)](https://discord.gg/6HxgFCx)
  6 | [![Donate](https://img.shields.io/badge/donorbox-donate-blue.svg)](https://donorbox.org/exceptionless?recurring=true)
  7 | 
  8 | DateTimeRange, Business Day and various DateTime, DateTimeOffset, TimeSpan extension methods.
  9 | 
 10 | ## Getting Started (Development)
 11 | 
 12 | [This package](https://www.nuget.org/packages/Exceptionless.DateTimeExtensions/) can be installed via the [NuGet package manager](https://docs.nuget.org/consume/Package-Manager-Dialog). If you need help, please contact us via in-app support or [open an issue](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/issues/new). We’re always here to help if you have any questions!
 13 | 
 14 | 1. You will need to have [Visual Studio Code](https://code.visualstudio.com/) installed.
 15 | 2. Open the root folder.
 16 | 
 17 | ## Using DateTimeExtensions
 18 | 
 19 | Below is a small sampling of the things you can accomplish with DateTimeExtensions, so check it out!
 20 | 
 21 | ### Business Day
 22 | 
 23 | Quickly calculate if a datetime is within your hours of business. Check out our [unit tests](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/main/tests/Exceptionless.DateTimeExtensions.Tests/BusinessDayTests.cs) for more usage samples.
 24 | 
 25 | ```csharp
 26 | var date = DateTime.Now.StartOfDay().AddHours(8);
 27 | 
 28 | var day = new BusinessDay(date.Date.DayOfWeek,
 29 |     date.Subtract(TimeSpan.FromHours(1)).TimeOfDay,
 30 |     date.AddHours(1).TimeOfDay);
 31 | 
 32 | bool isDay = day.IsBusinessDay(date);
 33 | ```
 34 | 
 35 | ### DateTime Ranges
 36 | 
 37 | Quickly work with date ranges with support for Elasticsearch-style date math expressions and bracket notation. Check out our [unit tests](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/main/tests/Exceptionless.DateTimeExtensions.Tests/DateTimeRangeTests.cs) for more usage samples.
 38 | 
 39 | ```csharp
 40 | // Basic range parsing
 41 | var range = DateTimeRange.Parse("yesterday", DateTime.Now);
 42 | if (range.Contains(DateTime.Now.Subtract(TimeSpan.FromHours(6)))) {
 43 |   //...
 44 | }
 45 | 
 46 | // Elasticsearch Date Math support with proper timezone handling
 47 | var elasticRange = DateTimeRange.Parse("2025-01-01T01:25:35Z||+3d/d", DateTime.Now);
 48 | // Supports timezone-aware operations: Z (UTC), +05:00, -08:00
 49 | 
 50 | // Bracket notation support [start TO end]
 51 | var bracketRange = DateTimeRange.Parse("[2023-01-01 TO 2023-12-31]", DateTime.Now);
 52 | 
 53 | // Wildcard support for open-ended ranges
 54 | var wildcardRange = DateTimeRange.Parse("[2023-01-01 TO *]", DateTime.Now); // From date to infinity
 55 | ```
 56 | 
 57 | #### Date Math Features
 58 | 
 59 | Supports full Elasticsearch date math syntax following [official specifications](https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#date-math):
 60 | 
 61 | - **Anchors**: `now`, explicit dates with `||` separator
 62 | - **Operations**: `+1d` (add), `-1h` (subtract), `/d` (round down)
 63 | - **Units**: `y` (years), `M` (months), `w` (weeks), `d` (days), `h`/`H` (hours), `m` (minutes), `s` (seconds)
 64 | - **Timezone Support**: Preserves explicit timezones (`Z`, `+05:00`, `-08:00`) or uses system timezone as fallback
 65 | 
 66 | Examples:
 67 | 
 68 | - `now+1h` - One hour from now
 69 | - `now-1d/d` - Start of yesterday
 70 | - `2025-01-01T01:25:35Z||+3d/d` - January 4th, 2025 (start of day) in UTC
 71 | - `2023-06-15T14:30:00+05:00||+1M-2d` - One month minus 2 days from the specified date/time in +05:00 timezone
 72 | 
 73 | ### DateMath Utility
 74 | 
 75 | For applications that need standalone date math parsing without the range functionality, the `DateMath` utility class provides direct access to Elasticsearch date math expression parsing. Check out our [unit tests](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/main/tests/Exceptionless.DateTimeExtensions.Tests/DateMathTests.cs) for more usage samples.
 76 | 
 77 | ```csharp
 78 | using Exceptionless.DateTimeExtensions;
 79 | 
 80 | // Parse date math expressions with standard .NET conventions
 81 | var baseTime = DateTimeOffset.Now;
 82 | 
 83 | // Parse method - throws ArgumentException on invalid input
 84 | var result = DateMath.Parse("now+1h", baseTime);
 85 | var rounded = DateMath.Parse("now-1d/d", baseTime, isUpperLimit: false); // Start of yesterday
 86 | 
 87 | // TryParse method - returns bool for success/failure
 88 | if (DateMath.TryParse("2023.06.15||+1M/d", baseTime, false, out var parsed)) {
 89 |     // Successfully parsed: June 15, 2023 + 1 month, rounded to start of day
 90 |     Console.WriteLine($"Parsed: {parsed:O}");
 91 | }
 92 | 
 93 | // Upper limit behavior affects rounding
 94 | var startOfDay = DateMath.Parse("now/d", baseTime, isUpperLimit: false); // 00:00:00
 95 | var endOfDay = DateMath.Parse("now/d", baseTime, isUpperLimit: true);     // 23:59:59.999
 96 | 
 97 | // Explicit dates with timezone preservation
 98 | var utcResult = DateMath.Parse("2025-01-01T01:25:35Z||+3d/d", baseTime);
 99 | var offsetResult = DateMath.Parse("2023-06-15T14:30:00+05:00||+1M", baseTime);
100 | ```
101 | 
102 | #### TimeZone-Aware DateMath
103 | 
104 | The `DateMath` utility also provides overloads that work directly with `TimeZoneInfo` for better timezone handling:
105 | 
106 | ```csharp
107 | using Exceptionless.DateTimeExtensions;
108 | 
109 | // Parse expressions using a specific timezone
110 | var utcTimeZone = TimeZoneInfo.Utc;
111 | var easternTimeZone = TimeZoneInfo.FindSystemTimeZoneById("US/Eastern");
112 | 
113 | // "now" will use current time in the specified timezone
114 | var utcResult = DateMath.Parse("now+1h", utcTimeZone);
115 | var easternResult = DateMath.Parse("now/d", easternTimeZone, isUpperLimit: false);
116 | 
117 | // TryParse with timezone
118 | if (DateMath.TryParse("now+2d-3h", easternTimeZone, false, out var result)) {
119 |     Console.WriteLine($"Eastern time result: {result:O}");
120 | }
121 | 
122 | // Dates without explicit timezone use the provided TimeZoneInfo
123 | var localDate = DateMath.Parse("2023-06-15T14:30:00||+1M", easternTimeZone);
124 | 
125 | // Dates with explicit timezone are preserved regardless of TimeZoneInfo parameter
126 | var preservedTz = DateMath.Parse("2023-06-15T14:30:00+05:00||+1M", easternTimeZone);
127 | // Result will still have +05:00 offset, not Eastern time offset
128 | ```
129 | 
130 | The `DateMath` utility supports the same comprehensive syntax as `DateTimeRange` but provides a simpler API for direct parsing operations.
131 | 
132 | ### TimeUnit
133 | 
134 | Quickly work with time units. . Check out our [unit tests](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/main/tests/Exceptionless.DateTimeExtensions.Tests/TimeUnitTests.cs) for more usage samples.
135 | 
136 | ```csharp
137 | TimeSpan oneNanosecond = TimeUnit.Parse("1nanos");
138 | TimeSpan oneMicrosecond = TimeUnit.Parse("1micros");
139 | TimeSpan oneMillisecond = TimeUnit.Parse("1ms");
140 | TimeSpan oneSecond = TimeUnit.Parse("1s");
141 | TimeSpan oneMinute = TimeUnit.Parse("1m");
142 | TimeSpan oneHour = TimeUnit.Parse("1h");
143 | TimeSpan oneDay = TimeUnit.Parse("1d");
144 | ```
145 | 
146 | ### DateTime Extension methods
147 | 
148 | Helper methods that makes working with DateTimes easier.  Check out the [source](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/main/src/Exceptionless.DateTimeExtensions/DateTimeExtensions.cs) for all of the extension methods you can use.
149 | 
150 | ```csharp
151 | using Exceptionless.DateTimeExtensions;
152 | 
153 | DateTime.Now.ToApproximateAgeString(); // "Just now"
154 | var time = DateTime.Now.StartOfMinute();
155 | var lastWeek = DateTime.Now.LastWeek();
156 | var nextWeek = DateTime.Now.NextWeek();
157 | ```
158 | 
159 | ### DateTimeOffset Extension methods
160 | 
161 | Helper methods that makes working with DateTimeOffsets easier.  Check out the [source](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/master/src/Exceptionless.DateTimeExtensions/DateTimeOffsetExtensions.cs) for all of the extension methods you can use.
162 | 
163 | ```csharp
164 | using Exceptionless.DateTimeExtensions;
165 | 
166 | DateTimeOffset.Now.ToApproximateAgeString(); // "Just now"
167 | var startOfMonth = DateTimeOffset.Now.ToStartOfMonth();
168 | var endOfMonth = DateTimeOffset.Now.ToEndOfMonth();
169 | ```
170 | 
171 | ### Timespan Extension methods
172 | 
173 | Helper methods that makes working with TimeSpans easier.  Check out the [source](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/main/src/Exceptionless.DateTimeExtensions/TimeSpanExtensions.cs) for all of the extension methods you can use.
174 | 
175 | ```csharp
176 | using Exceptionless.DateTimeExtensions;
177 | 
178 | var years = TimeSpan.FromHours(6).GetYears();
179 | var totalYears = TimeSpan.FromHours(6).GetTotalYears();
180 | ```
181 | 
182 | ## Thanks to all the people who have contributed
183 | 
184 | [![contributors](https://contributors-img.web.app/image?repo=exceptionless/Exceptionless.DateTimeExtensions)](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/graphs/contributors)
185 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
  1 | Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 
203 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/DateTimeRangeTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using Xunit;
  4 | 
  5 | namespace Exceptionless.DateTimeExtensions.Tests;
  6 | 
  7 | public class DateTimeRangeTests
  8 | {
  9 |     private static readonly DateTime _now = new(2014, 11, 6, 4, 32, 56, 78);
 10 | 
 11 |     [Fact]
 12 |     public void CanCompareForEquality()
 13 |     {
 14 |         var range1 = new DateTimeRange(_now, _now.AddMinutes(1));
 15 |         var range2 = new DateTimeRange(_now, _now.AddMinutes(1));
 16 |         Assert.True(range1 == range2);
 17 |     }
 18 | 
 19 |     [Fact]
 20 |     public void CanParseNull()
 21 |     {
 22 |         var range = DateTimeRange.Parse(null, _now);
 23 |         Assert.Equal(DateTimeRange.Empty, range);
 24 |     }
 25 | 
 26 |     [Fact]
 27 |     public void CanAddAndSubtract()
 28 |     {
 29 |         var range1 = new DateTimeRange(_now, _now.AddMinutes(1));
 30 |         var utcRange = range1.Add(TimeSpan.FromHours(6));
 31 |         Assert.Equal(_now.AddHours(6), utcRange.Start);
 32 |         Assert.Equal(_now.AddHours(6).AddMinutes(1), utcRange.End);
 33 | 
 34 |         var localRange = utcRange.Subtract(TimeSpan.FromHours(6));
 35 |         Assert.Equal(_now, localRange.Start);
 36 |         Assert.Equal(_now.AddMinutes(1), localRange.End);
 37 |     }
 38 | 
 39 |     [Fact]
 40 |     public void CanParseIntoLocalTime()
 41 |     {
 42 |         const string time = "2016-12-28T05:00:00-2016-12-28T05:30:00";
 43 |         var utcOffset = TimeSpan.FromHours(-1);
 44 |         var localRange = DateTimeRange.Parse(time, DateTimeOffset.UtcNow.ChangeOffset(utcOffset));
 45 |         Assert.Equal(new DateTime(2016, 12, 28, 5, 0, 0, DateTimeKind.Unspecified), localRange.Start);
 46 |         Assert.Equal(new DateTime(2016, 12, 28, 5, 30, 0, DateTimeKind.Unspecified), localRange.End);
 47 |         Assert.Equal(new DateTime(2016, 12, 28, 6, 0, 0, DateTimeKind.Utc), localRange.UtcStart);
 48 |         Assert.Equal(new DateTime(2016, 12, 28, 6, 30, 0, DateTimeKind.Utc), localRange.UtcEnd);
 49 |     }
 50 | 
 51 |     [Fact]
 52 |     public void CanParse8601()
 53 |     {
 54 |         const string time = "2023-12-28T05:00:00.000Z-2023-12-28T05:30:00.000Z";
 55 |         var range = DateTimeRange.Parse(time, DateTimeOffset.UtcNow);
 56 |         Assert.Equal(new DateTime(2023, 12, 28, 5, 0, 0, DateTimeKind.Utc), range.Start);
 57 |         Assert.Equal(new DateTime(2023, 12, 28, 5, 30, 0, DateTimeKind.Utc), range.End);
 58 |         Assert.Equal(new DateTime(2023, 12, 28, 5, 0, 0, DateTimeKind.Utc), range.UtcStart);
 59 |         Assert.Equal(new DateTime(2023, 12, 28, 5, 30, 0, DateTimeKind.Utc), range.UtcEnd);
 60 |     }
 61 | 
 62 |     [Theory]
 63 |     [MemberData(nameof(Inputs))]
 64 |     public void CanParseNamedRanges(string input, DateTime start, DateTime end)
 65 |     {
 66 |         var range = DateTimeRange.Parse(input, _now);
 67 |         Assert.Equal(start, range.Start);
 68 |         Assert.Equal(end, range.End);
 69 |     }
 70 | 
 71 |     public static IEnumerable<object[]> Inputs =>
 72 |     [
 73 |         ["today",          _now.StartOfDay(), _now.EndOfDay()],
 74 |         ["yesterday",      _now.SubtractDays(1).StartOfDay(), _now.SubtractDays(1).EndOfDay()],
 75 |         ["tomorrow",       _now.AddDays(1).StartOfDay(), _now.AddDays(1).EndOfDay()],
 76 |         ["last 5 minutes", _now.SubtractMinutes(5).StartOfMinute(), _now],
 77 |         ["this 5 minutes", _now, _now.AddMinutes(5).EndOfMinute()],
 78 |         ["next 5 minutes", _now, _now.AddMinutes(5).EndOfMinute()],
 79 |         ["last jan",       _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(1).EndOfMonth()],
 80 |         ["jan",            _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(1).EndOfMonth()],
 81 |         ["noVemBer",       _now.StartOfMonth(), _now.EndOfMonth()],
 82 |         ["deC",            _now.ChangeMonth(12).StartOfMonth(), _now.ChangeMonth(12).EndOfMonth()],
 83 |         ["next deC",       _now.ChangeMonth(12).StartOfMonth(), _now.ChangeMonth(12).EndOfMonth()],
 84 |         ["next nov",       _now.AddYears(1).StartOfMonth(), _now.AddYears(1).EndOfMonth()],
 85 |         ["next jan",       _now.AddYears(1).ChangeMonth(1).StartOfMonth(), _now.AddYears(1).ChangeMonth(1).EndOfMonth()],
 86 |         ["jan-feb",        _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
 87 |         ["now-this feb",   _now, _now.AddYears(1).ChangeMonth(2).EndOfMonth()],
 88 | 
 89 |         // Date math expressions without brackets (testing if they work)
 90 |         ["now-6h TO now", _now.AddHours(-6), _now],
 91 |         ["now-1d TO now", _now.AddDays(-1), _now],
 92 | 
 93 |         // Bracket notation with date math (currently failing - documenting expected behavior)
 94 |         ["[now-6h TO now]", _now.AddHours(-6), _now],
 95 |         ["[now-1d TO now]", _now.AddDays(-1), _now],
 96 |         ["[now-30m TO now]", _now.AddMinutes(-30), _now],
 97 |         ["[now TO now+2h]", _now, _now.AddHours(2)],
 98 |         ["[now-1h TO now+1h]", _now.AddHours(-1), _now.AddHours(1)],
 99 | 
100 |         // Curly brace notation with date math (currently failing - documenting expected behavior)
101 |         ["{now-6h TO now}", _now.AddHours(-6), _now],
102 |         ["{now-1d TO now}", _now.AddDays(-1), _now],
103 | 
104 |         // Mixed expressions with brackets (currently failing - documenting expected behavior)
105 |         ["[yesterday TO now]", _now.SubtractDays(1).StartOfDay(), _now],
106 |         ["[now-1w TO today]", _now.AddDays(-7), _now.EndOfDay()]
107 |     ];
108 | 
109 |     [Fact]
110 |     public void Parse_Yesterday_ReturnsFullDayRange()
111 |     {
112 |         // Arrange
113 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
114 |         var expected = baseTime.AddDays(-1).StartOfDay();
115 | 
116 |         // Act
117 |         var range = DateTimeRange.Parse("yesterday", baseTime);
118 | 
119 |         // Assert
120 |         Assert.NotEqual(DateTimeRange.Empty, range);
121 |         Assert.Equal(expected, range.Start);
122 |         Assert.Equal(expected.EndOfDay(), range.End);
123 |     }
124 | 
125 |     [Fact]
126 |     public void Parse_Today_ReturnsFullDayRange()
127 |     {
128 |         // Arrange
129 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
130 |         var expected = baseTime.StartOfDay();
131 | 
132 |         // Act
133 |         var range = DateTimeRange.Parse("today", baseTime);
134 | 
135 |         // Assert
136 |         Assert.NotEqual(DateTimeRange.Empty, range);
137 |         Assert.Equal(expected, range.Start);
138 |         Assert.Equal(expected.EndOfDay(), range.End);
139 |     }
140 | 
141 |     [Fact]
142 |     public void Parse_Tomorrow_ReturnsFullDayRange()
143 |     {
144 |         // Arrange
145 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
146 |         var expected = baseTime.AddDays(1).StartOfDay();
147 | 
148 |         // Act
149 |         var range = DateTimeRange.Parse("tomorrow", baseTime);
150 | 
151 |         // Assert
152 |         Assert.NotEqual(DateTimeRange.Empty, range);
153 |         Assert.Equal(expected, range.Start);
154 |         Assert.Equal(expected.EndOfDay(), range.End);
155 |     }
156 | 
157 |     [Fact]
158 |     public void Parse_LastFiveMinutes_ReturnsPastTimeRange()
159 |     {
160 |         // Arrange
161 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
162 |         var expectedStart = baseTime.AddMinutes(-5).StartOfMinute();
163 | 
164 |         // Act
165 |         var range = DateTimeRange.Parse("last 5 minutes", baseTime);
166 | 
167 |         // Assert
168 |         Assert.NotEqual(DateTimeRange.Empty, range);
169 |         Assert.Equal(expectedStart, range.Start);
170 |         Assert.Equal(baseTime, range.End);
171 |     }
172 | 
173 |     [Fact]
174 |     public void Parse_NextTwoHours_ReturnsFutureTimeRange()
175 |     {
176 |         // Arrange
177 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
178 |         var expectedEnd = baseTime.AddHours(2).EndOfHour();
179 | 
180 |         // Act
181 |         var range = DateTimeRange.Parse("next 2 hours", baseTime);
182 | 
183 |         // Assert
184 |         Assert.NotEqual(DateTimeRange.Empty, range);
185 |         Assert.Equal(baseTime, range.Start);
186 |         Assert.Equal(expectedEnd, range.End);
187 |     }
188 | 
189 |     [Fact]
190 |     public void Parse_BracketNotationWithDateMath_ParsesCorrectly()
191 |     {
192 |         // Arrange
193 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
194 | 
195 |         // Act
196 |         var range = DateTimeRange.Parse("[now-6h TO now]", baseTime);
197 | 
198 |         // Assert
199 |         Assert.NotEqual(DateTimeRange.Empty, range);
200 |         Assert.NotEqual(DateTime.MinValue, range.Start);
201 |         Assert.NotEqual(DateTime.MinValue, range.End);
202 |         Assert.True(range.Start < range.End);
203 | 
204 |         // Verify 'now' resolves to base time
205 |         var tolerance = TimeSpan.FromMinutes(1);
206 |         Assert.True(Math.Abs((range.End - baseTime).TotalMinutes) < tolerance.TotalMinutes);
207 | 
208 |         // Verify the 6-hour span
209 |         var expectedStart = baseTime.AddHours(-6);
210 |         Assert.True(Math.Abs((range.Start - expectedStart).TotalMinutes) < tolerance.TotalMinutes);
211 |     }
212 | 
213 |     [Fact]
214 |     public void Parse_CurlyBraceNotationWithDateMath_ParsesCorrectly()
215 |     {
216 |         // Arrange
217 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
218 | 
219 |         // Act
220 |         var range = DateTimeRange.Parse("{now-1d TO now}", baseTime);
221 | 
222 |         // Assert
223 |         Assert.NotEqual(DateTimeRange.Empty, range);
224 |         Assert.NotEqual(DateTime.MinValue, range.Start);
225 |         Assert.NotEqual(DateTime.MinValue, range.End);
226 |         Assert.True(range.Start < range.End);
227 | 
228 |         // Verify 'now' resolves to base time
229 |         var tolerance = TimeSpan.FromMinutes(1);
230 |         Assert.True(Math.Abs((range.End - baseTime).TotalMinutes) < tolerance.TotalMinutes);
231 | 
232 |         // Verify the 1-day span
233 |         var expectedStart = baseTime.AddDays(-1);
234 |         Assert.True(Math.Abs((range.Start - expectedStart).TotalMinutes) < tolerance.TotalMinutes);
235 |     }
236 | 
237 |     [Fact]
238 |     public void Parse_DateMathWithoutBrackets_ParsesCorrectly()
239 |     {
240 |         // Arrange
241 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
242 | 
243 |         // Act
244 |         var range = DateTimeRange.Parse("now-6h TO now", baseTime);
245 | 
246 |         // Assert
247 |         Assert.NotEqual(DateTimeRange.Empty, range);
248 |         Assert.NotEqual(DateTime.MinValue, range.Start);
249 |         Assert.NotEqual(DateTime.MinValue, range.End);
250 |         Assert.True(range.Start < range.End);
251 | 
252 |         // Verify 'now' resolves to base time
253 |         var tolerance = TimeSpan.FromMinutes(1);
254 |         Assert.True(Math.Abs((range.End - baseTime).TotalMinutes) < tolerance.TotalMinutes);
255 |     }
256 | 
257 |     [Fact]
258 |     public void Parse_MixedParsersInBracketNotation_ParsesCorrectly()
259 |     {
260 |         // Arrange
261 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
262 | 
263 |         // Act
264 |         var range = DateTimeRange.Parse("[yesterday TO today]", baseTime);
265 | 
266 |         // Assert
267 |         Assert.NotEqual(DateTimeRange.Empty, range);
268 |         Assert.NotEqual(DateTime.MinValue, range.Start);
269 |         Assert.NotEqual(DateTime.MinValue, range.End);
270 |         Assert.True(range.Start < range.End);
271 | 
272 |         // Verify yesterday and today are parsed correctly
273 |         var expectedStart = baseTime.AddDays(-1).StartOfDay();
274 |         var expectedEnd = baseTime.StartOfDay().EndOfDay();
275 |         Assert.Equal(expectedStart, range.Start);
276 |         Assert.Equal(expectedEnd, range.End);
277 |     }
278 | 
279 |     [Fact]
280 |     public void Parse_DateMathStartAndEnd_ParsesCorrectly()
281 |     {
282 |         // Arrange
283 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
284 | 
285 |         // Act
286 |         var range = DateTimeRange.Parse("now-1h TO now+1h", baseTime);
287 | 
288 |         // Assert
289 |         Assert.NotEqual(DateTimeRange.Empty, range);
290 |         Assert.NotEqual(DateTime.MinValue, range.Start);
291 |         Assert.NotEqual(DateTime.MinValue, range.End);
292 |         Assert.True(range.Start < range.End);
293 | 
294 |         // Verify the 2-hour span centered on base time
295 |         var tolerance = TimeSpan.FromMinutes(1);
296 |         var expectedStart = baseTime.AddHours(-1);
297 |         var expectedEnd = baseTime.AddHours(1);
298 |         Assert.True(Math.Abs((range.Start - expectedStart).TotalMinutes) < tolerance.TotalMinutes);
299 |         Assert.True(Math.Abs((range.End - expectedEnd).TotalMinutes) < tolerance.TotalMinutes);
300 |     }
301 | 
302 |     [Theory]
303 |     [InlineData("now-6h TO now+6h", 12, "DateMath expressions should create 12-hour range")]
304 |     [InlineData("now-1d TO now", 24, "DateMath expressions should create 24-hour range")]
305 |     [InlineData("now TO now+30m", 0.5, "DateMath expressions should create 30-minute range")]
306 |     public void Parse_DateMathExpressions_CreatesCorrectTimeSpans(string input, double expectedHours, string reason)
307 |     {
308 |         // Arrange
309 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
310 | 
311 |         // Act
312 |         var range = DateTimeRange.Parse(input, baseTime);
313 | 
314 |         // Assert
315 |         Assert.NotEqual(DateTimeRange.Empty, range);
316 |         var actualHours = (range.End - range.Start).TotalHours;
317 |         Assert.True(Math.Abs(actualHours - expectedHours) < 0.1,
318 |             $"{reason}. Expected {expectedHours} hours, but got {actualHours} hours");
319 |     }
320 | 
321 |     [Fact]
322 |     public void Parse_BracketNotationWithDateMath_PreservesTimeZoneInformation()
323 |     {
324 |         // Arrange
325 |         var baseTime = new DateTimeOffset(2023, 12, 25, 12, 0, 0, TimeSpan.FromHours(-5));
326 |         const string input = "[now-6h TO now]";
327 | 
328 |         // Act
329 |         var range = DateTimeRange.Parse(input, baseTime);
330 | 
331 |         // Assert
332 |         Assert.NotEqual(DateTimeRange.Empty, range);
333 |         Assert.Equal(baseTime.AddHours(-6).DateTime, range.Start);
334 |         Assert.Equal(baseTime.DateTime, range.End);
335 |     }
336 | 
337 |     [Theory]
338 |     [InlineData("now+1INVALID", "Invalid unit should not parse")]
339 |     [InlineData("now+", "Incomplete expression should not parse")]
340 |     [InlineData("now++1d", "Double operators should not parse")]
341 |     [InlineData("[now+ TO now]", "Invalid left side in bracket notation should not parse")]
342 |     public void Parse_InvalidDateMathExpressions_ReturnsEmptyRange(string input, string reason)
343 |     {
344 |         // Arrange
345 |         var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
346 | 
347 |         // Act
348 |         var range = DateTimeRange.Parse(input, baseTime);
349 | 
350 |         // Assert - Invalid expressions should result in empty range or fallback parsing
351 |         // The behavior may vary based on parser priority and fallback mechanisms
352 |         Assert.True(range == DateTimeRange.Empty || range.Start != DateTime.MinValue,
353 |             $"{reason}. Input '{input}' should either return empty range or valid fallback parsing");
354 |     }
355 | }
356 | 


--------------------------------------------------------------------------------
/tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/DateMathPartParserTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using Exceptionless.DateTimeExtensions.FormatParsers.PartParsers;
  4 | using Xunit;
  5 | using Xunit.Abstractions;
  6 | 
  7 | namespace Exceptionless.DateTimeExtensions.Tests.FormatParsers.PartParsers;
  8 | 
  9 | public class DateMathPartParserTests : PartParserTestsBase
 10 | {
 11 |     public DateMathPartParserTests(ITestOutputHelper output) : base(output) { }
 12 | 
 13 |     [Theory]
 14 |     [MemberData(nameof(NowInputs))]
 15 |     public void ParseNowInput(string input, bool isUpperLimit, DateTimeOffset? expected)
 16 |     {
 17 |         ValidateInput(new DateMathPartParser(), input, isUpperLimit, expected);
 18 |     }
 19 | 
 20 |     [Theory]
 21 |     [MemberData(nameof(ExplicitDateInputs))]
 22 |     public void ParseExplicitDateInput(string input, bool isUpperLimit, DateTimeOffset? expected)
 23 |     {
 24 |         ValidateInput(new DateMathPartParser(), input, isUpperLimit, expected);
 25 |     }
 26 | 
 27 |     [Theory]
 28 |     [MemberData(nameof(InvalidInputs))]
 29 |     public void ParseInvalidInput(string input, bool isUpperLimit, DateTimeOffset? expected)
 30 |     {
 31 |         ValidateInput(new DateMathPartParser(), input, isUpperLimit, expected);
 32 |     }
 33 | 
 34 |     [Theory]
 35 |     [MemberData(nameof(ComplexOperationInputs))]
 36 |     public void ParseComplexOperations(string input, bool isUpperLimit, DateTimeOffset? expected)
 37 |     {
 38 |         ValidateInput(new DateMathPartParser(), input, isUpperLimit, expected);
 39 |     }
 40 | 
 41 |     [Theory]
 42 |     [MemberData(nameof(RoundingInputs))]
 43 |     public void ParseRoundingOperations(string input, bool isUpperLimit, DateTimeOffset? expected)
 44 |     {
 45 |         ValidateInput(new DateMathPartParser(), input, isUpperLimit, expected);
 46 |     }
 47 | 
 48 |     [Theory]
 49 |     [MemberData(nameof(EdgeCaseInputs))]
 50 |     public void ParseEdgeCases(string input, bool isUpperLimit, DateTimeOffset? expected)
 51 |     {
 52 |         ValidateInput(new DateMathPartParser(), input, isUpperLimit, expected);
 53 |     }
 54 | 
 55 |     public static IEnumerable<object[]> NowInputs
 56 |     {
 57 |         get
 58 |         {
 59 |             return
 60 |             [
 61 |                 // Basic "now" anchor
 62 |                 ["now", false, _now],
 63 |                 ["now", true, _now],
 64 | 
 65 |                 // Now with single operations
 66 |                 ["now+1h", false, _now.AddHours(1)],
 67 |                 ["now+1h", true, _now.AddHours(1)],
 68 |                 ["now-1h", false, _now.AddHours(-1)],
 69 |                 ["now-1h", true, _now.AddHours(-1)],
 70 |                 ["now+1d", false, _now.AddDays(1)],
 71 |                 ["now+1d", true, _now.AddDays(1)],
 72 |                 ["now-1d", false, _now.AddDays(-1)],
 73 |                 ["now-1d", true, _now.AddDays(-1)],
 74 |                 ["now+1w", false, _now.AddDays(7)],
 75 |                 ["now+1w", true, _now.AddDays(7)],
 76 |                 ["now-1w", false, _now.AddDays(-7)],
 77 |                 ["now-1w", true, _now.AddDays(-7)],
 78 |                 ["now+1M", false, _now.AddMonths(1)],
 79 |                 ["now+1M", true, _now.AddMonths(1)],
 80 |                 ["now-1M", false, _now.AddMonths(-1)],
 81 |                 ["now-1M", true, _now.AddMonths(-1)],
 82 |                 ["now+1y", false, _now.AddYears(1)],
 83 |                 ["now+1y", true, _now.AddYears(1)],
 84 |                 ["now-1y", false, _now.AddYears(-1)],
 85 |                 ["now-1y", true, _now.AddYears(-1)],
 86 |                 ["now+1m", false, _now.AddMinutes(1)],
 87 |                 ["now+1m", true, _now.AddMinutes(1)],
 88 |                 ["now-1m", false, _now.AddMinutes(-1)],
 89 |                 ["now-1m", true, _now.AddMinutes(-1)],
 90 |                 ["now+1s", false, _now.AddSeconds(1)],
 91 |                 ["now+1s", true, _now.AddSeconds(1)],
 92 |                 ["now-1s", false, _now.AddSeconds(-1)],
 93 |                 ["now-1s", true, _now.AddSeconds(-1)],
 94 | 
 95 |                 // Multi-digit amounts
 96 |                 ["now+10h", false, _now.AddHours(10)],
 97 |                 ["now+24h", true, _now.AddHours(24)],
 98 |                 ["now-365d", false, _now.AddDays(-365)],
 99 |                 ["now+100y", true, _now.AddYears(100)],
100 | 
101 |                 // Capital H for hours
102 |                 ["now+1H", false, _now.AddHours(1)],
103 |                 ["now-2H", true, _now.AddHours(-2)],
104 | 
105 |                 // Without amount (defaults to 1)
106 |                 ["now+h", false, _now.AddHours(1)],
107 |                 ["now-d", true, _now.AddDays(-1)],
108 |                 ["now+M", false, _now.AddMonths(1)],
109 |                 ["now-y", true, _now.AddYears(-1)]
110 |             ];
111 |         }
112 |     }
113 | 
114 |     public static IEnumerable<object[]> ExplicitDateInputs
115 |     {
116 |         get
117 |         {
118 |             var baseDate = new DateTimeOffset(2001, 2, 1, 0, 0, 0, _now.Offset);
119 | 
120 |             return
121 |             [
122 |                 // Basic explicit date formats (officially supported by Elasticsearch)
123 |                 ["2001-02-01||", false, baseDate],
124 |                 ["2001-02-01||", true, baseDate],
125 |                 ["20010201||", false, baseDate],
126 |                 ["20010201||", true, baseDate],
127 | 
128 |                 // With time components (ISO 8601 formats)
129 |                 ["2001-02-01T12:30:45||", false, new DateTimeOffset(2001, 2, 1, 12, 30, 45, _now.Offset)],
130 |                 ["2001-02-01T12:30:45||", true, new DateTimeOffset(2001, 2, 1, 12, 30, 45, _now.Offset)],
131 |                 ["2001-02-01T12:30||", false, new DateTimeOffset(2001, 2, 1, 12, 30, 0, _now.Offset)],
132 |                 ["2001-02-01T12:30||", true, new DateTimeOffset(2001, 2, 1, 12, 30, 0, _now.Offset)],
133 |                 ["2001-02-01T12||", false, new DateTimeOffset(2001, 2, 1, 12, 0, 0, _now.Offset)],
134 |                 ["2001-02-01T12||", true, new DateTimeOffset(2001, 2, 1, 12, 0, 0, _now.Offset)],
135 | 
136 |                 // With operations
137 |                 ["2001-02-01||+1M", false, baseDate.AddMonths(1)],
138 |                 ["2001-02-01||+1M", true, baseDate.AddMonths(1)],
139 |                 ["2001-02-01||+1y", false, baseDate.AddYears(1)],
140 |                 ["2001-02-01||+1y", true, baseDate.AddYears(1)],
141 |                 ["2001-02-01||-1d", false, baseDate.AddDays(-1)],
142 |                 ["2001-02-01||-1d", true, baseDate.AddDays(-1)],
143 | 
144 |                 // With operations and rounding (basic_date format + operations)
145 |                 ["20010201||+1M/d", false, baseDate.AddMonths(1).StartOfDay()],
146 |                 ["20010201||+1M/d", true, baseDate.AddMonths(1).EndOfDay()],
147 | 
148 |                 // User's specific test case - UTC date with operations and rounding
149 |                 ["2025-01-01T01:25:35Z||+3d/d", false, new DateTimeOffset(2025, 1, 4, 0, 0, 0, TimeSpan.Zero)],
150 |                 ["2025-01-01T01:25:35Z||+3d/d", true, new DateTimeOffset(2025, 1, 4, 23, 59, 59, 999, TimeSpan.Zero)],
151 | 
152 |                 // Timezone variations - should preserve the timezone
153 |                 ["2023-06-15T14:30:00Z||", false, new DateTimeOffset(2023, 6, 15, 14, 30, 0, TimeSpan.Zero)],
154 |                 ["2023-06-15T14:30:00Z||", true, new DateTimeOffset(2023, 6, 15, 14, 30, 0, TimeSpan.Zero)],
155 |                 ["2023-06-15T14:30:00+05:00||", false, new DateTimeOffset(2023, 6, 15, 14, 30, 0, TimeSpan.FromHours(5))],
156 |                 ["2023-06-15T14:30:00+05:00||", true, new DateTimeOffset(2023, 6, 15, 14, 30, 0, TimeSpan.FromHours(5))],
157 |                 ["2023-06-15T14:30:00-08:00||", false, new DateTimeOffset(2023, 6, 15, 14, 30, 0, TimeSpan.FromHours(-8))],
158 |                 ["2023-06-15T14:30:00-08:00||", true, new DateTimeOffset(2023, 6, 15, 14, 30, 0, TimeSpan.FromHours(-8))],
159 | 
160 |                 // Dates without timezone - should use current timezone
161 |                 ["2023-06-15T14:30:00||", false, new DateTimeOffset(2023, 6, 15, 14, 30, 0, _now.Offset)],
162 |                 ["2023-06-15T14:30:00||", true, new DateTimeOffset(2023, 6, 15, 14, 30, 0, _now.Offset)],
163 | 
164 |                 // Milliseconds support with and without timezone
165 |                 ["2023-01-01T12:00:00.123||", false, new DateTimeOffset(2023, 1, 1, 12, 0, 0, 123, _now.Offset)],
166 |                 ["2023-01-01T12:00:00.123||", true, new DateTimeOffset(2023, 1, 1, 12, 0, 0, 123, _now.Offset)],
167 |                 ["2023-01-01T12:00:00.123Z||", false, new DateTimeOffset(2023, 1, 1, 12, 0, 0, 123, TimeSpan.Zero)],
168 |                 ["2023-01-01T12:00:00.123Z||", true, new DateTimeOffset(2023, 1, 1, 12, 0, 0, 123, TimeSpan.Zero)],
169 |                 ["2023-01-01T12:00:00.123+02:00||", false, new DateTimeOffset(2023, 1, 1, 12, 0, 0, 123, TimeSpan.FromHours(2))],
170 |                 ["2023-01-01T12:00:00.123+02:00||", true, new DateTimeOffset(2023, 1, 1, 12, 0, 0, 123, TimeSpan.FromHours(2))],
171 | 
172 |                 // Basic format variations (yyyyMMdd is officially supported)
173 |                 ["20230615||", false, new DateTimeOffset(2023, 6, 15, 0, 0, 0, _now.Offset)],
174 |                 ["20230615||", true, new DateTimeOffset(2023, 6, 15, 0, 0, 0, _now.Offset)]
175 |             ];
176 |         }
177 |     }
178 | 
179 |     public static IEnumerable<object[]> ComplexOperationInputs
180 |     {
181 |         get
182 |         {
183 |             return
184 |             [
185 |                 // Multiple operations
186 |                 ["now+1d+1h", false, _now.AddDays(1).AddHours(1)],
187 |                 ["now+1d+1h", true, _now.AddDays(1).AddHours(1)],
188 |                 ["now-1d-1h", false, _now.AddDays(-1).AddHours(-1)],
189 |                 ["now-1d-1h", true, _now.AddDays(-1).AddHours(-1)],
190 |                 ["now+1M-1d", false, _now.AddMonths(1).AddDays(-1)],
191 |                 ["now+1M-1d", true, _now.AddMonths(1).AddDays(-1)],
192 |                 ["now+1y+6M+15d", false, _now.AddYears(1).AddMonths(6).AddDays(15)],
193 |                 ["now+1y+6M+15d", true, _now.AddYears(1).AddMonths(6).AddDays(15)],
194 | 
195 |                 // Mixed units and operations
196 |                 ["now+2h+30m+45s", false, _now.AddHours(2).AddMinutes(30).AddSeconds(45)],
197 |                 ["now+2h+30m+45s", true, _now.AddHours(2).AddMinutes(30).AddSeconds(45)],
198 |                 ["now-1w+2d", false, _now.AddDays(-7).AddDays(2)],
199 |                 ["now-1w+2d", true, _now.AddDays(-7).AddDays(2)],
200 | 
201 |                 // Operations with explicit dates and timezones
202 |                 ["2025-01-01T01:25:35||+3d/d", false, new DateTimeOffset(2025, 1, 4, 0, 0, 0, _now.Offset)],
203 |                 ["2025-01-01T01:25:35||+3d/d", true, new DateTimeOffset(2025, 1, 4, 23, 59, 59, 999, _now.Offset)],
204 | 
205 |                 // Complex operations with UTC timezone
206 |                 ["2025-01-01T01:25:35Z||+3d/d", false, new DateTimeOffset(2025, 1, 4, 0, 0, 0, TimeSpan.Zero)],
207 |                 ["2025-01-01T01:25:35Z||+3d/d", true, new DateTimeOffset(2025, 1, 4, 23, 59, 59, 999, TimeSpan.Zero)],
208 |                 ["2023-12-31T23:59:59Z||+1d+1h", false, new DateTimeOffset(2024, 1, 2, 0, 59, 59, TimeSpan.Zero)],
209 |                 ["2023-12-31T23:59:59Z||+1d+1h", true, new DateTimeOffset(2024, 1, 2, 0, 59, 59, TimeSpan.Zero)],
210 | 
211 |                 // Complex operations with timezone offsets
212 |                 ["2023-06-15T10:00:00+05:00||+1d-2h", false, new DateTimeOffset(2023, 6, 16, 8, 0, 0, TimeSpan.FromHours(5))],
213 |                 ["2023-06-15T10:00:00+05:00||+1d-2h", true, new DateTimeOffset(2023, 6, 16, 8, 0, 0, TimeSpan.FromHours(5))]
214 |             ];
215 |         }
216 |     }
217 | 
218 |     public static IEnumerable<object[]> RoundingInputs
219 |     {
220 |         get
221 |         {
222 |             return
223 |             [
224 |                 // Rounding to different units
225 |                 ["now/d", false, _now.StartOfDay()],
226 |                 ["now/d", true, _now.EndOfDay()],
227 |                 ["now/h", false, _now.StartOfHour()],
228 |                 ["now/h", true, _now.EndOfHour()],
229 |                 ["now/H", false, _now.StartOfHour()],
230 |                 ["now/H", true, _now.EndOfHour()],
231 |                 ["now/m", false, _now.StartOfMinute()],
232 |                 ["now/m", true, _now.EndOfMinute()],
233 |                 ["now/s", false, _now.StartOfSecond()],
234 |                 ["now/s", true, _now.EndOfSecond()],
235 |                 ["now/w", false, _now.StartOfWeek()],
236 |                 ["now/w", true, _now.EndOfWeek()],
237 |                 ["now/M", false, _now.StartOfMonth()],
238 |                 ["now/M", true, _now.EndOfMonth()],
239 |                 ["now/y", false, _now.StartOfYear()],
240 |                 ["now/y", true, _now.EndOfYear()],
241 | 
242 |                 // Combined operations with rounding (Elasticsearch example)
243 |                 ["now-1h/d", false, _now.AddHours(-1).StartOfDay()],
244 |                 ["now-1h/d", true, _now.AddHours(-1).EndOfDay()],
245 |                 ["now+1d/h", false, _now.AddDays(1).StartOfHour()],
246 |                 ["now+1d/h", true, _now.AddDays(1).EndOfHour()],
247 | 
248 |                 // Multiple operations ending with rounding
249 |                 ["now+1M-1d/d", false, _now.AddMonths(1).AddDays(-1).StartOfDay()],
250 |                 ["now+1M-1d/d", true, _now.AddMonths(1).AddDays(-1).EndOfDay()]
251 |             ];
252 |         }
253 |     }
254 | 
255 |     public static IEnumerable<object[]> EdgeCaseInputs
256 |     {
257 |         get
258 |         {
259 |             return
260 |             [
261 |                 // Case sensitivity
262 |                 ["NOW", false, _now],
263 |                 ["NOW", true, _now],
264 |                 ["Now", false, _now],
265 |                 ["Now", true, _now],
266 | 
267 |                 // Zero amounts (edge case, should work)
268 |                 ["now+0d", false, _now],
269 |                 ["now+0d", true, _now],
270 |                 ["now-0h", false, _now],
271 |                 ["now-0h", true, _now],
272 | 
273 |                 // Large amounts (but not overflow)
274 |                 ["now+100y", false, _now.AddYears(100)],
275 |                 ["now+100y", true, _now.AddYears(100)],
276 | 
277 |                 // Overflow case - should return original date
278 |                 ["now+9999y", false, _now], // AddYears would overflow, should return original
279 |                 ["now+9999y", true, _now],
280 | 
281 |                 // Mixed case units
282 |                 ["now+1D", false, null], // Should fail - lowercase d required
283 |                 ["now+1D", true, null],
284 |                 ["now+1HOUR", false, null], // Should fail - single char required
285 |                 ["now+1HOUR", true, null]
286 |             ];
287 |         }
288 |     }
289 | 
290 |     public static IEnumerable<object[]> InvalidInputs
291 |     {
292 |         get
293 |         {
294 |             return
295 |             [
296 |                 // Invalid formats
297 |                 ["invalid", false, null],
298 |                 ["invalid", true, null],
299 |                 ["blah", false, null],
300 |                 ["blah blah", true, null],
301 |                 ["", false, null],
302 |                 ["", true, null],
303 | 
304 |                 // Invalid date formats
305 |                 ["2001-13-01||", false, null], // Invalid month
306 |                 ["2001-13-01||", true, null],
307 |                 ["2001-02-30||", false, null], // Invalid day for February
308 |                 ["2001-02-30||", true, null],
309 |                 ["invalid-date||", false, null],
310 |                 ["invalid-date||", true, null],
311 | 
312 |                 // Invalid operations
313 |                 ["now+", false, null], // Missing unit
314 |                 ["now+", true, null],
315 |                 ["now+1", false, null], // Missing unit
316 |                 ["now+1", true, null],
317 |                 ["now+1x", false, null], // Invalid unit
318 |                 ["now+1x", true, null],
319 |                 ["now++1d", false, null], // Double operator
320 |                 ["now++1d", true, null],
321 |                 ["now+1d+", false, null], // Trailing operator
322 |                 ["now+1d+", true, null],
323 | 
324 |                 // Invalid anchor
325 |                 ["yesterday+1d", false, null], // Invalid anchor
326 |                 ["yesterday+1d", true, null],
327 |                 ["2001||+1d", false, null], // Incomplete date
328 |                 ["2001||+1d", true, null],
329 | 
330 |                 // Invalid timezone formats
331 |                 // Invalid date components
332 |                 ["2023-00-01||", false, null], // Invalid month
333 |                 ["2023-00-01||", true, null],
334 |                 ["2023-01-32||", false, null], // Invalid day
335 |                 ["2023-01-32||", true, null],
336 |                 ["2023-02-29||", false, null], // Invalid day for non-leap year
337 |                 ["2023-02-29||", true, null]
338 |             ];
339 |         }
340 |     }
341 | }
342 | 


--------------------------------------------------------------------------------
/src/Exceptionless.DateTimeExtensions/DateTimeExtensions.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | 
  3 | namespace Exceptionless.DateTimeExtensions;
  4 | 
  5 | public static class DateTimeExtensions
  6 | {
  7 |     public static bool IsBefore(this DateTime date, DateTime value)
  8 |     {
  9 |         return date < value;
 10 |     }
 11 | 
 12 |     public static bool IsBeforeOrEqual(this DateTime date, DateTime value)
 13 |     {
 14 |         return date <= value;
 15 |     }
 16 | 
 17 |     public static bool IsAfter(this DateTime date, DateTime value)
 18 |     {
 19 |         return date > value;
 20 |     }
 21 | 
 22 |     public static bool IsAfterOrEqual(this DateTime date, DateTime value)
 23 |     {
 24 |         return date >= value;
 25 |     }
 26 | 
 27 |     public static DateTime SafeAdd(this DateTime date, TimeSpan value)
 28 |     {
 29 |         if (date.Ticks + value.Ticks < DateTime.MinValue.Ticks)
 30 |             return DateTime.MinValue;
 31 | 
 32 |         if (date.Ticks + value.Ticks > DateTime.MaxValue.Ticks)
 33 |             return DateTime.MaxValue;
 34 | 
 35 |         return date.Add(value);
 36 |     }
 37 | 
 38 |     public static DateTime SafeSubtract(this DateTime date, TimeSpan value)
 39 |     {
 40 |         if (date.Ticks - value.Ticks < DateTime.MinValue.Ticks)
 41 |             return DateTime.MinValue;
 42 | 
 43 |         if (date.Ticks - value.Ticks > DateTime.MaxValue.Ticks)
 44 |             return DateTime.MaxValue;
 45 | 
 46 |         return date.Subtract(value);
 47 |     }
 48 | 
 49 |     public static string ToApproximateAgeString(this DateTime fromDate)
 50 |     {
 51 |         bool isFuture = fromDate > DateTime.Now;
 52 |         var age = isFuture ? GetAge(DateTime.Now, fromDate) : GetAge(fromDate);
 53 |         if (age.TotalMinutes <= 1d)
 54 |             return age.TotalSeconds > 0 ? "Just now" : "Right now";
 55 | 
 56 |         return isFuture ? $"{age.ToString(1)} from now" : $"{age.ToString(1)} ago";
 57 |     }
 58 | 
 59 |     public static string ToAgeString(this DateTime fromDate)
 60 |     {
 61 |         return ToAgeString(fromDate, DateTime.Now, 0);
 62 |     }
 63 | 
 64 |     public static string ToAgeString(this DateTime fromDate, int maxSpans)
 65 |     {
 66 |         return ToAgeString(fromDate, DateTime.Now, maxSpans);
 67 |     }
 68 | 
 69 |     public static string ToAgeString(this DateTime fromDate, int maxSpans, bool shortForm)
 70 |     {
 71 |         return ToAgeString(fromDate, DateTime.Now, maxSpans, shortForm);
 72 |     }
 73 | 
 74 |     public static string ToAgeString(this DateTime fromDate, DateTime toDate, int maxSpans)
 75 |     {
 76 |         var age = GetAge(fromDate, toDate);
 77 |         return age.ToString(maxSpans, false);
 78 |     }
 79 | 
 80 |     public static string ToAgeString(this DateTime fromDate, DateTime toDate, int maxSpans, bool shortForm)
 81 |     {
 82 |         var age = GetAge(fromDate, toDate);
 83 |         return age.ToString(maxSpans, shortForm);
 84 |     }
 85 | 
 86 |     public static AgeSpan GetAge(this DateTime fromDate)
 87 |     {
 88 |         return GetAge(fromDate, DateTime.Now);
 89 |     }
 90 | 
 91 |     public static AgeSpan GetAge(this DateTime fromDate, DateTime toDate)
 92 |     {
 93 |         return new AgeSpan(toDate - fromDate);
 94 |     }
 95 | 
 96 |     public static int ToEpoch(this DateTime fromDate)
 97 |     {
 98 |         long utc = (fromDate.ToUniversalTime().Ticks - EPOCH_TICKS) / TimeSpan.TicksPerSecond;
 99 |         return Convert.ToInt32(utc);
100 |     }
101 | 
102 |     public static int ToEpochOffset(this DateTime date, int timestamp)
103 |     {
104 |         return timestamp - date.ToEpoch();
105 |     }
106 | 
107 |     public static int ToEpoch(this DateTime date, int offset)
108 |     {
109 |         return offset + date.ToEpoch();
110 |     }
111 | 
112 |     private const long EPOCH_TICKS = 621355968000000000;
113 | 
114 |     public static DateTime ToDateTime(this int secondsSinceEpoch)
115 |     {
116 |         return new DateTime(EPOCH_TICKS + (secondsSinceEpoch * TimeSpan.TicksPerSecond));
117 |     }
118 | 
119 |     public static DateTime ToDateTime(this double milliSecondsSinceEpoch)
120 |     {
121 |         return new DateTime(EPOCH_TICKS + ((long)milliSecondsSinceEpoch * TimeSpan.TicksPerMillisecond));
122 |     }
123 | 
124 |     public static DateTime ChangeMillisecond(this DateTime date, int millisecond)
125 |     {
126 |         if (millisecond < 0 || millisecond > 59)
127 |             throw new ArgumentException("Value must be between 0 and 999.", nameof(millisecond));
128 | 
129 |         return date.AddMilliseconds(millisecond - date.Millisecond);
130 |     }
131 | 
132 |     public static DateTime ChangeSecond(this DateTime date, int second)
133 |     {
134 |         if (second < 0 || second > 59)
135 |             throw new ArgumentException("Value must be between 0 and 59.", nameof(second));
136 | 
137 |         return date.AddSeconds(second - date.Second);
138 |     }
139 | 
140 |     public static DateTime ChangeMinute(this DateTime date, int minute)
141 |     {
142 |         if (minute < 0 || minute > 59)
143 |             throw new ArgumentException("Value must be between 0 and 59.", nameof(minute));
144 | 
145 |         return date.AddMinutes(minute - date.Minute);
146 |     }
147 | 
148 |     public static DateTime ChangeHour(this DateTime date, int hour)
149 |     {
150 |         if (hour < 0 || hour > 23)
151 |             throw new ArgumentException("Value must be between 0 and 23.", nameof(hour));
152 | 
153 |         return date.AddHours(hour - date.Hour);
154 |     }
155 | 
156 |     public static DateTime ChangeDay(this DateTime date, int day)
157 |     {
158 |         if (day < 1 || day > 31)
159 |             throw new ArgumentException("Value must be between 1 and 31.", nameof(day));
160 | 
161 |         if (day > DateTime.DaysInMonth(date.Year, date.Month))
162 |             throw new ArgumentException("Value must be a valid source.", nameof(day));
163 | 
164 |         return date.AddDays(day - date.Day);
165 |     }
166 | 
167 |     public static DateTime ChangeMonth(this DateTime date, int month)
168 |     {
169 |         if (month < 1 || month > 12)
170 |             throw new ArgumentException("Value must be between 1 and 12.", nameof(month));
171 | 
172 |         return date.AddMonths(month - date.Month);
173 |     }
174 | 
175 |     public static DateTime ChangeYear(this DateTime date, int year)
176 |     {
177 |         return date.AddYears(year - date.Year);
178 |     }
179 | 
180 |     public static DateTime Change(this DateTime date, int? year = null, int? month = null, int? day = null, int? hour = null, int? minute = null, int? second = null)
181 |     {
182 |         var result = date;
183 | 
184 |         if (year.HasValue)
185 |             result = result.ChangeYear(year.Value);
186 |         if (month.HasValue)
187 |             result = result.ChangeMonth(month.Value);
188 |         if (day.HasValue)
189 |             result = result.ChangeDay(day.Value);
190 |         if (hour.HasValue)
191 |             result = result.ChangeHour(hour.Value);
192 |         if (minute.HasValue)
193 |             result = result.ChangeMinute(minute.Value);
194 |         if (second.HasValue)
195 |             result = result.ChangeSecond(second.Value);
196 | 
197 |         return result;
198 |     }
199 | 
200 |     public static DateTime StartOfSecond(this DateTime date)
201 |     {
202 |         return date.Floor(TimeSpan.FromSeconds(1));
203 |     }
204 | 
205 |     public static DateTime EndOfSecond(this DateTime date)
206 |     {
207 |         var value = date.StartOfSecond().SafeAdd(TimeSpan.FromSeconds(1));
208 |         if (value == DateTime.MaxValue)
209 |             return value;
210 | 
211 |         return value.SubtractMilliseconds(1);
212 |     }
213 | 
214 |     public static DateTime StartOfMinute(this DateTime date)
215 |     {
216 |         return date.Floor(TimeSpan.FromMinutes(1));
217 |     }
218 | 
219 |     public static DateTime EndOfMinute(this DateTime date)
220 |     {
221 |         var value = date.StartOfMinute().SafeAdd(TimeSpan.FromMinutes(1));
222 |         if (value == DateTime.MaxValue)
223 |             return value;
224 | 
225 |         return value.SubtractMilliseconds(1);
226 |     }
227 | 
228 |     public static DateTime StartOfHour(this DateTime date)
229 |     {
230 |         return date.Floor(TimeSpan.FromHours(1));
231 |     }
232 | 
233 |     public static DateTime EndOfHour(this DateTime date)
234 |     {
235 |         var value = date.StartOfHour().SafeAdd(TimeSpan.FromHours(1));
236 |         if (value == DateTime.MaxValue)
237 |             return value;
238 | 
239 |         return value.SubtractMilliseconds(1);
240 |     }
241 | 
242 |     public static DateTime StartOfDay(this DateTime date)
243 |     {
244 |         return date.Floor(TimeSpan.FromDays(1));
245 |     }
246 | 
247 |     public static DateTime EndOfDay(this DateTime date)
248 |     {
249 |         var value = date.StartOfDay().SafeAdd(TimeSpan.FromDays(1));
250 |         if (value == DateTime.MaxValue)
251 |             return value;
252 | 
253 |         return value.SubtractMilliseconds(1);
254 |     }
255 | 
256 |     public static DateTime StartOfWeek(this DateTime date, DayOfWeek startOfWeek = DayOfWeek.Sunday)
257 |     {
258 |         int diff = date.DayOfWeek - startOfWeek;
259 |         if (diff < 0)
260 |             diff += 7;
261 | 
262 |         return date.StartOfDay().SafeSubtract(TimeSpan.FromDays(diff));
263 |     }
264 | 
265 |     public static DateTime EndOfWeek(this DateTime date, DayOfWeek startOfWeek = DayOfWeek.Sunday)
266 |     {
267 |         var value = date.StartOfWeek(startOfWeek).AddWeeks(1);
268 |         if (value == DateTime.MaxValue)
269 |             return value;
270 | 
271 |         return value.SubtractMilliseconds(1);
272 |     }
273 | 
274 |     public static DateTime StartOfMonth(this DateTime date)
275 |     {
276 |         return date.StartOfDay().SafeSubtract(TimeSpan.FromDays(date.Date.Day - 1));
277 |     }
278 | 
279 |     public static DateTime EndOfMonth(this DateTime date)
280 |     {
281 |         var value = date.StartOfMonth().AddMonths(1);
282 |         if (value == DateTime.MaxValue)
283 |             return value;
284 | 
285 |         return value.SubtractMilliseconds(1);
286 |     }
287 | 
288 |     public static DateTime StartOfYear(this DateTime date)
289 |     {
290 |         return date.StartOfMonth().SubtractMonths(date.Date.Month - 1);
291 |     }
292 | 
293 |     public static DateTime EndOfYear(this DateTime date)
294 |     {
295 |         var value = date.StartOfYear().AddYears(1);
296 |         if (value == DateTime.MaxValue)
297 |             return value;
298 | 
299 |         return value.SubtractMilliseconds(1);
300 |     }
301 | 
302 |     public static DateTime Floor(this DateTime date, TimeSpan interval)
303 |     {
304 |         return date.AddTicks(-(date.Ticks % interval.Ticks));
305 |     }
306 | 
307 |     public static DateTime Ceiling(this DateTime date, TimeSpan interval)
308 |     {
309 |         return date.AddTicks(interval.Ticks - (date.Ticks % interval.Ticks));
310 |     }
311 | 
312 |     public static DateTime Round(this DateTime date, TimeSpan roundingInterval)
313 |     {
314 |         long halfIntervalTicks = ((roundingInterval.Ticks + 1) >> 1);
315 |         return date.AddTicks(halfIntervalTicks - ((date.Ticks + halfIntervalTicks) % roundingInterval.Ticks));
316 |     }
317 | 
318 |     public static DateTime NextSecond(this DateTime date)
319 |     {
320 |         return date.SafeAdd(TimeSpan.FromSeconds(1));
321 |     }
322 | 
323 |     public static DateTime LastSecond(this DateTime date)
324 |     {
325 |         return date.SafeSubtract(TimeSpan.FromSeconds(1));
326 |     }
327 | 
328 |     public static DateTime NextMinute(this DateTime date)
329 |     {
330 |         return date.SafeAdd(TimeSpan.FromMinutes(1));
331 |     }
332 | 
333 |     public static DateTime LastMinute(this DateTime date)
334 |     {
335 |         return date.SafeSubtract(TimeSpan.FromMinutes(1));
336 |     }
337 | 
338 |     public static DateTime NextHour(this DateTime date)
339 |     {
340 |         return date.SafeAdd(TimeSpan.FromHours(1));
341 |     }
342 | 
343 |     public static DateTime LastHour(this DateTime date)
344 |     {
345 |         return date.SafeSubtract(TimeSpan.FromHours(1));
346 |     }
347 | 
348 |     public static DateTime NextDay(this DateTime date)
349 |     {
350 |         return date.SafeAdd(TimeSpan.FromDays(1));
351 |     }
352 | 
353 |     public static DateTime LastDay(this DateTime date)
354 |     {
355 |         return date.SafeSubtract(TimeSpan.FromDays(1));
356 |     }
357 | 
358 |     public static DateTime NextWeek(this DateTime date)
359 |     {
360 |         return date.AddWeeks(1);
361 |     }
362 | 
363 |     public static DateTime LastWeek(this DateTime date)
364 |     {
365 |         return date.SubtractWeeks(1);
366 |     }
367 | 
368 |     public static DateTime NextMonth(this DateTime date)
369 |     {
370 |         return date.AddMonths(1);
371 |     }
372 | 
373 |     public static DateTime LastMonth(this DateTime date)
374 |     {
375 |         return date.SubtractMonths(1);
376 |     }
377 | 
378 |     public static DateTime NextYear(this DateTime date)
379 |     {
380 |         return date.AddYears(1);
381 |     }
382 | 
383 |     public static DateTime LastYear(this DateTime date)
384 |     {
385 |         return date.SubtractYears(1);
386 |     }
387 | 
388 |     public static DateTime SubtractTicks(this DateTime date, long value)
389 |     {
390 |         if (value < 0)
391 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
392 | 
393 |         return date.SafeSubtract(TimeSpan.FromTicks(value));
394 |     }
395 | 
396 |     public static DateTime SubtractMilliseconds(this DateTime date, double value)
397 |     {
398 |         if (value < 0)
399 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
400 | 
401 |         return date.SafeSubtract(TimeSpan.FromMilliseconds(value));
402 |     }
403 | 
404 |     public static DateTime SubtractSeconds(this DateTime date, double value)
405 |     {
406 |         if (value < 0)
407 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
408 | 
409 |         return date.SafeSubtract(TimeSpan.FromSeconds(value));
410 |     }
411 | 
412 |     public static DateTime SubtractMinutes(this DateTime date, double value)
413 |     {
414 |         if (value < 0)
415 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
416 | 
417 |         return date.SafeSubtract(TimeSpan.FromMinutes(value));
418 |     }
419 | 
420 |     public static DateTime SubtractHours(this DateTime date, double value)
421 |     {
422 |         if (value < 0)
423 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
424 | 
425 |         return date.SafeSubtract(TimeSpan.FromHours(value));
426 |     }
427 | 
428 |     public static DateTime SubtractDays(this DateTime date, double value)
429 |     {
430 |         if (value < 0)
431 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
432 | 
433 |         return date.SafeSubtract(TimeSpan.FromDays(value));
434 |     }
435 | 
436 |     public static DateTime AddWeeks(this DateTime date, double value)
437 |     {
438 |         return date.SafeAdd(TimeSpan.FromDays(value * 7));
439 |     }
440 | 
441 |     public static DateTime SubtractWeeks(this DateTime date, double value)
442 |     {
443 |         if (value < 0)
444 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
445 | 
446 |         return date.SafeSubtract(TimeSpan.FromDays(value * 7));
447 |     }
448 | 
449 |     public static DateTime SubtractMonths(this DateTime date, int months)
450 |     {
451 |         if (months < 0)
452 |             throw new ArgumentException("Months cannot be less than 0.", nameof(months));
453 | 
454 |         return date.AddMonths(months * -1);
455 |     }
456 | 
457 |     public static DateTime SubtractYears(this DateTime date, int value)
458 |     {
459 |         if (value < 0)
460 |             throw new ArgumentException("Value cannot be less than 0.", nameof(value));
461 | 
462 |         return date.AddYears(value * -1);
463 |     }
464 | 
465 |     public static bool Intersects(this DateTime source, DateTime start, DateTime end)
466 |     {
467 |         return source >= start && source <= end;
468 |     }
469 | 
470 |     public static bool IntersectsSecond(this DateTime source, DateTime date)
471 |     {
472 |         return source.Intersects(date.StartOfSecond(), date.EndOfSecond());
473 |     }
474 | 
475 |     public static bool IntersectsMinute(this DateTime source, DateTime date)
476 |     {
477 |         return source.Intersects(date.StartOfMinute(), date.EndOfMinute());
478 |     }
479 | 
480 |     public static bool IntersectsHour(this DateTime source, DateTime date)
481 |     {
482 |         return source.Intersects(date.StartOfHour(), date.EndOfHour());
483 |     }
484 | 
485 |     public static bool IntersectsDay(this DateTime source, DateTime date)
486 |     {
487 |         return source.Intersects(date.StartOfDay(), date.EndOfDay());
488 |     }
489 | 
490 |     public static bool IntersectsMonth(this DateTime source, DateTime date)
491 |     {
492 |         return source.Intersects(date.StartOfMonth(), date.EndOfMonth());
493 |     }
494 | 
495 |     public static bool IntersectsYear(this DateTime source, DateTime date)
496 |     {
497 |         return source.Intersects(date.StartOfYear(), date.EndOfYear());
498 |     }
499 | }
500 | 


--------------------------------------------------------------------------------