Features/2023 fixlist

Directory.Build.props

@@ -1,12 +1,13 @@
 <Project>
   <PropertyGroup>
-    <LangVersion>8.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
   </PropertyGroup>
+
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
       <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
   </PropertyGroup>
-  <ItemGroup>
-  </ItemGroup>
-</Project>                                                      
+</Project>

builds/default/build.yml

@@ -15,6 +15,12 @@ steps:
     inputs:
       versionSpec: 5.8.0
 
+  - task: JavaToolInstaller@0
+    inputs:
+      versionSpec: '11'
+      jdkArchitectureOption: 'x64'
+      jdkSourceOption: 'PreInstalled'
+
   - task: NuGetCommand@2
     displayName: 'Nuget restore'
     inputs:

builds/pr-pipeline.yml

@@ -18,6 +18,12 @@ jobs:
     inputs:
       versionSpec: 5.8.0
 
+  - task: JavaToolInstaller@0
+    inputs:
+      versionSpec: '11'
+      jdkArchitectureOption: 'x64'
+      jdkSourceOption: 'PreInstalled'
+
   - task: NuGetCommand@2
     displayName: 'Nuget restore'
     inputs:

src/Features/AllEditions/EditionDescendingComparer.cs

@@ -1,12 +1,11 @@
-using System.Collections.Generic;
-
+
 namespace Chroomsoft.Top2000.Features.AllEditions
 {
     public class EditionDescendingComparer : Comparer<Edition>
     {
-        public override int Compare(Edition x, Edition y)
+        public override int Compare(Edition? x, Edition? y)
         {
-            return y.Year - x.Year;
+            return y?.Year ?? 0 - x?.Year ?? 0;
         }
     }
 }

src/Features/AllListingsOfEdition/AllListingsOfEditionRequest.cs

@@ -1,6 +1,8 @@
 using MediatR;
 using SQLite;
 using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -19,22 +21,36 @@ public AllListingsOfEditionRequest(int year)
     public class AllListingsOfEditionRequestHandler : IRequestHandler<AllListingsOfEditionRequest, ImmutableHashSet<TrackListing>>
     {
         private readonly SQLiteAsyncConnection connection;
+        private readonly TrackCountHolder trackCountHolder;
 
-        public AllListingsOfEditionRequestHandler(SQLiteAsyncConnection connection)
+        public AllListingsOfEditionRequestHandler(SQLiteAsyncConnection connection, TrackCountHolder trackCountHolder)
         {
             this.connection = connection;
+            this.trackCountHolder = trackCountHolder;
         }
 
         public async Task<ImmutableHashSet<TrackListing>> Handle(AllListingsOfEditionRequest request, CancellationToken cancellationToken)
         {
+            var counters = await trackCountHolder.CountTrackCountForEditionAsync(connection, request.Year);
+
             var sql =
                       "SELECT Listing.TrackId, Listing.Position, (p.Position - Listing.Position) AS Delta, Listing.PlayUtcDateAndTime, Title, Artist " +
                       "FROM Listing JOIN Track ON Listing.TrackId = Id " +
                       "LEFT JOIN Listing as p ON p.TrackId = Id AND p.Edition = ? " +
                       $"WHERE Listing.Edition = ?";
 
-            return (await connection.QueryAsync<TrackListing>(sql, request.Year - 1, request.Year).ConfigureAwait(false))
-                .ToImmutableHashSet(new TrackListingComparer());
+            var items = await connection.QueryAsync<TrackListing>(sql, request.Year - 1, request.Year);
+            var itemWithNullDelta = items.Where(x => x.Delta is null);
+            foreach (var item in itemWithNullDelta)
+            {
+                var inCounters = counters.Find(x => x.TrackId == item.TrackId);
+                if (inCounters?.TrackCount > 1)
+                {
+                    item.IsRecurring = true;
+                }
+            }
+
+            return  items.ToImmutableHashSet(new TrackListingComparer());
         }
     }
 }

src/Features/AllListingsOfEdition/TrackCountHolder.cs

@@ -0,0 +1,31 @@
+using SQLite;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Chroomsoft.Top2000.Features.AllListingsOfEdition
+{
+    public class TrackCountHolder
+    {
+        Dictionary<int, List<TrackCounter>> counters = new Dictionary<int, List<TrackCounter>>();
+
+        public async Task<List<TrackCounter>> CountTrackCountForEditionAsync(SQLiteAsyncConnection connection, int edition)
+        {
+            if (!counters.ContainsKey(edition))
+            {
+                var sql = "SELECT TrackId, COUNT(TrackId) AS TrackCount " +
+                    "FROM Listing " +
+                    "WHERE Edition <= ? " +
+                    "GROUP BY TrackId";
+
+                var trackCounters = await connection.QueryAsync<TrackCounter>(sql, edition);
+                var list = trackCounters.Where(x => x.TrackCount > 1).ToList();
+                counters.Add(edition, list);
+            }
+
+            return counters[edition];
+        }
+
+
+    }
+}

src/Features/AllListingsOfEdition/TrackCounter.cs

@@ -0,0 +1,8 @@
+namespace Chroomsoft.Top2000.Features.AllListingsOfEdition
+{
+    public class TrackCounter
+    {
+        public int TrackId { get; set; }
+        public int TrackCount { get; set; }
+    }
+}

src/Features/AllListingsOfEdition/TrackListing.cs

@@ -10,6 +10,8 @@ public class TrackListing
 
         public int? Delta { get; set; }
 
+        public bool IsRecurring { get; set; }
+
         public DateTime LocalPlayDateAndTime => DateTime.SpecifyKind(PlayUtcDateAndTime, DateTimeKind.Utc).ToLocalTime();
 
         public DateTime PlayUtcDateAndTime { get; set; }

src/Features/AllListingsOfEdition/TrackListingComparer.cs

@@ -4,7 +4,7 @@ namespace Chroomsoft.Top2000.Features.AllListingsOfEdition
 {
     public class TrackListingComparer : IEqualityComparer<TrackListing>
     {
-        public bool Equals(TrackListing x, TrackListing y) => x.Position == y.Position;
+        public bool Equals(TrackListing? x, TrackListing? y) => x?.Position == y?.Position;
 
         public int GetHashCode(TrackListing obj) => obj.Position.GetHashCode();
     }

src/Features/ConfigureServices.cs

@@ -1,4 +1,5 @@
-using Chroomsoft.Top2000.Features.Searching;
+using Chroomsoft.Top2000.Features.AllListingsOfEdition;
+using Chroomsoft.Top2000.Features.Searching;
 using MediatR;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -9,7 +10,11 @@ public static class ConfigureServices
         public static IServiceCollection AddFeatures(this IServiceCollection services)
         {
             return services
-                .AddMediatR(typeof(ConfigureServices).Assembly)
+                .AddMediatR(config => 
+                {
+                    config.RegisterServicesFromAssemblyContaining<TrackCountHolder>();
+                })
+                .AddSingleton<TrackCountHolder>()
                 .AddSingleton<ISort, SortByTitle>()
                 .AddSingleton<ISort, SortByArtist>()
                 .AddSingleton<ISort, SortByRecordedYear>()

src/Features/Features.csproj

@@ -1,17 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <AssemblyName>Chroomsoft.Top2000.Features</AssemblyName>
     <RootNamespace>Chroomsoft.Top2000.Features</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MediatR" Version="9.0.0" />
-    <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="9.0.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="5.0.0" />
-    <PackageReference Include="sqlite-net-pcl" Version="1.6.292" />
-    <PackageReference Include="System.Collections.Immutable" Version="1.7.1" />
+    <PackageReference Include="MediatR" Version="12.2.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.0" />
+    <PackageReference Include="sqlite-net-pcl" Version="1.8.116" />
+    <PackageReference Include="System.Collections.Immutable" Version="8.0.0" />
   </ItemGroup>
 
 </Project>

src/Features/Searching/SearchTrackRequest.cs

@@ -43,7 +43,7 @@ public async Task<ReadOnlyCollection<IGrouping<string, Track>>> Handle(SearchTra
                 {
                     var sql = "SELECT Id, Title, Artist, RecordedYear, Listing.Position AS Position " +
                         "FROM Track " +
-                        "LEFT JOIN Listing ON Track.Id = Listing.TrackId AND Listing.Edition = 2021 " +
+                        "LEFT JOIN Listing ON Track.Id = Listing.TrackId AND Listing.Edition = 2023 " +
                         "WHERE RecordedYear = ?" +
                         "LIMIT 100";
 
@@ -53,7 +53,7 @@ public async Task<ReadOnlyCollection<IGrouping<string, Track>>> Handle(SearchTra
                 {
                     var sql = "SELECT Id, Title, Artist, RecordedYear, Listing.Position AS Position " +
                         "FROM Track " +
-                        "LEFT JOIN Listing ON Track.Id = Listing.TrackId AND Listing.Edition = 2021 " +
+                        "LEFT JOIN Listing ON Track.Id = Listing.TrackId AND Listing.Edition = 2023 " +
                         "WHERE (Title LIKE ?) OR (Artist LIKE ?)" +
                         "LIMIT 100";
 

src/Features/Searching/Track.cs

@@ -12,6 +12,6 @@ public class Track
 
         public int? Position { get; set; }
 
-        public string PositionIn2020 => $"2022: {Position?.ToString() ?? "-"}";
+        public string PositionIn2020 => $"2023: {Position?.ToString() ?? "-"}";
     }
 }

src/Features/TrackInformation/ListingInformationDescendingComparer.cs

@@ -4,9 +4,9 @@ namespace Chroomsoft.Top2000.Features.TrackInformation
 {
     public class ListingInformationDescendingComparer : Comparer<ListingInformation>
     {
-        public override int Compare(ListingInformation x, ListingInformation y)
+        public override int Compare(ListingInformation? x, ListingInformation? y)
         {
-            return y.Edition - x.Edition;
+            return y?.Edition ?? 0 - x?.Edition ?? 0;
         }
     }
 }