From 0c752b50076112cf580e440a324b90dab6718d26 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 6 Jul 2026 01:02:49 +0200 Subject: [PATCH 01/44] Update NuGet packages --- Directory.Packages.props | 45 ++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/Directory.Packages.props b/Directory.Packages.props index 068affa..99b320e 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -4,32 +4,33 @@ true - + - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - + + + + + - - - + + + From dc0edcec0cc441fd7b0e08ea4dddde1e82271c6f Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 6 Jul 2026 01:19:51 +0200 Subject: [PATCH 02/44] Minor md change --- CONTRIBUTING.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 8f57029..cac0d35 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -58,7 +58,7 @@ Name | Description ## Configuration -### Web API appsettings +### Web API settings Key | Description ------------------------------------------|-------------------------- @@ -103,7 +103,7 @@ Template for `src/WebApi/appsettings.Development.json`: } ``` -### Blazor Server App appsettings +### Blazor Server App settings Key | Required | Default value ----------------------------------------|----------|-------------- From d8c287607d214a53c108bb8415aa2d64acc73901 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 6 Jul 2026 01:20:11 +0200 Subject: [PATCH 03/44] Fix obsolete warning on Google credentials --- src/BlazorApp/Program.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/BlazorApp/Program.cs b/src/BlazorApp/Program.cs index 296b76e..279b3e3 100644 --- a/src/BlazorApp/Program.cs +++ b/src/BlazorApp/Program.cs @@ -17,7 +17,7 @@ if (FirebaseApp.DefaultInstance is null) { var firebaseJson = builder.Configuration.TryGetSection("Firebase:ServiceAccount"); - var googleCredential = GoogleCredential.FromJson(firebaseJson); + var googleCredential = CredentialFactory.FromJson(firebaseJson).ToGoogleCredential(); FirebaseApp.Create(new AppOptions { Credential = googleCredential }); } builder.Services.AddHttpContextAccessor(); From b6bba5c00bb6c7867a6504f81b0cbb6f87d8f92a Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 6 Jul 2026 01:42:41 +0200 Subject: [PATCH 04/44] Add CLAUDE files --- CLAUDE.md | 118 ++++++++++++++++++++++++++++++++++ Keeptrack.slnx | 2 + docs/code-quality-findings.md | 91 ++++++++++++++++++++++++++ 3 files changed, 211 insertions(+) create mode 100644 CLAUDE.md create mode 100644 docs/code-quality-findings.md diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..946cce3 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,118 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project overview + +Keeptrack is an open source application that lets users save and review everything they read, watch, listen to or play (books, movies, TV shows, music albums, video games, cars/car history). + +It is a three-tier .NET 10 / C# solution: + +- Frontend: `BlazorApp`, a Blazor Server application. +- Backend: `WebApi`, an ASP.NET Web API (REST). +- Database: MongoDB. + +## Commands + +```bash +# restore and build the whole solution +dotnet restore +dotnet build + +# run the Web API (https://localhost:5011/) +dotnet run --project src/WebApi + +# run the Blazor Server app (https://localhost:5021/) +dotnet run --project src/BlazorApp + +# run all tests (uses the Microsoft.Testing.Platform runner, xunit v3) +dotnet test + +# run a single test project +dotnet test test/WebApi.UnitTests/WebApi.UnitTests.csproj +dotnet test test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj + +# run a single test by fully qualified name +dotnet test --filter-method "Keeptrack.WebApi.UnitTests.MappingProfiles.AutoMapperConfigurationTest.WebApiAutoMapperProfile_ShouldBeValid" + +# build container images +docker build . -t devprofr/keeptrack-blazorapp:local -f src/BlazorApp/Dockerfile +docker build . -t devprofr/keeptrack-webapi:local -f src/WebApi/Dockerfile +``` + +A local MongoDB instance is required to run the Web API or the integration tests: + +```bash +docker run --name mongodb -d -p 27017:27017 mongo:8.2 +``` + +Integration tests also need Firebase test-user credentials and MongoDB connection settings. Provide them as environment variables, or in a `Local.runsettings` file at the repository root (see `CONTRIBUTING.md` for the template). Never commit this file. + +## Architecture + +The solution follows a layered / clean-architecture style split across small, single-purpose projects (`src/*`), with `Domain` at the center and no project referencing "outward": + +| Project | Depends on | Responsibility | +|---|---|---| +| `Common.System` | — | Cross-cutting primitives shared by every layer: `IHasId`, `IHasIdAndOwnerId`, `PagedRequest`, `PagedResult`. | +| `Domain` | `Common.System` | Business models (`*Model` in `Models/`) and repository interfaces (`I*Repository` in `Repositories/`). No persistence or web concerns. | +| `Infrastructure.MongoDb` | `Domain` | MongoDB implementation: BSON `Entities/` and `Repositories/` implementing the `Domain` interfaces. | +| `WebApi.Contracts` | `Common.System` | Public REST DTOs (`Dto/`), shared between `WebApi` and `BlazorApp` so the Blazor client can deserialize API responses without duplicating classes. | +| `WebApi` | `Infrastructure.MongoDb`, `Domain`, `WebApi.Contracts` | ASP.NET Web API: controllers, AutoMapper profiles, DI wiring, JWT authentication, OpenAPI/Scalar docs. | +| `BlazorApp` | `Common.System`, `WebApi.Contracts` | Blazor Server UI. Talks to `WebApi` over HTTP using the shared DTOs; it never references `Domain` or `Infrastructure.MongoDb` directly. | + +### Data model conventions + +Every entity that belongs to a user implements `IHasIdAndOwnerId` (`Id` + `OwnerId`) at all three layers (`Domain` model, MongoDB entity, contract DTO), each with its own class. AutoMapper profiles convert between them: + +- `Infrastructure.MongoDb/../MappingProfiles`-equivalent lives in `WebApi/MappingProfiles/DataStorageMappingProfile.cs`: MongoDB entity <-> Domain model. +- `WebApi/MappingProfiles/WebServiceMappingProfile.cs`: DTO <-> Domain model. `OwnerId` is always ignored on the DTO -> model direction; it is set server-side from the authenticated user's claims, never trusted from client input. + +`AutoMapperConfigurationTest` (in `WebApi.UnitTests`) asserts the whole mapping configuration is valid; add a mapping there whenever a new model/entity/DTO triple is introduced. + +### Adding a new trackable item type + +Follow the existing types (`Book`, `Movie`, `MusicAlbum`, `TvShow`, `VideoGame`, `Car`/`CarHistory`) as the template. A new type touches every layer: + +1. `Domain/Models/Model.cs` and `Domain/Repositories/IRepository.cs` (extends `IDataRepository`). +2. `Infrastructure.MongoDb/Entities/.cs` (BSON attributes, `snake_case` element names via `[BsonElement]`) and `Infrastructure.MongoDb/Repositories/Repository.cs` (extends `MongoDbRepositoryBase`, overrides `CollectionName` and, if searchable, `GetFilter`). +3. `WebApi.Contracts/Dto/Dto.cs` (XML doc comments drive the generated OpenAPI spec). +4. `WebApi/Controllers/Controller.cs`: a one-line class extending `DataCrudControllerBase` — CRUD logic is never duplicated per controller. +5. Register the repository in `WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs`. +6. Add both AutoMapper maps (`DataStorageMappingProfile`, `WebServiceMappingProfile`). +7. `BlazorApp/Components/Inventory/Clients/ApiClient.cs` extending `InventoryApiClientBase`, plus a `Pages/.razor` / `.razor.cs` pair extending `InventoryPageBase`. + +### Web API request flow + +`DataCrudControllerBase` (`WebApi/Controllers/DataCrudControllerBase.cs`) implements the full CRUD surface (`GET`, `GET/{id}`, `POST`, `PUT/{id}`, `DELETE/{id}`) once, generically. It reads the caller's `user_id` claim to scope every query and to stamp `OwnerId` on writes, so per-type controllers only need routing and generic type arguments. Unhandled exceptions are converted to JSON error responses by `ApiExceptionFilterAttribute` (`ArgumentException`/`ArgumentNullException` -> 400, everything else -> 500). + +### Blazor app + +`InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, which wraps the typed `HttpClient` calls to the Web API. Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. + +## Code style + +- Enforced by `.editorconfig`: 4-space indent for C#/Razor, LF line endings, `var` preferred everywhere, braces required, `_camelCase` for private instance fields, `s_camelCase` for private static fields, PascalCase for everything else. Avoid `this.` qualification. +- Primary constructors are the norm for controllers, repositories and API clients (see `BookController`, `BookRepository`, `BookApiClient` above). +- Nullable reference types are enabled across all `src` projects; use `required` for non-nullable properties that have no sensible default (e.g. `BookModel.Title`). +- Public WebApi.Contracts DTOs and WebApi controllers carry XML doc comments (`GenerateDocumentationFile` is enabled) because they feed the generated OpenAPI/Scalar documentation. +- Markdown files: 2-space indent, no trailing-whitespace trimming, max line length 240 (`.markdownlint-cli2.yaml`). In addition, write one sentence per line inside multi-sentence paragraphs: never cut a sentence, keep each sentence as short as possible, and start a new line right after the period that ends it. Single-sentence paragraphs/list items don't need to be split further. + +## Tests + +- `test/WebApi.UnitTests`: xunit v3 unit tests, e.g. AutoMapper configuration validation. +- `test/WebApi.IntegrationTests`: xunit v3 tests booted against a real Kestrel host (`KestrelWebAppFactory`) and a real MongoDB instance. `ResourceTestBase` provides typed `GetAsync`/`PostAsync`/`PutAsync`/`DeleteAsync` helpers and an `Authenticate()` helper that logs in against Firebase to obtain a bearer token. Resource tests (`BookResourceTest`, `MovieResourceTest`) exercise a full create/read/update/delete cycle against the live API and clean up what they create. +- Assertions use `AwesomeAssertions` (a `FluentAssertions`-compatible API); test data is generated with `Bogus`. + +## CI + +GitHub Actions (`.github/workflows/ci.yaml`) runs, on push/PR to `main`: a git/markup lint job, a .NET quality job (build, test with coverage, SonarCloud, FOSSA license/security scan) gated on app changes, and a container image scan for both Dockerfiles. Equivalent pipelines exist for GitLab CI and Azure DevOps. + +## Quality bar + +The owner has zero tolerance for bad design or duplicated algorithms. Hold every change to this standard, not just new code. + +- No duplicated algorithms or logic. Duplicated data shapes (a `Model`, an `Entity`, and a `Dto` that mirror the same fields) are fine and expected; duplicating the logic that operates on them is not. If two repositories, controllers, or components need the same behavior, it belongs in a shared base class or method, following the existing `DataCrudControllerBase` / `MongoDbRepositoryBase` / `InventoryPageBase` pattern. +- Every non-trivial piece of logic needs a test, especially per-type overrides like `GetFilter`. These are the most duplicated, least-reused pieces of code in the solution, and history has already shown they are where bugs hide (see `docs/code-quality-findings.md`). +- Before proposing a fix, verify the current best-practice for the specific library/framework version in use (e.g. MongoDB driver filter semantics, current ASP.NET Core guidance) rather than relying on older patterns from training data. +- Known findings from past reviews, including which items are confirmed bugs versus intentional by-design behavior, are tracked in `docs/code-quality-findings.md`. Check it before re-reporting something already triaged there, and update it when a listed item is fixed. diff --git a/Keeptrack.slnx b/Keeptrack.slnx index c48f897..1b6f05a 100644 --- a/Keeptrack.slnx +++ b/Keeptrack.slnx @@ -4,12 +4,14 @@ + + diff --git a/docs/code-quality-findings.md b/docs/code-quality-findings.md new file mode 100644 index 0000000..db38963 --- /dev/null +++ b/docs/code-quality-findings.md @@ -0,0 +1,91 @@ +# Code quality findings + +This document tracks a code review performed on 2026-07-06 against current .NET and MongoDB best practices. +Each finding is classified as a confirmed bug, a confirmed by-design behavior, or a known gap that is not yet implemented. +Update this file as items are fixed or as new reviews are performed. + +## Confirmed bugs + +These are true defects. They should be fixed. + +### Search is a no-op for Movie and Music Album + +`MovieRepository.GetFilter` and `MusicAlbumRepository.GetFilter` build a MongoDB filter with `builder.Where(...)`. +The result is never combined into the returned `filter`. +As a result, the `search` box on the Movies and Music Albums pages currently filters nothing. + +Files: + +- `src/Infrastructure.MongoDb/Repositories/MovieRepository.cs` +- `src/Infrastructure.MongoDb/Repositories/MusicAlbumRepository.cs` + +Fix: combine the built expression back into the filter, e.g. `filter &= builder.Where(...)`. + +### Car and CarHistory search relies on a `$text` index that does not exist + +`CarRepository` has no `GetFilter` override, so it falls back to `MongoDbRepositoryBase.GetFilter`, which calls `builder.Text(search)`. +`CarHistoryRepository.GetFilter` also calls `builder.Text(...)`. +Both require a MongoDB text index on their collection. +`scripts/mongodb-create-index.js` only creates text indexes for `book`, `movie`, `tvshow`, and `videogame`. +No index exists for `car` or `car_history`. +A search request against either resource will throw a runtime error ("text index required for $text query"). + +Files: + +- `src/Infrastructure.MongoDb/Repositories/CarRepository.cs` +- `src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs` +- `scripts/mongodb-create-index.js` + +Fix: either create the missing indexes, or switch these two repositories to the same per-field filter strategy used by Book/TvShow/VideoGame. + +### CarHistory treats a car ID as free text + +`CarHistoryRepository.GetFilter` calls `builder.Text(input.CarId)`. +A car ID is an exact identifier, not a free-text search term, so this is the wrong filter type regardless of the missing index above. +MongoDB also only allows one `$text` expression per query. +If both `input.CarId` and `search` are non-empty at the same time, the query throws ("only one $text expression allowed per query"). + +File: `src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs` + +Fix: filter `CarId` with an equality filter (`builder.Eq(f => f.CarId, input.CarId)`), not `Text`. + +## Confirmed by design + +These were reviewed with the project owner and are intentional. No action needed. + +### Each entity searches its own fields + +`Book` searches `Title` + `Series` + `Author`. +`VideoGame` adds exact-match filters on `Platform` and `State`. +`TvShow` and `Movie` (once fixed) search `Title` only. +This is intentional: each entity type exposes the search behavior that fits its own fields, not a shared generic contract. + +## Known gaps (not yet implemented) + +These are acknowledged as incomplete rather than deliberately permanent. Track and prioritize separately. + +### `Car` has no controller or Blazor page + +`ICarRepository`, `CarRepository`, and their DI registration exist, but there is no `CarController` and no Blazor Inventory page for `Car`. +Only `CarHistoryController` exists, and it references a `CarId` that currently cannot be created through the app. + +### No `CancellationToken` propagation + +Controllers, `MongoDbRepositoryBase`, and `InventoryApiClientBase` (Blazor) do not accept or forward a `CancellationToken`. +Requests keep running server-side work after a client disconnects. +The test project already uses `TestContext.Current.CancellationToken` (xunit v3), so the pattern is known, just not applied to production code yet. + +### No pagination bounds + +`PagedRequest.Page` and `PagedRequest.PageSize` have no `[Range]` validation or clamping. +A negative `Page` produces a negative `Skip` value, which the MongoDB driver rejects. +A very large `PageSize` forces an unbounded fetch. + +### Thin test coverage + +Only `Book` and `Movie` have integration tests (`BookResourceTest`, `MovieResourceTest`). +`CarHistory`, `MusicAlbum`, `TvShow`, and `VideoGame` have none. +No test exercises the `search` query parameter for any resource, which is why the search bugs above went unnoticed. +No test asserts ownership isolation (that user A cannot read, update, or delete user B's record). +There is no test project for `BlazorApp`. +`BookResourceTest` and `MovieResourceTest` are also close to copy-pasted; a generic/parameterized test base (mirroring `DataCrudControllerBase` on the production side) would cover all resources without duplicating the test code per type. From abb7a3aa428aab5fa0ef4fe5504a23a60b31a57c Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 6 Jul 2026 10:44:14 +0200 Subject: [PATCH 05/44] TV Time import step 1 --- CLAUDE.md | 20 +- Directory.Packages.props | 1 + docs/code-quality-findings.md | 23 +- scripts/mongodb-create-index.js | 29 ++ src/BlazorApp/Components/App.razor | 1 + .../Components/Import/ImportPage.razor | 84 ++++ .../Import/TvTimeImportApiClient.cs | 21 + .../Inventory/Clients/EpisodeApiClient.cs | 9 + .../Clients/InventoryApiClientBase.cs | 10 +- .../Components/Inventory/Pages/Movies.razor | 30 ++ .../Inventory/Pages/TvShowDetail.razor | 172 ++++++++ .../Components/Inventory/Pages/TvShows.razor | 34 +- src/BlazorApp/Components/Layout/NavMenu.razor | 17 + .../WatchNext/WatchNextApiClient.cs | 12 + .../Components/WatchNext/WatchNextPage.razor | 79 ++++ ...frastructureServiceCollectionExtensions.cs | 6 + .../wwwroot/Keeptrack.BlazorApp.lib.module.js | 7 + src/BlazorApp/wwwroot/app.css | 402 ++++++++++++------ src/BlazorApp/wwwroot/theme.js | 15 + src/Domain/Models/EpisodeModel.cs | 21 + src/Domain/Models/MovieModel.cs | 4 + src/Domain/Models/TvShowModel.cs | 4 + src/Domain/Repositories/IEpisodeRepository.cs | 7 + .../Entities/Episode.cs | 30 ++ src/Infrastructure.MongoDb/Entities/Movie.cs | 6 + src/Infrastructure.MongoDb/Entities/TvShow.cs | 6 + .../Repositories/EpisodeRepository.cs | 22 + .../Repositories/MovieRepository.cs | 27 +- .../Repositories/MusicAlbumRepository.cs | 4 +- .../Repositories/TvShowRepository.cs | 2 + src/WebApi.Contracts/Dto/EpisodeDto.cs | 37 ++ src/WebApi.Contracts/Dto/ImportResultDto.cs | 26 ++ src/WebApi.Contracts/Dto/MovieDto.cs | 4 + src/WebApi.Contracts/Dto/TvShowDto.cs | 4 + src/WebApi.Contracts/Dto/WatchNextDto.cs | 30 ++ .../Controllers/ControllerBaseExtensions.cs | 15 + .../Controllers/DataCrudControllerBase.cs | 22 +- src/WebApi/Controllers/EpisodeController.cs | 12 + ...frastructureServiceCollectionExtensions.cs | 1 + .../Parsers/EpisodeCommentsCsvParser.cs | 40 ++ .../Parsers/FavoriteMoviesListParser.cs | 63 +++ .../Import/Parsers/FollowedShowsCsvParser.cs | 29 ++ .../Import/Parsers/MovieVotesCsvParser.cs | 36 ++ .../Import/Parsers/SeenEpisodesCsvParser.cs | 37 ++ .../Import/Parsers/ShowCommentsCsvParser.cs | 34 ++ .../Import/Parsers/ShowRatingsCsvParser.cs | 29 ++ .../Import/Parsers/ShowStatusCsvParser.cs | 36 ++ .../Import/Parsers/TvTimeCsvConfiguration.cs | 16 + src/WebApi/Import/TvTimeImportController.cs | 32 ++ src/WebApi/Import/TvTimeImportService.cs | 202 +++++++++ .../DataStorageMappingProfile.cs | 3 + .../WebServiceMappingProfile.cs | 4 + src/WebApi/Program.cs | 2 + src/WebApi/WatchNext/WatchNextController.cs | 39 ++ src/WebApi/WatchNext/WatchNextService.cs | 42 ++ src/WebApi/WebApi.csproj | 1 + .../Resources/MovieResourceTest.cs | 26 +- .../Resources/ResourceTestBase.cs | 15 + .../Resources/TvTimeFixtureZipBuilder.cs | 80 ++++ .../Resources/TvTimeImportResourceTest.cs | 77 ++++ .../Import/Parsers/CsvTestHelper.cs | 9 + .../Parsers/EpisodeCommentsCsvParserTest.cs | 26 ++ .../Parsers/FavoriteMoviesListParserTest.cs | 41 ++ .../Parsers/FollowedShowsCsvParserTest.cs | 24 ++ .../Import/Parsers/MovieVotesCsvParserTest.cs | 39 ++ .../Parsers/SeenEpisodesCsvParserTest.cs | 27 ++ .../Parsers/ShowCommentsCsvParserTest.cs | 22 + .../Parsers/ShowRatingsCsvParserTest.cs | 24 ++ .../Import/Parsers/ShowStatusCsvParserTest.cs | 26 ++ .../WatchNext/WatchNextServiceTest.cs | 91 ++++ 70 files changed, 2241 insertions(+), 187 deletions(-) create mode 100644 src/BlazorApp/Components/Import/ImportPage.razor create mode 100644 src/BlazorApp/Components/Import/TvTimeImportApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Clients/EpisodeApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor create mode 100644 src/BlazorApp/Components/WatchNext/WatchNextApiClient.cs create mode 100644 src/BlazorApp/Components/WatchNext/WatchNextPage.razor create mode 100644 src/BlazorApp/wwwroot/Keeptrack.BlazorApp.lib.module.js create mode 100644 src/BlazorApp/wwwroot/theme.js create mode 100644 src/Domain/Models/EpisodeModel.cs create mode 100644 src/Domain/Repositories/IEpisodeRepository.cs create mode 100644 src/Infrastructure.MongoDb/Entities/Episode.cs create mode 100644 src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs create mode 100644 src/WebApi.Contracts/Dto/EpisodeDto.cs create mode 100644 src/WebApi.Contracts/Dto/ImportResultDto.cs create mode 100644 src/WebApi.Contracts/Dto/WatchNextDto.cs create mode 100644 src/WebApi/Controllers/ControllerBaseExtensions.cs create mode 100644 src/WebApi/Controllers/EpisodeController.cs create mode 100644 src/WebApi/Import/Parsers/EpisodeCommentsCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/FavoriteMoviesListParser.cs create mode 100644 src/WebApi/Import/Parsers/FollowedShowsCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/MovieVotesCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/ShowCommentsCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/ShowRatingsCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/ShowStatusCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/TvTimeCsvConfiguration.cs create mode 100644 src/WebApi/Import/TvTimeImportController.cs create mode 100644 src/WebApi/Import/TvTimeImportService.cs create mode 100644 src/WebApi/WatchNext/WatchNextController.cs create mode 100644 src/WebApi/WatchNext/WatchNextService.cs create mode 100644 test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs create mode 100644 test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/CsvTestHelper.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/EpisodeCommentsCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/FavoriteMoviesListParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/FollowedShowsCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/MovieVotesCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/SeenEpisodesCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/ShowCommentsCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/ShowRatingsCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/ShowStatusCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs diff --git a/CLAUDE.md b/CLAUDE.md index 946cce3..0c34020 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -82,13 +82,25 @@ Follow the existing types (`Book`, `Movie`, `MusicAlbum`, `TvShow`, `VideoGame`, 6. Add both AutoMapper maps (`DataStorageMappingProfile`, `WebServiceMappingProfile`). 7. `BlazorApp/Components/Inventory/Clients/ApiClient.cs` extending `InventoryApiClientBase`, plus a `Pages/.razor` / `.razor.cs` pair extending `InventoryPageBase`. +### Child entities (1-to-many owned by another entity) + +`CarHistory` (owned by `Car`) and `Episode` (owned by `TvShow`) are separate top-level collections referencing their parent by id (`car_id`, `tv_show_id`), not embedded arrays. This is deliberate MongoDB schema design, not an accident: these child collections can grow unbounded per parent over years of use, and features that need to query the child across *all* of a user's parents at once (e.g. Watch Next, below) need a plain indexed query rather than an `$unwind` aggregation. Embedding is the right call for genuinely small, always-together, never-queried-alone data; neither condition holds here. `EpisodeRepository.GetFilter` filters by `input.TvShowId` with `Eq` (not `Text` — see the `CarHistory` bug in `docs/code-quality-findings.md` for what happens when an exact-id filter uses `Text` instead). New multi-word BSON fields get an explicit `[BsonElement("snake_case_name")]`; don't rely on the `CamelCaseElementNameConvention` registered in `AddMongoDbInfrastructure` — every existing multi-word field already overrides it explicitly, so it's effectively dead configuration. Indexes for new collections are declared in `scripts/mongodb-create-index.js` (natural-key uniqueness, query-shape support, and partial indexes for sparse boolean flags like `is_favorite`/`want_to_watch`). + ### Web API request flow -`DataCrudControllerBase` (`WebApi/Controllers/DataCrudControllerBase.cs`) implements the full CRUD surface (`GET`, `GET/{id}`, `POST`, `PUT/{id}`, `DELETE/{id}`) once, generically. It reads the caller's `user_id` claim to scope every query and to stamp `OwnerId` on writes, so per-type controllers only need routing and generic type arguments. Unhandled exceptions are converted to JSON error responses by `ApiExceptionFilterAttribute` (`ArgumentException`/`ArgumentNullException` -> 400, everything else -> 500). +`DataCrudControllerBase` (`WebApi/Controllers/DataCrudControllerBase.cs`) implements the full CRUD surface (`GET`, `GET/{id}`, `POST`, `PUT/{id}`, `DELETE/{id}`) once, generically. It calls the shared `ControllerBaseExtensions.GetUserId()` extension (`WebApi/Controllers/ControllerBaseExtensions.cs`) to read the caller's `user_id` claim, scope every query, and stamp `OwnerId` on writes, so per-type controllers only need routing and generic type arguments — any new controller (CRUD or not) should call the same extension rather than re-reading the claim. Unhandled exceptions are converted to JSON error responses by `ApiExceptionFilterAttribute` (`ArgumentException`/`ArgumentNullException` -> 400, everything else -> 500). + +Not every endpoint is per-item CRUD. `WebApi/WatchNext/` (a read-only cross-entity aggregation) and `WebApi/Import/` (the TV Time GDPR-export upsert, using `CsvHelper` for parsing) are their own feature folders with a plain `ControllerBase` and a small service class, rather than being force-fit into `DataCrudControllerBase`. Follow that folder-per-feature shape for future non-CRUD endpoints instead of stretching the generic CRUD base to cover them. ### Blazor app -`InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, which wraps the typed `HttpClient` calls to the Web API. Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. +`InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, which wraps the typed `HttpClient` calls to the Web API (its `GetAsync` takes an optional extra-query-parameters dictionary, used by features that filter on more than search/page/pageSize). Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. + +Pages that aren't a generic CRUD list (`TvShowDetail.razor`, `WatchNext/WatchNextPage.razor`, `Import/ImportPage.razor`) don't extend `InventoryPageBase`/`InventoryList` — they're free to build their own layout on top of the shared `kt-*` CSS classes in `app.css`. Their API clients live next to them in a feature folder rather than in `Inventory/Clients/`. + +### Theme + +`app.css` is a light+dark theme driven by `data-bs-theme` on `` (Bootstrap 5.3's native color-mode support), with Keeptrack's own `--kt-*` tokens layered on top for custom components (sidebar, `kt-table-wrap`, `kt-modal`, etc.). `wwwroot/theme.js` sets the initial theme from `localStorage`/`prefers-color-scheme` before first paint (avoiding a flash of the wrong theme) and exposes `ktToggleTheme()`, called directly from a plain button in `NavMenu.razor` — no Blazor/JS interop needed for the toggle itself. Use system-ui fonts only; no decorative/display webfonts. ## Code style @@ -100,8 +112,8 @@ Follow the existing types (`Book`, `Movie`, `MusicAlbum`, `TvShow`, `VideoGame`, ## Tests -- `test/WebApi.UnitTests`: xunit v3 unit tests, e.g. AutoMapper configuration validation. -- `test/WebApi.IntegrationTests`: xunit v3 tests booted against a real Kestrel host (`KestrelWebAppFactory`) and a real MongoDB instance. `ResourceTestBase` provides typed `GetAsync`/`PostAsync`/`PutAsync`/`DeleteAsync` helpers and an `Authenticate()` helper that logs in against Firebase to obtain a bearer token. Resource tests (`BookResourceTest`, `MovieResourceTest`) exercise a full create/read/update/delete cycle against the live API and clean up what they create. +- `test/WebApi.UnitTests`: xunit v3 unit tests, e.g. AutoMapper configuration validation, the TV Time import parsers (`Import/Parsers/`, pure stream-in/records-out, no I/O beyond an in-memory stream), and `WatchNextService` (pure next-episode computation). +- `test/WebApi.IntegrationTests`: xunit v3 tests booted against a real Kestrel host (`KestrelWebAppFactory`) and a real MongoDB instance. `ResourceTestBase` provides typed `GetAsync`/`PostAsync`/`PutAsync`/`DeleteAsync`/`PostFileAsync` helpers and an `Authenticate()` helper that logs in against Firebase to obtain a bearer token. Resource tests (`BookResourceTest`, `MovieResourceTest`, `TvTimeImportResourceTest`) exercise a full create/read/update/delete (or upsert) cycle against the live API and clean up what they create. `TvTimeFixtureZipBuilder` builds a small synthetic TV Time export in memory for the import test — never commit a real personal export as a test fixture. - Assertions use `AwesomeAssertions` (a `FluentAssertions`-compatible API); test data is generated with `Bogus`. ## CI diff --git a/Directory.Packages.props b/Directory.Packages.props index 99b320e..1bd8407 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -8,6 +8,7 @@ + diff --git a/docs/code-quality-findings.md b/docs/code-quality-findings.md index db38963..ebde40a 100644 --- a/docs/code-quality-findings.md +++ b/docs/code-quality-findings.md @@ -4,22 +4,23 @@ This document tracks a code review performed on 2026-07-06 against current .NET Each finding is classified as a confirmed bug, a confirmed by-design behavior, or a known gap that is not yet implemented. Update this file as items are fixed or as new reviews are performed. -## Confirmed bugs - -These are true defects. They should be fixed. +## Fixed -### Search is a no-op for Movie and Music Album +### Search was a no-op for Movie and Music Album -`MovieRepository.GetFilter` and `MusicAlbumRepository.GetFilter` build a MongoDB filter with `builder.Where(...)`. -The result is never combined into the returned `filter`. -As a result, the `search` box on the Movies and Music Albums pages currently filters nothing. +Fixed on 2026-07-06 while building the TV Time import feature (both repositories were touched anyway to add the `IsFavorite`/`WantToWatch` filters). +`MovieRepository.GetFilter` and `MusicAlbumRepository.GetFilter` built a MongoDB filter with `builder.Where(...)` but never combined the result back into the returned `filter`. +Both now do `filter &= builder.Where(...)`. +A regression test (`MovieResourceTest.MovieResourceSearch_FiltersToMatchingTitle_IsOk`) locks in the Movie fix; `MusicAlbum` still has no integration test at all (see "Thin test coverage" below), so its fix is unverified beyond the code change itself. Files: - `src/Infrastructure.MongoDb/Repositories/MovieRepository.cs` - `src/Infrastructure.MongoDb/Repositories/MusicAlbumRepository.cs` -Fix: combine the built expression back into the filter, e.g. `filter &= builder.Where(...)`. +## Confirmed bugs + +These are true defects. They should be fixed. ### Car and CarHistory search relies on a `$text` index that does not exist @@ -83,9 +84,9 @@ A very large `PageSize` forces an unbounded fetch. ### Thin test coverage -Only `Book` and `Movie` have integration tests (`BookResourceTest`, `MovieResourceTest`). -`CarHistory`, `MusicAlbum`, `TvShow`, and `VideoGame` have none. -No test exercises the `search` query parameter for any resource, which is why the search bugs above went unnoticed. +`Book` and `Movie` have integration tests (`BookResourceTest`, `MovieResourceTest`); `Movie`'s now also covers `?search=`. +`Episode` and `TvShow` gained partial coverage as a side effect of `TvTimeImportResourceTest` (create/upsert/search paths, plus `Episode`'s `TvShowId` filter), but neither has a dedicated full CRUD test of its own yet. +`CarHistory`, `MusicAlbum`, and `VideoGame` still have none. No test asserts ownership isolation (that user A cannot read, update, or delete user B's record). There is no test project for `BlazorApp`. `BookResourceTest` and `MovieResourceTest` are also close to copy-pasted; a generic/parameterized test base (mirroring `DataCrudControllerBase` on the production side) would cover all resources without duplicating the test code per type. diff --git a/scripts/mongodb-create-index.js b/scripts/mongodb-create-index.js index fc7e275..6198f37 100644 --- a/scripts/mongodb-create-index.js +++ b/scripts/mongodb-create-index.js @@ -2,3 +2,32 @@ db.book.createIndex({ title: "text" }, { name: "book_text" }); db.movie.createIndex({ title: "text" }, { name: "movie_text" }); db.tvshow.createIndex({ title: "text" }, { name: "tvshow_text" }); db.videogame.createIndex({ title: "text" }, { name: "videogame_text" }); + +// episode: enforces the (show, season, episode) natural key and makes re-imports idempotent at the database level +db.episode.createIndex( + { owner_id: 1, tv_show_id: 1, season_number: 1, episode_number: 1 }, + { name: "episode_natural_key", unique: true } +); +// episode: supports the Watch Next "most recently watched episode per show" lookup +db.episode.createIndex( + { owner_id: 1, tv_show_id: 1, watched_at: -1 }, + { name: "episode_last_watched" } +); + +// movie / tvshow: partial indexes over the sparse favorite/want-to-watch flags (most documents are false) +db.movie.createIndex( + { owner_id: 1, is_favorite: 1 }, + { name: "movie_favorite", partialFilterExpression: { is_favorite: true } } +); +db.movie.createIndex( + { owner_id: 1, want_to_watch: 1 }, + { name: "movie_want_to_watch", partialFilterExpression: { want_to_watch: true } } +); +db.tvshow.createIndex( + { owner_id: 1, is_favorite: 1 }, + { name: "tvshow_favorite", partialFilterExpression: { is_favorite: true } } +); +db.tvshow.createIndex( + { owner_id: 1, want_to_watch: 1 }, + { name: "tvshow_want_to_watch", partialFilterExpression: { want_to_watch: true } } +); diff --git a/src/BlazorApp/Components/App.razor b/src/BlazorApp/Components/App.razor index 5d44783..db1b5fc 100644 --- a/src/BlazorApp/Components/App.razor +++ b/src/BlazorApp/Components/App.razor @@ -6,6 +6,7 @@ + diff --git a/src/BlazorApp/Components/Import/ImportPage.razor b/src/BlazorApp/Components/Import/ImportPage.razor new file mode 100644 index 0000000..95a5f8d --- /dev/null +++ b/src/BlazorApp/Components/Import/ImportPage.razor @@ -0,0 +1,84 @@ +@page "/import" +@rendermode InteractiveServer +@attribute [Authorize] + +
+

Import from TV Time

+
+ +
+

+ Upload the zip file from TV Time's "Download my data" (GDPR) export. + Keeptrack reads your followed shows, episode watch history, ratings, favorite/want-to-watch status, + comments, and movies, and upserts them into your account. + Safe to run more than once. +

+ +
+ 📦 + +
+ + @if (_importing) + { +
+ + Importing… +
+ } + + @if (_error is not null) + { +
@_error
+ } + + @if (_result is not null) + { +
+

Shows: @_result.ShowsCreated created, @_result.ShowsUpdated updated

+

Episodes: @_result.EpisodesCreated created, @_result.EpisodesUpdated updated

+

Movies: @_result.MoviesCreated created, @_result.MoviesUpdated updated

+ @if (_result.Warnings.Count > 0) + { +
+

Warnings:

+
    + @foreach (var warning in _result.Warnings) + { +
  • @warning
    • + } +
+ } +
+ } +
+ +@code { + private const long MaxFileSize = 50_000_000; + + [Inject] private TvTimeImportApiClient ImportApi { get; set; } = null!; + + private bool _importing; + private string? _error; + private ImportResultDto? _result; + + private async Task OnFileSelectedAsync(InputFileChangeEventArgs e) + { + _importing = true; + _error = null; + _result = null; + try + { + await using var stream = e.File.OpenReadStream(MaxFileSize); + _result = await ImportApi.ImportAsync(stream, e.File.Name); + } + catch (Exception ex) + { + _error = ex.Message; + } + finally + { + _importing = false; + } + } +} diff --git a/src/BlazorApp/Components/Import/TvTimeImportApiClient.cs b/src/BlazorApp/Components/Import/TvTimeImportApiClient.cs new file mode 100644 index 0000000..7e499f9 --- /dev/null +++ b/src/BlazorApp/Components/Import/TvTimeImportApiClient.cs @@ -0,0 +1,21 @@ +using System.Net.Http.Headers; +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Import; + +public sealed class TvTimeImportApiClient(HttpClient http) +{ + public async Task ImportAsync(Stream zipStream, string fileName) + { + using var content = new MultipartFormDataContent(); + using var fileContent = new StreamContent(zipStream); + fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/zip"); + content.Add(fileContent, "file", fileName); + + var response = await http.PostAsync("/api/import/tv-time", content); + response.EnsureSuccessStatusCode(); + + var result = await response.Content.ReadFromJsonAsync(); + return result ?? new ImportResultDto(); + } +} diff --git a/src/BlazorApp/Components/Inventory/Clients/EpisodeApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/EpisodeApiClient.cs new file mode 100644 index 0000000..71eee17 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Clients/EpisodeApiClient.cs @@ -0,0 +1,9 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Inventory.Clients; + +public sealed class EpisodeApiClient(HttpClient http) + : InventoryApiClientBase(http) +{ + protected override string ApiResourceName => "/api/episodes"; +} diff --git a/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs b/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs index 5231937..1c4497e 100644 --- a/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs +++ b/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs @@ -7,9 +7,17 @@ public abstract class InventoryApiClientBase(HttpClient http) { protected abstract string ApiResourceName { get; } - public async Task> GetAsync(string search, int page, int pageSize) + public async Task> GetAsync(string search, int page, int pageSize, IReadOnlyDictionary? extraQuery = null) { var query = $"{ApiResourceName}?search={Uri.EscapeDataString(search)}&page={page}&pageSize={pageSize}"; + if (extraQuery is not null) + { + foreach (var (key, value) in extraQuery) + { + query += $"&{Uri.EscapeDataString(key)}={Uri.EscapeDataString(value)}"; + } + } + var result = await http.GetFromJsonAsync>(query); return result ?? new PagedResult([], 0, 1, 1); } diff --git a/src/BlazorApp/Components/Inventory/Pages/Movies.razor b/src/BlazorApp/Components/Inventory/Pages/Movies.razor index 5363fae..4ace1a5 100644 --- a/src/BlazorApp/Components/Inventory/Pages/Movies.razor +++ b/src/BlazorApp/Components/Inventory/Pages/Movies.razor @@ -32,12 +32,23 @@ Year Rating First seen + @movie.Title @(movie.Year > 0 ? movie.Year : "") @movie.FirstSeenAt?.ToString("yyyy-MM-dd") + + @if (movie.IsFavorite) + { + ⭐ + } + @if (movie.WantToWatch) + { + 👁 + } + @@ -45,6 +56,14 @@ +
+ + +
+
+ + +
@@ -71,5 +90,16 @@
+
+ +
+ + +
+
+ + +
+
diff --git a/src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor b/src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor new file mode 100644 index 0000000..6961015 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor @@ -0,0 +1,172 @@ +@page "/tv-shows/{Id}" +@rendermode InteractiveServer +@attribute [Authorize] + +@if (_loading) +{ +
+ + Loading… +
+} +else if (_show is null) +{ +
+
◈
+

Show not found.

+
+} +else +{ +
+

@_show.Title

+
+ + +
+
+ +
+
+
+ +
+
+
+ +
@_show.Notes
+
+
+
+ +

Add episode watched

+
+
+
+ + +
+
+ + +
+
+ + +
+
+ +
+
+ @if (_error is not null) + { +
@_error
+ } +
+ + @if (_seasons.Count == 0) + { +
+
◈
+

No episodes tracked yet.

+
+ } + else + { +
+ @foreach (var season in _seasons) + { + + } +
+ +
+
Season @_selectedSeason
+ @foreach (var episode in _episodesBySeason[_selectedSeason]) + { +
+ E@(episode.EpisodeNumber.ToString("00")) + @episode.Notes + @episode.WatchedAt?.ToString("yyyy-MM-dd") +
+ } +
+ } +} + +@code { + [Parameter] public required string Id { get; set; } + + [Inject] private TvShowApiClient TvShowApi { get; set; } = null!; + + [Inject] private EpisodeApiClient EpisodeApi { get; set; } = null!; + + private bool _loading = true; + private TvShowDto? _show; + private Dictionary> _episodesBySeason = new(); + private List _seasons = []; + private int _selectedSeason; + private string? _error; + + private int _newSeason = 1; + private int _newEpisode = 1; + private DateOnly? _newWatchedAt = DateOnly.FromDateTime(DateTime.Today); + + protected override async Task OnParametersSetAsync() => await LoadAsync(); + + private async Task LoadAsync() + { + _loading = true; + _show = await TvShowApi.GetOneAsync(Id); + var episodes = await EpisodeApi.GetAsync(string.Empty, 1, 5000, new Dictionary { ["TvShowId"] = Id }); + + // most recently aired first: latest season at the top, latest episode within a season at the top + _episodesBySeason = episodes.Items + .GroupBy(e => e.SeasonNumber) + .ToDictionary(g => g.Key, g => g.OrderByDescending(e => e.EpisodeNumber).ToList()); + _seasons = _episodesBySeason.Keys.OrderByDescending(s => s).ToList(); + + if (!_seasons.Contains(_selectedSeason)) + { + _selectedSeason = _seasons.Count > 0 ? _seasons[0] : 0; + } + + _loading = false; + } + + private void SelectSeason(int season) => _selectedSeason = season; + + private async Task ToggleFavoriteAsync() + { + if (_show is null) return; + _show.IsFavorite = !_show.IsFavorite; + await TvShowApi.UpdateAsync(_show); + } + + private async Task ToggleWantToWatchAsync() + { + if (_show is null) return; + _show.WantToWatch = !_show.WantToWatch; + await TvShowApi.UpdateAsync(_show); + } + + private async Task AddEpisodeAsync() + { + try + { + await EpisodeApi.AddAsync(new EpisodeDto + { + TvShowId = Id, + SeasonNumber = _newSeason, + EpisodeNumber = _newEpisode, + WatchedAt = _newWatchedAt + }); + _error = null; + await LoadAsync(); + } + catch (Exception ex) + { + _error = ex.Message; + } + } +} diff --git a/src/BlazorApp/Components/Inventory/Pages/TvShows.razor b/src/BlazorApp/Components/Inventory/Pages/TvShows.razor index c963dba..4af0e03 100644 --- a/src/BlazorApp/Components/Inventory/Pages/TvShows.razor +++ b/src/BlazorApp/Components/Inventory/Pages/TvShows.razor @@ -31,16 +31,37 @@ Title Last episode seen Rating + - @show.Title + + @show.Title + @show.LastEpisodeSeen + + @if (show.IsFavorite) + { + ⭐ + } + @if (show.WantToWatch) + { + 👁 + } + +
+ + +
+
+ + +
@@ -67,5 +88,16 @@
+
+ +
+ + +
+
+ + +
+
diff --git a/src/BlazorApp/Components/Layout/NavMenu.razor b/src/BlazorApp/Components/Layout/NavMenu.razor index 66a22a4..ab8509d 100644 --- a/src/BlazorApp/Components/Layout/NavMenu.razor +++ b/src/BlazorApp/Components/Layout/NavMenu.razor @@ -14,6 +14,11 @@ +
+ + ▶️ Watch next + +
📚 Books @@ -39,7 +44,19 @@ 🎮 Video games
+
+ + ⬆️ Import + +
+
+ +
👤 diff --git a/src/BlazorApp/Components/WatchNext/WatchNextApiClient.cs b/src/BlazorApp/Components/WatchNext/WatchNextApiClient.cs new file mode 100644 index 0000000..795a530 --- /dev/null +++ b/src/BlazorApp/Components/WatchNext/WatchNextApiClient.cs @@ -0,0 +1,12 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.WatchNext; + +public sealed class WatchNextApiClient(HttpClient http) +{ + public async Task GetAsync() + { + var result = await http.GetFromJsonAsync("/api/watch-next"); + return result ?? new WatchNextDto(); + } +} diff --git a/src/BlazorApp/Components/WatchNext/WatchNextPage.razor b/src/BlazorApp/Components/WatchNext/WatchNextPage.razor new file mode 100644 index 0000000..fdcb5f2 --- /dev/null +++ b/src/BlazorApp/Components/WatchNext/WatchNextPage.razor @@ -0,0 +1,79 @@ +@page "/watch-next" +@rendermode InteractiveServer +@attribute [Authorize] + +
+

Watch next

+
+ +@if (_loading) +{ +
+ + Loading… +
+} +else +{ +

Continue watching

+ @if (_data.NextEpisodes.Count == 0) + { +
+
◈
+

No shows in progress. Mark an episode as watched to get suggestions here.

+
+ } + else + { +
+ @foreach (var next in _data.NextEpisodes) + { + + S@(next.NextSeasonNumber.ToString("00"))E@(next.NextEpisodeNumber.ToString("00")) +

@next.TvShowTitle

+ @if (next.LastWatchedAt is not null) + { +

Last watched @next.LastWatchedAt.Value.ToString("yyyy-MM-dd")

+ } + + } +
+ } + +

Movies to watch

+ @if (_data.MoviesToWatch.Count == 0) + { +
+
◈
+

Your movie watchlist is empty. Mark a movie as "want to watch" to see it here.

+
+ } + else + { +
+ @foreach (var movie in _data.MoviesToWatch) + { +
+

@movie.Title

+ @if (movie.Year > 0) + { +

@movie.Year

+ } +
+ } +
+ } +} + +@code { + [Inject] private WatchNextApiClient WatchNextApi { get; set; } = null!; + + private bool _loading = true; + private WatchNextDto _data = new(); + + protected override async Task OnInitializedAsync() + { + _data = await WatchNextApi.GetAsync(); + _loading = false; + } +} diff --git a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index dbae844..a25ef9f 100644 --- a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -7,6 +7,8 @@ internal static void AddWebApiHttpClient(this IServiceCollection services, strin var webApiUri = new Uri(webApiBaseUrl); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) @@ -15,5 +17,9 @@ internal static void AddWebApiHttpClient(this IServiceCollection services, strin .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); } } diff --git a/src/BlazorApp/wwwroot/Keeptrack.BlazorApp.lib.module.js b/src/BlazorApp/wwwroot/Keeptrack.BlazorApp.lib.module.js new file mode 100644 index 0000000..2022a49 --- /dev/null +++ b/src/BlazorApp/wwwroot/Keeptrack.BlazorApp.lib.module.js @@ -0,0 +1,7 @@ +// JS initializer, auto-detected and loaded by Blazor (file name must match the assembly name). +// Re-applies the theme after enhanced navigation, since data-bs-theme is set by client-side JS +// (theme.js) rather than server-rendered markup, so Blazor's enhanced-navigation DOM diff would +// otherwise drop it whenever it merges in a freshly server-rendered page. +export function afterWebStarted(blazor) { + blazor.addEventListener('enhancedload', ktApplyTheme); +} diff --git a/src/BlazorApp/wwwroot/app.css b/src/BlazorApp/wwwroot/app.css index ba46082..aff89dd 100644 --- a/src/BlazorApp/wwwroot/app.css +++ b/src/BlazorApp/wwwroot/app.css @@ -1,58 +1,82 @@ /* ═══════════════════════════════════════════════════════════════════ - KEEPTRACK — Cinema-grade dark theme v3 - Bootstrap 5.3.3 override layer + KEEPTRACK — theme layer (light + dark) + Bootstrap 5.3 override layer, driven by [data-bs-theme] on ═══════════════════════════════════════════════════════════════════ */ -@import url('https://fonts.googleapis.com/css2?family=Playfair+Display:ital,wght@0,400;0,600;0,700;1,400;1,600&family=DM+Sans:wght@300;400;500;600&display=swap'); - -/* ── Variables ─────────────────────────────────────────────────────── */ +/* ── Tokens: light (default) ──────────────────────────────────────── */ :root { - --kt-bg: #0d0f14; - --kt-surface: #13161e; - --kt-surface-2: #1a1e28; - --kt-surface-3: #222636; - --kt-border: rgba(255,255,255,0.08); - --kt-border-hover: rgba(255,255,255,0.16); - --kt-amber: #e8a045; - --kt-amber-dim: #c4843a; - --kt-amber-glow: rgba(232,160,69,0.12); - --kt-text: #e8e6e1; - --kt-text-muted: #7a7d8a; - --kt-text-subtle: #3e414e; - --kt-danger: #c0485a; - --kt-success: #3d9970; + color-scheme: light; + + --kt-bg: #f6f7f9; + --kt-surface: #ffffff; + --kt-surface-2: #f1f2f5; + --kt-surface-3: #eceef1; + --kt-border: rgba(15, 18, 25, 0.10); + --kt-border-hover: rgba(15, 18, 25, 0.18); + --kt-accent: #2f6fed; + --kt-accent-dim: #1f56c4; + --kt-accent-glow: rgba(47, 111, 237, 0.10); + --kt-text: #1a1d23; + --kt-text-muted: #5f6570; + --kt-text-subtle: #b1b6bd; + --kt-danger: #c73a52; + --kt-success: #2b8a5e; --kt-radius: 10px; --kt-radius-lg: 14px; - --kt-shadow: 0 4px 24px rgba(0,0,0,0.5); - --kt-shadow-lg: 0 12px 48px rgba(0,0,0,0.7); - --kt-font-display: 'Playfair Display', Georgia, serif; - --kt-font-ui: 'DM Sans', system-ui, sans-serif; - --kt-transition: 0.18s cubic-bezier(0.4, 0, 0.2, 1); - - /* Bootstrap overrides */ - --bs-body-bg: #0d0f14; - --bs-body-color: #e8e6e1; - --bs-border-color: rgba(255,255,255,0.08); + --kt-shadow: 0 2px 10px rgba(15, 18, 25, 0.06); + --kt-shadow-lg: 0 12px 36px rgba(15, 18, 25, 0.14); + --kt-font: system-ui, -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; + --kt-transition: 0.15s ease; + + --bs-body-bg: var(--kt-bg); + --bs-body-color: var(--kt-text); + --bs-border-color: var(--kt-border); --bs-table-bg: transparent; - --bs-table-color: #e8e6e1; - --bs-table-border-color: rgba(255,255,255,0.08); + --bs-table-color: var(--kt-text); + --bs-table-border-color: var(--kt-border); --bs-table-striped-bg: transparent; - --bs-table-hover-bg: #1a1e28; - --bs-table-active-bg: #1a1e28; + --bs-table-hover-bg: var(--kt-surface-2); + --bs-table-active-bg: var(--kt-surface-2); +} + +/* ── Tokens: dark ──────────────────────────────────────────────────── */ +:root[data-bs-theme="dark"] { + color-scheme: dark; + + --kt-bg: #14161a; + --kt-surface: #1b1e24; + --kt-surface-2: #23262d; + --kt-surface-3: #2b2f37; + --kt-border: rgba(255, 255, 255, 0.08); + --kt-border-hover: rgba(255, 255, 255, 0.16); + --kt-accent: #5b9dff; + --kt-accent-dim: #3f7fe0; + --kt-accent-glow: rgba(91, 157, 255, 0.14); + --kt-text: #e6e8eb; + --kt-text-muted: #9aa0aa; + --kt-text-subtle: #565c66; + --kt-danger: #e0687a; + --kt-success: #4cb489; + --kt-shadow: 0 4px 20px rgba(0, 0, 0, 0.35); + --kt-shadow-lg: 0 16px 48px rgba(0, 0, 0, 0.5); + + --bs-body-bg: var(--kt-bg); + --bs-body-color: var(--kt-text); + --bs-border-color: var(--kt-border); + --bs-table-hover-bg: var(--kt-surface-2); + --bs-table-active-bg: var(--kt-surface-2); } /* ── Base ──────────────────────────────────────────────────────────── */ *, *::before, *::after { box-sizing: border-box; } -html { color-scheme: dark; } - html, body { height: 100%; margin: 0; padding: 0; - background-color: var(--kt-bg) !important; - color: var(--kt-text) !important; - font-family: var(--kt-font-ui); + background-color: var(--kt-bg); + color: var(--kt-text); + font-family: var(--kt-font); font-size: 15px; font-weight: 400; line-height: 1.6; @@ -60,14 +84,14 @@ html, body { } h1, h2, h3, h4 { - font-family: var(--kt-font-display); + font-family: var(--kt-font); font-weight: 600; - letter-spacing: -0.02em; + letter-spacing: -0.01em; color: var(--kt-text); } -a { color: var(--kt-amber); text-decoration: none; transition: color var(--kt-transition); } -a:hover { color: var(--kt-text); } +a { color: var(--kt-accent); text-decoration: none; transition: color var(--kt-transition); } +a:hover { color: var(--kt-accent-dim); } /* ── Layout ────────────────────────────────────────────────────────── */ .page { @@ -76,7 +100,6 @@ a:hover { color: var(--kt-text); } background: var(--kt-bg); } -/* The main column fills all remaining space */ .main { flex: 1 1 0%; min-width: 0; @@ -85,8 +108,6 @@ a:hover { color: var(--kt-text); } overflow-x: hidden; } -/* Content area — covers both article.content (our layout) and - div.content (Blazor default template). Centered with max-width. */ article.content, div.content, .content { @@ -119,21 +140,19 @@ div.content, border-bottom: 1px solid var(--kt-border); } -/* Hide the default Blazor top-row inside .main (About link etc) */ .main > .top-row { display: none; } .navbar-brand { - font-family: var(--kt-font-display); - font-size: 1.25rem; + font-size: 1.2rem; font-weight: 700; color: var(--kt-text) !important; - letter-spacing: -0.02em; + letter-spacing: -0.01em; display: flex; align-items: center; gap: 0.5rem; text-decoration: none !important; } -.navbar-brand::before { content: '◈'; color: var(--kt-amber); font-size: 0.95rem; } +.navbar-brand::before { content: '◈'; color: var(--kt-accent); font-size: 0.95rem; } .navbar-toggler { display: none; @@ -147,12 +166,10 @@ div.content, line-height: 1; } -/* Hide the checkbox input, show only the label */ #nav-toggle { display: none !important; } -/* Hamburger label — visible on mobile */ .navbar-toggler-label { display: none; background: none; @@ -192,24 +209,20 @@ div.content, line-height: 1.4; } .nav-link:hover { color: var(--kt-text) !important; background: var(--kt-surface-2) !important; } -.nav-link.active { color: var(--kt-amber) !important; background: var(--kt-amber-glow) !important; } -button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0.08) !important; } +.nav-link.active { color: var(--kt-accent) !important; background: var(--kt-accent-glow) !important; } +button.nav-link:hover { color: var(--kt-danger) !important; background: rgba(199, 58, 82, 0.08) !important; } -/* nav-icon span used instead of pseudo-elements to avoid encoding issues */ .nav-icon { width: 16px; text-align: center; flex-shrink: 0; font-style: normal; - opacity: 0.7; -} - -.nav-link-user { + opacity: 0.8; } .nav-link-logout:hover { - color: #e07070 !important; - background: rgba(192,72,90,0.08) !important; + color: var(--kt-danger) !important; + background: rgba(199, 58, 82, 0.08) !important; } .nav-username { @@ -222,27 +235,49 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. .nav-divider { border-top: 1px solid var(--kt-border); margin: 0.75rem 0; } +/* ── Theme toggle ──────────────────────────────────────────────────── */ +.kt-theme-toggle { + display: flex !important; + align-items: center; + gap: 0.6rem; + width: 100%; + padding: 0.5rem 0.75rem; + border-radius: 7px; + border: none; + background: none; + color: var(--kt-text-muted); + font-size: 0.875rem; + font-weight: 500; + font-family: var(--kt-font); + cursor: pointer; + text-align: left; +} +.kt-theme-toggle:hover { color: var(--kt-text); background: var(--kt-surface-2); } +.kt-theme-toggle .nav-icon { opacity: 1; } +[data-bs-theme="dark"] .kt-theme-toggle .kt-theme-icon-dark { display: none; } +[data-bs-theme="light"] .kt-theme-toggle .kt-theme-icon-light { display: none; } +:root:not([data-bs-theme]) .kt-theme-toggle .kt-theme-icon-light { display: none; } + /* ── Buttons ───────────────────────────────────────────────────────── */ .btn { - font-family: var(--kt-font-ui) !important; + font-family: var(--kt-font) !important; font-weight: 500 !important; font-size: 0.85rem !important; border-radius: 8px !important; padding: 0.5rem 1.1rem !important; transition: all var(--kt-transition) !important; - letter-spacing: 0.01em; line-height: 1.4; } -.btn-primary { background: var(--kt-amber) !important; color: #0d0f14 !important; border-color: var(--kt-amber) !important; } -.btn-primary:hover { background: #f0b060 !important; border-color: #f0b060 !important; color: #0d0f14 !important; box-shadow: 0 0 0 3px rgba(232,160,69,0.22) !important; } +.btn-primary { background: var(--kt-accent) !important; color: #fff !important; border-color: var(--kt-accent) !important; } +.btn-primary:hover { background: var(--kt-accent-dim) !important; border-color: var(--kt-accent-dim) !important; color: #fff !important; box-shadow: 0 0 0 3px var(--kt-accent-glow) !important; } .btn-secondary { background: var(--kt-surface-3) !important; color: var(--kt-text-muted) !important; border-color: var(--kt-border) !important; } -.btn-secondary:hover { background: #2a2f40 !important; color: var(--kt-text) !important; border-color: var(--kt-border-hover) !important; box-shadow: none !important; } +.btn-secondary:hover { background: var(--kt-surface-2) !important; color: var(--kt-text) !important; border-color: var(--kt-border-hover) !important; box-shadow: none !important; } .btn-success { background: var(--kt-success) !important; color: #fff !important; border-color: var(--kt-success) !important; } -.btn-success:hover { background: #4aad82 !important; border-color: #4aad82 !important; } -.btn-outline-danger { background: transparent !important; color: var(--kt-danger) !important; border-color: rgba(192,72,90,0.35) !important; } -.btn-outline-danger:hover { background: rgba(192,72,90,0.12) !important; color: #d45a6c !important; border-color: var(--kt-danger) !important; box-shadow: none !important; } -.btn-outline-primary { background: transparent !important; color: var(--kt-amber) !important; border-color: rgba(232,160,69,0.35) !important; } -.btn-outline-primary:hover { background: var(--kt-amber-glow) !important; color: var(--kt-amber) !important; border-color: rgba(232,160,69,0.6) !important; box-shadow: none !important; } +.btn-success:hover { filter: brightness(1.08); border-color: var(--kt-success) !important; } +.btn-outline-danger { background: transparent !important; color: var(--kt-danger) !important; border-color: rgba(199, 58, 82, 0.35) !important; } +.btn-outline-danger:hover { background: rgba(199, 58, 82, 0.10) !important; color: var(--kt-danger) !important; border-color: var(--kt-danger) !important; box-shadow: none !important; } +.btn-outline-primary { background: transparent !important; color: var(--kt-accent) !important; border-color: rgba(47, 111, 237, 0.35) !important; } +.btn-outline-primary:hover { background: var(--kt-accent-glow) !important; color: var(--kt-accent) !important; border-color: var(--kt-accent) !important; box-shadow: none !important; } .btn-sm { padding: 0.28rem 0.65rem !important; font-size: 0.78rem !important; border-radius: 6px !important; } /* ── Form controls ─────────────────────────────────────────────────── */ @@ -254,20 +289,21 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. border-radius: 8px !important; padding: 0.5rem 0.85rem !important; font-size: 0.875rem !important; - font-family: var(--kt-font-ui) !important; + font-family: var(--kt-font) !important; transition: border-color var(--kt-transition), box-shadow var(--kt-transition) !important; } .form-control:focus, .form-select:focus { background-color: var(--kt-surface-3) !important; - border-color: var(--kt-amber) !important; + border-color: var(--kt-accent) !important; color: var(--kt-text) !important; - box-shadow: 0 0 0 3px rgba(232,160,69,0.12) !important; + box-shadow: 0 0 0 3px var(--kt-accent-glow) !important; outline: none !important; } .form-control::placeholder { color: var(--kt-text-subtle) !important; } .form-select option { background: var(--kt-surface-3); color: var(--kt-text); } .form-control-sm, .form-select-sm { padding: 0.3rem 0.65rem !important; font-size: 0.82rem !important; border-radius: 6px !important; } -.form-label { font-size: 0.72rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.07em; color: var(--kt-text-muted); margin-bottom: 0.35rem; } +.form-label { font-size: 0.72rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.06em; color: var(--kt-text-muted); margin-bottom: 0.35rem; } +.form-check-input:checked { background-color: var(--kt-accent) !important; border-color: var(--kt-accent) !important; } /* ── TABLE ─────────────────────────────────────────────────────────── */ .table { @@ -283,7 +319,6 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. border-spacing: 0 !important; } -/* Override Bootstrap's per-cell bg injection */ .table > :not(caption) > * > * { background-color: transparent !important; color: var(--kt-text) !important; @@ -297,7 +332,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. font-size: 0.7rem !important; font-weight: 600 !important; text-transform: uppercase !important; - letter-spacing: 0.1em !important; + letter-spacing: 0.08em !important; color: var(--kt-text-muted) !important; border-bottom: 1px solid var(--kt-border) !important; white-space: nowrap; @@ -307,9 +342,9 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. .table tbody tr:hover td { background-color: var(--kt-surface-2) !important; } .table tbody tr.kt-editing td { - background-color: rgba(232,160,69,0.04) !important; - border-top: 1px solid rgba(232,160,69,0.2) !important; - border-bottom: 1px solid rgba(232,160,69,0.2) !important; + background-color: var(--kt-accent-glow) !important; + border-top: 1px solid var(--kt-accent) !important; + border-bottom: 1px solid var(--kt-accent) !important; } .kt-table-wrap { @@ -321,7 +356,6 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. width: 100%; } -/* Header bar inside the table card — title left, button right */ .kt-table-header { display: flex; align-items: center; @@ -331,13 +365,13 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. } .kt-table-title { - font-size: 1.75rem; + font-size: 1.6rem; margin: 0; line-height: 1; padding-bottom: 1.25rem; } -.kt-table-title span { color: var(--kt-amber); } +.kt-table-title span { color: var(--kt-accent); } /* ── Page header ───────────────────────────────────────────────────── */ .kt-page-header { @@ -348,47 +382,62 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. gap: 1rem; flex-wrap: wrap; } -.kt-page-header h1 { font-size: 2.2rem; color: var(--kt-text); margin: 0; line-height: 1; } -.kt-page-header h1 span { color: var(--kt-amber); } +.kt-page-header h1 { font-size: 2rem; color: var(--kt-text); margin: 0; line-height: 1; } +.kt-page-header h1 span { color: var(--kt-accent); } /* ── Form card ─────────────────────────────────────────────────────── */ .kt-form-card { background: var(--kt-surface); border: 1px solid var(--kt-border); - border-top: 1px solid rgba(232,160,69,0.3); + border-top: 2px solid var(--kt-accent); border-radius: var(--kt-radius-lg); padding: 1.5rem 1.75rem; margin-bottom: 1.75rem; box-shadow: var(--kt-shadow); } .kt-form-card h5 { - font-family: var(--kt-font-display); - font-style: italic; - color: var(--kt-amber); - font-size: 0.9rem; + color: var(--kt-accent); + font-size: 0.85rem; font-weight: 600; margin-bottom: 1.25rem; text-transform: uppercase; - letter-spacing: 0.08em; + letter-spacing: 0.06em; } /* ── Alerts ────────────────────────────────────────────────────────── */ .alert { border-radius: var(--kt-radius) !important; font-size: 0.875rem; padding: 0.8rem 1.1rem !important; } -.alert-danger { background: rgba(192,72,90,0.1) !important; border-color: rgba(192,72,90,0.3) !important; color: #e07080 !important; } -.alert-info { background: rgba(232,160,69,0.06) !important; border-color: rgba(232,160,69,0.18) !important; color: var(--kt-text-muted) !important; } +.alert-danger { background: rgba(199, 58, 82, 0.10) !important; border-color: rgba(199, 58, 82, 0.3) !important; color: var(--kt-danger) !important; } +.alert-info { background: var(--kt-accent-glow) !important; border-color: rgba(47, 111, 237, 0.2) !important; color: var(--kt-text-muted) !important; } /* ── Loading / empty ───────────────────────────────────────────────── */ .kt-loading { display: flex; align-items: center; gap: 0.75rem; color: var(--kt-text-muted); font-size: 0.9rem; padding: 4rem 0; justify-content: center; } -.kt-spinner { width: 18px; height: 18px; border: 2px solid var(--kt-surface-3); border-top-color: var(--kt-amber); border-radius: 50%; animation: spin 0.75s linear infinite; flex-shrink: 0; } +.kt-spinner { width: 18px; height: 18px; border: 2px solid var(--kt-surface-3); border-top-color: var(--kt-accent); border-radius: 50%; animation: spin 0.75s linear infinite; flex-shrink: 0; } @keyframes spin { to { transform: rotate(360deg); } } .kt-empty { text-align: center; padding: 5rem 2rem; } .kt-empty-icon { font-size: 2.5rem; color: var(--kt-text-subtle); display: block; margin-bottom: 1rem; } .kt-empty p { font-size: 0.9rem; color: var(--kt-text-muted); margin: 0; line-height: 1.8; } /* ── Stars ─────────────────────────────────────────────────────────── */ -.kt-stars { color: var(--kt-amber); letter-spacing: 0; font-size: 0.85rem; } +.kt-stars { color: var(--kt-accent); letter-spacing: 0; font-size: 0.85rem; } .kt-stars .empty { color: var(--kt-text-subtle); } +.star { font-size: 1.2rem; } +.star.full { color: var(--kt-accent); } +.star.empty { color: var(--kt-text-subtle); } +.star.half { + position: relative; + display: inline-block; + color: var(--kt-text-subtle); +} +.star.half::before { + content: '★'; + position: absolute; + left: 0; + width: 50%; + overflow: hidden; + color: var(--kt-accent); +} + /* ── Home ──────────────────────────────────────────────────────────── */ .kt-home { display: flex; @@ -400,9 +449,9 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. margin-right: auto; padding-top: 5vh; } -.kt-home-eyebrow { font-size: 0.72rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.2em; color: var(--kt-amber); margin-bottom: 1.1rem; } -.kt-home h1 { font-size: clamp(2.4rem, 4.5vw, 3.8rem); line-height: 1.12; margin-bottom: 1.25rem; } -.kt-home h1 em { font-style: italic; color: var(--kt-amber); } +.kt-home-eyebrow { font-size: 0.72rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.16em; color: var(--kt-accent); margin-bottom: 1.1rem; } +.kt-home h1 { font-size: clamp(2.2rem, 4.2vw, 3.4rem); line-height: 1.15; margin-bottom: 1.25rem; } +.kt-home h1 em { font-style: normal; color: var(--kt-accent); } .kt-home-sub { font-size: 1rem; color: var(--kt-text-muted); line-height: 1.75; margin-bottom: 2.5rem; } .kt-home-cta { display: flex; gap: 0.75rem; flex-wrap: wrap; align-items: center; } @@ -422,7 +471,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. border: 1px solid var(--kt-border); border-radius: 20px; padding: 0.3rem 0.85rem; - letter-spacing: 0.02em; + letter-spacing: 0.01em; } /* ── Login ─────────────────────────────────────────────────────────── */ @@ -437,7 +486,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. .kt-login-card { background: var(--kt-surface); border: 1px solid var(--kt-border); - border-top: 2px solid var(--kt-amber); + border-top: 2px solid var(--kt-accent); border-radius: var(--kt-radius-lg); padding: 2.25rem 2rem 2rem; width: 100%; @@ -445,8 +494,8 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. box-shadow: var(--kt-shadow-lg); } -.kt-login-logo { font-family: var(--kt-font-display); font-size: 1.5rem; font-weight: 700; color: var(--kt-text); margin-bottom: 0.35rem; display: flex; align-items: center; gap: 0.45rem; } -.kt-login-logo::before { content: '◈'; color: var(--kt-amber); font-size: 1rem; } +.kt-login-logo { font-size: 1.4rem; font-weight: 700; color: var(--kt-text); margin-bottom: 0.35rem; display: flex; align-items: center; gap: 0.45rem; } +.kt-login-logo::before { content: '◈'; color: var(--kt-accent); font-size: 1rem; } .kt-login-tagline { font-size: 0.82rem; color: var(--kt-text-muted); margin-bottom: 1.75rem; } /* OAuth buttons — flex, icon left, text centered in remaining space */ @@ -461,7 +510,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. margin-bottom: 0.65rem; transition: all var(--kt-transition); cursor: pointer; - font-family: var(--kt-font-ui); + font-family: var(--kt-font); border: 1px solid var(--kt-border); background: var(--kt-surface-2); color: var(--kt-text); @@ -470,7 +519,6 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. position: relative; } -/* Icon sits at fixed left position */ .btn-oauth svg, .btn-oauth img { position: absolute; @@ -478,7 +526,6 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. flex-shrink: 0; } -/* Label fills the button and centers itself */ .btn-oauth span.btn-label { flex: 1; text-align: center; @@ -493,7 +540,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. ::-webkit-scrollbar-thumb { background: var(--kt-surface-3); border-radius: 10px; } /* ── Blazor internals ──────────────────────────────────────────────── */ -#blazor-error-ui { background: var(--kt-surface); border-top: 1px solid var(--kt-border); color: var(--kt-text-muted); font-family: var(--kt-font-ui); font-size: 0.82rem; padding: 0.75rem 1.25rem; position: fixed; bottom: 0; width: 100%; z-index: 1000; display: none; } +#blazor-error-ui { background: var(--kt-surface); border-top: 1px solid var(--kt-border); color: var(--kt-text-muted); font-family: var(--kt-font); font-size: 0.82rem; padding: 0.75rem 1.25rem; position: fixed; bottom: 0; width: 100%; z-index: 1000; display: none; } #blazor-error-ui .dismiss { cursor: pointer; float: right; font-weight: 600; } #components-reconnect-modal { background: var(--kt-surface); border: 1px solid var(--kt-border); border-radius: var(--kt-radius); padding: 0.85rem 1.25rem; position: fixed; bottom: 1.5rem; right: 1.5rem; color: var(--kt-text-muted); font-size: 0.82rem; z-index: 1001; box-shadow: var(--kt-shadow-lg); } @@ -506,7 +553,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. .nav-scrollable { display: none; } #nav-toggle:checked ~ .nav-scrollable { display: block; } article.content { padding: 1.5rem 1rem; } - .kt-page-header h1 { font-size: 1.75rem; } + .kt-page-header h1 { font-size: 1.6rem; } .kt-table-wrap { border-radius: var(--kt-radius); } .table thead { display: none; } .table, .table tbody, .table tr, .table td { display: block; width: 100%; } @@ -576,7 +623,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. border: 1px solid var(--kt-border); background: transparent; color: var(--kt-text-muted); - font-family: var(--kt-font-ui); + font-family: var(--kt-font); font-size: 0.82rem; font-weight: 500; cursor: pointer; @@ -593,9 +640,9 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. } .kt-page-btn.active { - background: var(--kt-amber-glow); - border-color: rgba(232,160,69,0.4); - color: var(--kt-amber); + background: var(--kt-accent-glow); + border-color: rgba(47, 111, 237, 0.4); + color: var(--kt-accent); font-weight: 600; } @@ -610,29 +657,11 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. color: var(--kt-text-subtle); } -/* ── Stars ────────────────────────────────────────────────────── */ -.star { font-size: 1.2rem; } -.star.full { color: gold; } -.star.empty { color: lightgray; } -.star.half { - position: relative; - display: inline-block; - color: lightgray; -} -.star.half::before { - content: '★'; - position: absolute; - left: 0; - width: 50%; - overflow: hidden; - color: gold; -} - /* ── Modal ─────────────────────────────────────────────────────────── */ .kt-modal-backdrop { position: fixed; inset: 0; - background: rgba(0, 0, 0, 0.65); + background: rgba(10, 12, 16, 0.5); backdrop-filter: blur(3px); z-index: 500; display: flex; @@ -645,7 +674,7 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. .kt-modal { background: var(--kt-surface); border: 1px solid var(--kt-border); - border-top: 2px solid var(--kt-amber); + border-top: 2px solid var(--kt-accent); border-radius: var(--kt-radius-lg); box-shadow: var(--kt-shadow-lg); width: 100%; @@ -666,14 +695,12 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. } .kt-modal-header h5 { - font-family: var(--kt-font-display); - font-style: italic; - color: var(--kt-amber); - font-size: 0.9rem; + color: var(--kt-accent); + font-size: 0.85rem; font-weight: 600; margin: 0; text-transform: uppercase; - letter-spacing: 0.08em; + letter-spacing: 0.06em; } .kt-modal-close { @@ -707,13 +734,112 @@ button.nav-link:hover { color: #e07070 !important; background: rgba(192,72,90,0. @keyframes kt-fade-in { from { opacity: 0; } to { opacity: 1; } } @keyframes kt-slide-up { from { transform: translateY(12px); opacity: 0; } to { transform: translateY(0); opacity: 1; } } -/* Mobile: slide up from bottom as a sheet */ @media (max-width: 767px) { .kt-modal-backdrop { align-items: flex-end; padding: 0; } .kt-modal { max-width: 100%; max-height: 95vh; border-radius: var(--kt-radius-lg) var(--kt-radius-lg) 0 0; - border-top: 2px solid var(--kt-amber); + border-top: 2px solid var(--kt-accent); } } + +/* ── Dashboard cards (Watch Next) ──────────────────────────────────── */ +.kt-card-grid { + display: grid; + grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); + gap: 1rem; +} + +.kt-card { + background: var(--kt-surface); + border: 1px solid var(--kt-border); + border-radius: var(--kt-radius-lg); + padding: 1.25rem; + box-shadow: var(--kt-shadow); + transition: border-color var(--kt-transition), box-shadow var(--kt-transition); +} +.kt-card:hover { border-color: var(--kt-border-hover); } + +.kt-card-title { + font-size: 1rem; + font-weight: 600; + color: var(--kt-text); + margin: 0 0 0.6rem; +} + +.kt-card-badge { + display: inline-flex; + align-items: center; + gap: 0.35rem; + font-size: 0.78rem; + font-weight: 600; + color: var(--kt-accent); + background: var(--kt-accent-glow); + border-radius: 20px; + padding: 0.25rem 0.75rem; + margin-bottom: 0.75rem; +} + +.kt-card-meta { + font-size: 0.78rem; + color: var(--kt-text-muted); +} + +.kt-section-title { + font-size: 0.78rem; + font-weight: 600; + text-transform: uppercase; + letter-spacing: 0.08em; + color: var(--kt-text-muted); + margin: 2rem 0 1rem; +} +.kt-section-title:first-child { margin-top: 0; } + +/* ── Season timeline (TV show detail) ──────────────────────────────── */ +.kt-season-picker { + display: flex; + flex-wrap: wrap; + gap: 0.35rem; + margin-bottom: 1rem; +} + +.kt-season { + background: var(--kt-surface); + border: 1px solid var(--kt-border); + border-radius: var(--kt-radius-lg); + margin-bottom: 1rem; + overflow: hidden; +} + +.kt-season-header { + padding: 0.9rem 1.25rem; + font-weight: 600; + font-size: 0.9rem; + border-bottom: 1px solid var(--kt-border); +} + +.kt-episode-row { + display: flex; + align-items: center; + gap: 0.85rem; + padding: 0.65rem 1.25rem; + border-top: 1px solid var(--kt-border); + font-size: 0.85rem; +} +.kt-episode-row:first-of-type { border-top: none; } +.kt-episode-row.watched { color: var(--kt-text); } +.kt-episode-row.unwatched { color: var(--kt-text-muted); } +.kt-episode-number { font-variant-numeric: tabular-nums; color: var(--kt-text-muted); min-width: 2.5rem; } +.kt-episode-date { margin-left: auto; font-size: 0.78rem; color: var(--kt-text-subtle); } + +/* ── Upload dropzone (Import) ──────────────────────────────────────── */ +.kt-dropzone { + border: 2px dashed var(--kt-border); + border-radius: var(--kt-radius-lg); + padding: 3rem 2rem; + text-align: center; + color: var(--kt-text-muted); + background: var(--kt-surface); +} +.kt-dropzone-icon { font-size: 2.25rem; display: block; margin-bottom: 1rem; color: var(--kt-text-subtle); } diff --git a/src/BlazorApp/wwwroot/theme.js b/src/BlazorApp/wwwroot/theme.js new file mode 100644 index 0000000..7adc244 --- /dev/null +++ b/src/BlazorApp/wwwroot/theme.js @@ -0,0 +1,15 @@ +function ktApplyTheme() { + var stored = localStorage.getItem('kt-theme'); + var theme = stored || (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'); + document.documentElement.setAttribute('data-bs-theme', theme); +} + +// runs immediately, before CSS paints, so the very first page load never flashes the wrong theme +ktApplyTheme(); + +function ktToggleTheme() { + var current = document.documentElement.getAttribute('data-bs-theme'); + var next = current === 'dark' ? 'light' : 'dark'; + document.documentElement.setAttribute('data-bs-theme', next); + localStorage.setItem('kt-theme', next); +} diff --git a/src/Domain/Models/EpisodeModel.cs b/src/Domain/Models/EpisodeModel.cs new file mode 100644 index 0000000..044825c --- /dev/null +++ b/src/Domain/Models/EpisodeModel.cs @@ -0,0 +1,21 @@ +using System; +using Keeptrack.Common.System; + +namespace Keeptrack.Domain.Models; + +public class EpisodeModel : IHasIdAndOwnerId +{ + public string? Id { get; set; } + + public required string OwnerId { get; set; } + + public required string TvShowId { get; set; } + + public required int SeasonNumber { get; set; } + + public required int EpisodeNumber { get; set; } + + public DateOnly? WatchedAt { get; set; } + + public string? Notes { get; set; } +} diff --git a/src/Domain/Models/MovieModel.cs b/src/Domain/Models/MovieModel.cs index aa84358..4e403df 100644 --- a/src/Domain/Models/MovieModel.cs +++ b/src/Domain/Models/MovieModel.cs @@ -24,4 +24,8 @@ public class MovieModel : IHasIdAndOwnerId public string? AllocineId { get; set; } public DateOnly? FirstSeenAt { get; set; } + + public bool IsFavorite { get; set; } + + public bool WantToWatch { get; set; } } diff --git a/src/Domain/Models/TvShowModel.cs b/src/Domain/Models/TvShowModel.cs index 0a50131..04dc55c 100644 --- a/src/Domain/Models/TvShowModel.cs +++ b/src/Domain/Models/TvShowModel.cs @@ -24,4 +24,8 @@ public class TvShowModel : IHasIdAndOwnerId public string? AllocineId { get; set; } public DateOnly? FinishedAt { get; set; } + + public bool IsFavorite { get; set; } + + public bool WantToWatch { get; set; } } diff --git a/src/Domain/Repositories/IEpisodeRepository.cs b/src/Domain/Repositories/IEpisodeRepository.cs new file mode 100644 index 0000000..9c642d5 --- /dev/null +++ b/src/Domain/Repositories/IEpisodeRepository.cs @@ -0,0 +1,7 @@ +using Keeptrack.Domain.Models; + +namespace Keeptrack.Domain.Repositories; + +public interface IEpisodeRepository : IDataRepository +{ +} diff --git a/src/Infrastructure.MongoDb/Entities/Episode.cs b/src/Infrastructure.MongoDb/Entities/Episode.cs new file mode 100644 index 0000000..e5eac28 --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/Episode.cs @@ -0,0 +1,30 @@ +using System; +using Keeptrack.Common.System; +using MongoDB.Bson; +using MongoDB.Bson.Serialization.Attributes; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +public class Episode : IHasIdAndOwnerId +{ + [BsonId] + [BsonRepresentation(BsonType.ObjectId)] + public string? Id { get; set; } + + [BsonElement("owner_id")] + public required string OwnerId { get; set; } + + [BsonElement("tv_show_id")] + public required string TvShowId { get; set; } + + [BsonElement("season_number")] + public required int SeasonNumber { get; set; } + + [BsonElement("episode_number")] + public required int EpisodeNumber { get; set; } + + [BsonElement("watched_at")] + public DateTime? WatchedAt { get; set; } + + public string? Notes { get; set; } +} diff --git a/src/Infrastructure.MongoDb/Entities/Movie.cs b/src/Infrastructure.MongoDb/Entities/Movie.cs index 628ef7a..60e9a8a 100644 --- a/src/Infrastructure.MongoDb/Entities/Movie.cs +++ b/src/Infrastructure.MongoDb/Entities/Movie.cs @@ -30,4 +30,10 @@ public class Movie : IHasIdAndOwnerId [BsonElement("first_seen_at")] public DateTime? FirstSeenAt { get; set; } + + [BsonElement("is_favorite")] + public bool IsFavorite { get; set; } + + [BsonElement("want_to_watch")] + public bool WantToWatch { get; set; } } diff --git a/src/Infrastructure.MongoDb/Entities/TvShow.cs b/src/Infrastructure.MongoDb/Entities/TvShow.cs index 6d69f61..7eab302 100644 --- a/src/Infrastructure.MongoDb/Entities/TvShow.cs +++ b/src/Infrastructure.MongoDb/Entities/TvShow.cs @@ -31,4 +31,10 @@ public class TvShow : IHasIdAndOwnerId [BsonElement("finished_at")] public DateTime? FinishedAt { get; set; } + + [BsonElement("is_favorite")] + public bool IsFavorite { get; set; } + + [BsonElement("want_to_watch")] + public bool WantToWatch { get; set; } } diff --git a/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs b/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs new file mode 100644 index 0000000..1eb9310 --- /dev/null +++ b/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs @@ -0,0 +1,22 @@ +using AutoMapper; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Microsoft.Extensions.Logging; +using MongoDB.Driver; + +namespace Keeptrack.Infrastructure.MongoDb.Repositories; + +public class EpisodeRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) + : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IEpisodeRepository +{ + protected override string CollectionName => "episode"; + + protected override FilterDefinition GetFilter(string ownerId, string? search, EpisodeModel input) + { + var builder = Builders.Filter; + var filter = builder.Eq(f => f.OwnerId, ownerId); + if (!string.IsNullOrEmpty(input.TvShowId)) filter &= builder.Eq(f => f.TvShowId, input.TvShowId); + return filter; + } +} diff --git a/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs b/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs index bc2ff4c..e95fcd5 100644 --- a/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs @@ -1,23 +1,24 @@ -using AutoMapper; +using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; using Microsoft.Extensions.Logging; using MongoDB.Driver; -namespace Keeptrack.Infrastructure.MongoDb.Repositories +namespace Keeptrack.Infrastructure.MongoDb.Repositories; + +public class MovieRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) + : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IMovieRepository { - public class MovieRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) - : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IMovieRepository - { - protected override string CollectionName => "movie"; + protected override string CollectionName => "movie"; - protected override FilterDefinition GetFilter(string ownerId, string? search, MovieModel input) - { - var builder = Builders.Filter; - var filter = builder.Eq(f => f.OwnerId, ownerId); - if (!string.IsNullOrEmpty(search)) builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); - return filter; - } + protected override FilterDefinition GetFilter(string ownerId, string? search, MovieModel input) + { + var builder = Builders.Filter; + var filter = builder.Eq(f => f.OwnerId, ownerId); + if (!string.IsNullOrEmpty(search)) filter &= builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + if (input.IsFavorite) filter &= builder.Eq(f => f.IsFavorite, true); + if (input.WantToWatch) filter &= builder.Eq(f => f.WantToWatch, true); + return filter; } } diff --git a/src/Infrastructure.MongoDb/Repositories/MusicAlbumRepository.cs b/src/Infrastructure.MongoDb/Repositories/MusicAlbumRepository.cs index a03e6be..d03d117 100644 --- a/src/Infrastructure.MongoDb/Repositories/MusicAlbumRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/MusicAlbumRepository.cs @@ -16,8 +16,8 @@ protected override FilterDefinition GetFilter(string ownerId, string { var builder = Builders.Filter; var filter = builder.Eq(f => f.OwnerId, ownerId); - if (!string.IsNullOrEmpty(search)) builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase) - || f.Artist.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + if (!string.IsNullOrEmpty(search)) filter &= builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase) + || f.Artist.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); return filter; } } diff --git a/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs b/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs index 6b4983d..96aa8bb 100644 --- a/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs @@ -17,6 +17,8 @@ protected override FilterDefinition GetFilter(string ownerId, string? se var builder = Builders.Filter; var filter = builder.Eq(f => f.OwnerId, ownerId); if (!string.IsNullOrEmpty(search)) filter &= builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + if (input.IsFavorite) filter &= builder.Eq(f => f.IsFavorite, true); + if (input.WantToWatch) filter &= builder.Eq(f => f.WantToWatch, true); return filter; } } diff --git a/src/WebApi.Contracts/Dto/EpisodeDto.cs b/src/WebApi.Contracts/Dto/EpisodeDto.cs new file mode 100644 index 0000000..1b5b2f4 --- /dev/null +++ b/src/WebApi.Contracts/Dto/EpisodeDto.cs @@ -0,0 +1,37 @@ +using System; +using Keeptrack.Common.System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Episode data transfer object. +/// +public class EpisodeDto : IHasId +{ + /// + /// Episode ID. + /// + public string? Id { get; set; } + + /// + /// TV Show ID. + /// + public required string TvShowId { get; set; } + + /// + /// Season number. + /// + public required int SeasonNumber { get; set; } + + /// + /// Episode number within the season. + /// + public required int EpisodeNumber { get; set; } + + /// + /// Date the episode was watched. + /// + public DateOnly? WatchedAt { get; set; } + + public string? Notes { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/ImportResultDto.cs b/src/WebApi.Contracts/Dto/ImportResultDto.cs new file mode 100644 index 0000000..51667f4 --- /dev/null +++ b/src/WebApi.Contracts/Dto/ImportResultDto.cs @@ -0,0 +1,26 @@ +using System.Collections.Generic; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Result of a TV Time GDPR export import. +/// +public class ImportResultDto +{ + public int ShowsCreated { get; set; } + + public int ShowsUpdated { get; set; } + + public int EpisodesCreated { get; set; } + + public int EpisodesUpdated { get; set; } + + public int MoviesCreated { get; set; } + + public int MoviesUpdated { get; set; } + + /// + /// Non-fatal issues encountered during the import (e.g. a movie referenced only by an unresolvable id). + /// + public List Warnings { get; set; } = []; +} diff --git a/src/WebApi.Contracts/Dto/MovieDto.cs b/src/WebApi.Contracts/Dto/MovieDto.cs index dd82b6f..82418aa 100644 --- a/src/WebApi.Contracts/Dto/MovieDto.cs +++ b/src/WebApi.Contracts/Dto/MovieDto.cs @@ -22,4 +22,8 @@ public class MovieDto : IHasId public string? AllocineId { get; set; } public DateOnly? FirstSeenAt { get; set; } + + public bool IsFavorite { get; set; } + + public bool WantToWatch { get; set; } } diff --git a/src/WebApi.Contracts/Dto/TvShowDto.cs b/src/WebApi.Contracts/Dto/TvShowDto.cs index 8191fcd..1feb5bc 100644 --- a/src/WebApi.Contracts/Dto/TvShowDto.cs +++ b/src/WebApi.Contracts/Dto/TvShowDto.cs @@ -31,4 +31,8 @@ public class TvShowDto : IHasId public string? AllocineId { get; set; } public DateOnly? FinishedAt { get; set; } + + public bool IsFavorite { get; set; } + + public bool WantToWatch { get; set; } } diff --git a/src/WebApi.Contracts/Dto/WatchNextDto.cs b/src/WebApi.Contracts/Dto/WatchNextDto.cs new file mode 100644 index 0000000..50af2f0 --- /dev/null +++ b/src/WebApi.Contracts/Dto/WatchNextDto.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// A TV show with a suggested next episode to watch. +/// +public class NextEpisodeDto +{ + public required string TvShowId { get; set; } + + public required string TvShowTitle { get; set; } + + public required int NextSeasonNumber { get; set; } + + public required int NextEpisodeNumber { get; set; } + + public DateOnly? LastWatchedAt { get; set; } +} + +/// +/// What to watch next: in-progress shows and movies on the watch list. +/// +public class WatchNextDto +{ + public List NextEpisodes { get; set; } = []; + + public List MoviesToWatch { get; set; } = []; +} diff --git a/src/WebApi/Controllers/ControllerBaseExtensions.cs b/src/WebApi/Controllers/ControllerBaseExtensions.cs new file mode 100644 index 0000000..ad0e838 --- /dev/null +++ b/src/WebApi/Controllers/ControllerBaseExtensions.cs @@ -0,0 +1,15 @@ +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Controllers; + +internal static class ControllerBaseExtensions +{ + /// + /// Get authenticated user id. + /// + internal static string GetUserId(this ControllerBase controller) + { + var userId = controller.User.Claims.FirstOrDefault(x => x.Type == "user_id")?.Value; + return string.IsNullOrEmpty(userId) ? throw new UnauthorizedAccessException() : userId; + } +} diff --git a/src/WebApi/Controllers/DataCrudControllerBase.cs b/src/WebApi/Controllers/DataCrudControllerBase.cs index affab3c..c35d0df 100644 --- a/src/WebApi/Controllers/DataCrudControllerBase.cs +++ b/src/WebApi/Controllers/DataCrudControllerBase.cs @@ -20,7 +20,7 @@ public abstract class DataCrudControllerBase(IMapper mapper, IData [ProducesResponseType(500)] public async Task>> Get([FromQuery] PagedRequest pagedRequest, [FromQuery] TDto input) { - var models = await dataRepository.FindAllAsync(GetUserId(), + var models = await dataRepository.FindAllAsync(this.GetUserId(), pagedRequest.Page, pagedRequest.PageSize, pagedRequest.Search, @@ -40,7 +40,7 @@ public async Task> GetById(string id) return BadRequest(); } - var model = await dataRepository.FindOneAsync(id, GetUserId()); + var model = await dataRepository.FindOneAsync(id, this.GetUserId()); if (model == null) { return NotFound(); @@ -56,7 +56,7 @@ public async Task> GetById(string id) public async Task Post([FromBody] TDto dto) { var input = mapper.Map(dto); - input.OwnerId = GetUserId(); + input.OwnerId = this.GetUserId(); var model = await dataRepository.CreateAsync(input); return CreatedAtAction(nameof(GetById), new { id = model.Id }, mapper.Map(model)); } @@ -73,8 +73,8 @@ public async Task Put(string id, [FromBody] TDto dto) } var input = mapper.Map(dto); - input.OwnerId = GetUserId(); - await dataRepository.UpdateAsync(id, input, GetUserId()); + input.OwnerId = this.GetUserId(); + await dataRepository.UpdateAsync(id, input, this.GetUserId()); return NoContent(); } @@ -89,17 +89,7 @@ public async Task Delete(string id) return BadRequest(); } - await dataRepository.DeleteAsync(id, GetUserId()); + await dataRepository.DeleteAsync(id, this.GetUserId()); return NoContent(); } - - /// - /// Get authenticated user id. - /// - /// - private string GetUserId() - { - var userId = User.Claims.FirstOrDefault(x => x.Type == "user_id")?.Value; - return string.IsNullOrEmpty(userId) ? throw new UnauthorizedAccessException() : userId; - } } diff --git a/src/WebApi/Controllers/EpisodeController.cs b/src/WebApi/Controllers/EpisodeController.cs new file mode 100644 index 0000000..4b56726 --- /dev/null +++ b/src/WebApi/Controllers/EpisodeController.cs @@ -0,0 +1,12 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Controllers; + +[ApiController] +[Authorize] +[Route("api/episodes")] +public class EpisodeController(IMapper mapper, IEpisodeRepository dataRepository) + : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index f81be7a..e9a7e11 100644 --- a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -28,6 +28,7 @@ internal static void AddMongoDbInfrastructure(this IServiceCollection services, services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); + services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); diff --git a/src/WebApi/Import/Parsers/EpisodeCommentsCsvParser.cs b/src/WebApi/Import/Parsers/EpisodeCommentsCsvParser.cs new file mode 100644 index 0000000..c9b728c --- /dev/null +++ b/src/WebApi/Import/Parsers/EpisodeCommentsCsvParser.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class EpisodeCommentRecord +{ + [Name("tv_show_name")] + public required string ShowTitle { get; set; } + + [Name("episode_season_number")] + public required int SeasonNumber { get; set; } + + [Name("episode_number")] + public required int EpisodeNumber { get; set; } + + [Name("comment")] + public required string Comment { get; set; } + + [Name("created_at")] + public required DateTime CreatedAt { get; set; } +} + +/// +/// Parses TV Time's episode_comment.csv: the exporting user's own free-text comments on episodes. +/// Episodes here are only identified by show name (no show id in this file), same as seen_episode_source.csv. +/// +public static class EpisodeCommentsCsvParser +{ + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords().ToList(); + } +} diff --git a/src/WebApi/Import/Parsers/FavoriteMoviesListParser.cs b/src/WebApi/Import/Parsers/FavoriteMoviesListParser.cs new file mode 100644 index 0000000..c5c8aa6 --- /dev/null +++ b/src/WebApi/Import/Parsers/FavoriteMoviesListParser.cs @@ -0,0 +1,63 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +internal class ListRowRecord +{ + [Name("s_key")] + public string? SKey { get; set; } + + [Name("objects")] + public string? Objects { get; set; } +} + +/// +/// Parses TV Time's lists-prod-lists.csv to find the movie ids in the built-in "Favorite Movies" list. +/// That one row's `objects` column is not CSV or JSON: it's a Go fmt-style dump of a slice of maps, +/// e.g. "[map[created_at:... type:movie uuid:1be8d227-...] map[... type:series id:71663] ...]". +/// +public static partial class FavoriteMoviesListParser +{ + private const string FavoriteMoviesSKey = "favorite-movies"; + + public static HashSet Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + var objectsField = csv.GetRecords() + .FirstOrDefault(row => row.SKey == FavoriteMoviesSKey) + ?.Objects; + return ParseObjectsField(objectsField); + } + + /// + /// Pure parsing of the raw `objects` field content, split out so it can be unit-tested without a CSV file. + /// + public static HashSet ParseObjectsField(string? objectsField) + { + var uuids = new HashSet(); + if (string.IsNullOrEmpty(objectsField)) return uuids; + + foreach (Match entry in EntryRegex().Matches(objectsField)) + { + var content = entry.Groups[1].Value; + if (!content.Contains("type:movie")) continue; + + var uuidMatch = UuidRegex().Match(content); + if (uuidMatch.Success) uuids.Add(uuidMatch.Groups[1].Value); + } + + return uuids; + } + + [GeneratedRegex(@"map\[([^\[\]]*)\]")] + private static partial Regex EntryRegex(); + + [GeneratedRegex(@"uuid:([0-9a-fA-F-]{36})")] + private static partial Regex UuidRegex(); +} diff --git a/src/WebApi/Import/Parsers/FollowedShowsCsvParser.cs b/src/WebApi/Import/Parsers/FollowedShowsCsvParser.cs new file mode 100644 index 0000000..e5f4e6e --- /dev/null +++ b/src/WebApi/Import/Parsers/FollowedShowsCsvParser.cs @@ -0,0 +1,29 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class FollowedShowRecord +{ + [Name("tv_show_id")] + public required string TvShowId { get; set; } + + [Name("tv_show_name")] + public required string Title { get; set; } +} + +/// +/// Parses TV Time's followed_tv_show.csv, the master list of a user's TV shows. +/// +public static class FollowedShowsCsvParser +{ + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords().ToList(); + } +} diff --git a/src/WebApi/Import/Parsers/MovieVotesCsvParser.cs b/src/WebApi/Import/Parsers/MovieVotesCsvParser.cs new file mode 100644 index 0000000..f68280d --- /dev/null +++ b/src/WebApi/Import/Parsers/MovieVotesCsvParser.cs @@ -0,0 +1,36 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class MovieVoteRecord +{ + [Name("uuid")] + public required string Uuid { get; set; } + + [Name("movie_name")] + public required string MovieName { get; set; } +} + +/// +/// Parses TV Time's rating/emotion vote files (ratings-v2-prod-votes.csv, ratings-live-votes.csv, +/// emotions-v2-prod-votes.csv, emotions-live-votes.csv). These files mix movie and episode votes; +/// only rows carrying a movie_name are kept, since that's the sole way a movie title is discoverable +/// in the export (movies have no stable id and no dedicated "movies I watched" file). +/// The vote's own emotion/rating code is intentionally not read here: it's an undocumented internal +/// enum, not a linear rating scale. +/// +public static class MovieVotesCsvParser +{ + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords() + .Where(record => !string.IsNullOrWhiteSpace(record.MovieName)) + .ToList(); + } +} diff --git a/src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs b/src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs new file mode 100644 index 0000000..f0928ba --- /dev/null +++ b/src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class SeenEpisodeRecord +{ + [Name("tv_show_name")] + public required string ShowTitle { get; set; } + + [Name("episode_season_number")] + public required int SeasonNumber { get; set; } + + [Name("episode_number")] + public required int EpisodeNumber { get; set; } + + [Name("created_at")] + public required DateTime WatchedAt { get; set; } +} + +/// +/// Parses TV Time's seen_episode_source.csv: one row per episode watch event, with a date. +/// Episodes here are only identified by show name (no show id in this file). +/// +public static class SeenEpisodesCsvParser +{ + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords().ToList(); + } +} diff --git a/src/WebApi/Import/Parsers/ShowCommentsCsvParser.cs b/src/WebApi/Import/Parsers/ShowCommentsCsvParser.cs new file mode 100644 index 0000000..19d1011 --- /dev/null +++ b/src/WebApi/Import/Parsers/ShowCommentsCsvParser.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class ShowCommentRecord +{ + [Name("tv_show_id")] + public required string TvShowId { get; set; } + + [Name("comment")] + public required string Comment { get; set; } + + [Name("created_at")] + public required DateTime CreatedAt { get; set; } +} + +/// +/// Parses TV Time's show_comment.csv: the exporting user's own free-text comments on shows. +/// The GDPR export only ever contains the requesting user's own rows, so no user-id filtering is needed. +/// +public static class ShowCommentsCsvParser +{ + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords().ToList(); + } +} diff --git a/src/WebApi/Import/Parsers/ShowRatingsCsvParser.cs b/src/WebApi/Import/Parsers/ShowRatingsCsvParser.cs new file mode 100644 index 0000000..261ea2d --- /dev/null +++ b/src/WebApi/Import/Parsers/ShowRatingsCsvParser.cs @@ -0,0 +1,29 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class ShowRatingRecord +{ + [Name("tv_show_id")] + public required string TvShowId { get; set; } + + [Name("rating")] + public required float Rating { get; set; } +} + +/// +/// Parses TV Time's tv_show_rate.csv: a clean 0-5 rating per show. +/// +public static class ShowRatingsCsvParser +{ + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords().ToList(); + } +} diff --git a/src/WebApi/Import/Parsers/ShowStatusCsvParser.cs b/src/WebApi/Import/Parsers/ShowStatusCsvParser.cs new file mode 100644 index 0000000..f91bef6 --- /dev/null +++ b/src/WebApi/Import/Parsers/ShowStatusCsvParser.cs @@ -0,0 +1,36 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class ShowStatusRecord +{ + [Name("tv_show_id")] + public required string TvShowId { get; set; } + + /// + /// TV Time status value, e.g. "favorite" or "for_later". + /// + [Name("status")] + public required string Status { get; set; } +} + +/// +/// Parses TV Time's user_show_special_status.csv: favorite/for_later status per show. +/// +public static class ShowStatusCsvParser +{ + public const string FavoriteStatus = "favorite"; + + public const string ForLaterStatus = "for_later"; + + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords().ToList(); + } +} diff --git a/src/WebApi/Import/Parsers/TvTimeCsvConfiguration.cs b/src/WebApi/Import/Parsers/TvTimeCsvConfiguration.cs new file mode 100644 index 0000000..f4ff8f5 --- /dev/null +++ b/src/WebApi/Import/Parsers/TvTimeCsvConfiguration.cs @@ -0,0 +1,16 @@ +using System.Globalization; +using CsvHelper.Configuration; + +namespace Keeptrack.WebApi.Import.Parsers; + +/// +/// Shared CsvHelper configuration for every TV Time export file: tolerant of the differing +/// column sets between the several export-generation files this importer reads. +/// +internal static class TvTimeCsvConfiguration +{ + public static CsvConfiguration Instance { get; } = new(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => args.Header.Trim().ToLowerInvariant() + }; +} diff --git a/src/WebApi/Import/TvTimeImportController.cs b/src/WebApi/Import/TvTimeImportController.cs new file mode 100644 index 0000000..ea6b7f9 --- /dev/null +++ b/src/WebApi/Import/TvTimeImportController.cs @@ -0,0 +1,32 @@ +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.Controllers; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Import; + +[ApiController] +[Authorize] +[Route("api/import")] +public class TvTimeImportController(TvTimeImportService importService) : ControllerBase +{ + /// + /// Imports a TV Time GDPR export (the zip you get from TV Time's "Download my data" request) as an upsert. + /// + [HttpPost("tv-time")] + [RequestSizeLimit(50_000_000)] + [Consumes("multipart/form-data")] + [ProducesResponseType(200)] + [ProducesResponseType(400)] + public async Task> ImportTvTime(IFormFile file) + { + if (file.Length == 0) + { + return BadRequest(); + } + + await using var stream = file.OpenReadStream(); + var result = await importService.ImportAsync(stream, this.GetUserId()); + return Ok(result); + } +} diff --git a/src/WebApi/Import/TvTimeImportService.cs b/src/WebApi/Import/TvTimeImportService.cs new file mode 100644 index 0000000..b7a925d --- /dev/null +++ b/src/WebApi/Import/TvTimeImportService.cs @@ -0,0 +1,202 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.IO.Compression; +using System.Linq; +using Keeptrack.Common.System; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.Import.Parsers; + +namespace Keeptrack.WebApi.Import; + +/// +/// Imports a TV Time GDPR export (a zip of CSV files) as an upsert: followed shows, per-episode +/// watch history, ratings, favorite/want-to-watch status, comments, and movies discovered through +/// rating/emotion votes. Every record created or updated is stamped with the authenticated caller's +/// owner id only - nothing in the uploaded file (including TV Time's own internal user id) is ever +/// used to determine ownership. +/// +public class TvTimeImportService(ITvShowRepository tvShowRepository, IEpisodeRepository episodeRepository, IMovieRepository movieRepository) +{ + private static readonly string[] MovieVoteFileNames = + [ + "ratings-v2-prod-votes.csv", + "ratings-live-votes.csv", + "emotions-v2-prod-votes.csv", + "emotions-live-votes.csv" + ]; + + public async Task ImportAsync(Stream zipStream, string ownerId) + { + using var archive = new ZipArchive(zipStream, ZipArchiveMode.Read); + + var followedShows = ReadCsvEntry(archive, "followed_tv_show.csv", FollowedShowsCsvParser.Parse) ?? []; + var seenEpisodes = ReadCsvEntry(archive, "seen_episode_source.csv", SeenEpisodesCsvParser.Parse) ?? []; + var showRatings = ReadCsvEntry(archive, "tv_show_rate.csv", ShowRatingsCsvParser.Parse) ?? []; + var showStatuses = ReadCsvEntry(archive, "user_show_special_status.csv", ShowStatusCsvParser.Parse) ?? []; + var showComments = ReadCsvEntry(archive, "show_comment.csv", ShowCommentsCsvParser.Parse) ?? []; + var episodeComments = ReadCsvEntry(archive, "episode_comment.csv", EpisodeCommentsCsvParser.Parse) ?? []; + var favoriteMovieUuids = ReadCsvEntry(archive, "lists-prod-lists.csv", FavoriteMoviesListParser.Parse) ?? []; + + var movieVotes = MovieVoteFileNames + .Select(fileName => ReadCsvEntry(archive, fileName, MovieVotesCsvParser.Parse)) + .Where(votes => votes is not null) + .SelectMany(votes => votes!) + .ToList(); + + var result = new ImportResultDto(); + + var showsByTitle = await ImportShowsAsync(ownerId, followedShows, showRatings, showStatuses, showComments, result); + await ImportEpisodesAsync(ownerId, showsByTitle, seenEpisodes, episodeComments, result); + await ImportMoviesAsync(ownerId, movieVotes, favoriteMovieUuids, result); + + return result; + } + + private async Task> ImportShowsAsync( + string ownerId, + List followedShows, + List showRatings, + List showStatuses, + List showComments, + ImportResultDto result) + { + var showsByTitle = (await tvShowRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, NewShow(ownerId, string.Empty))) + .Items + .ToDictionary(show => NormalizeTitle(show.Title)); + + var ratingByShowId = showRatings.GroupBy(r => r.TvShowId).ToDictionary(g => g.Key, g => g.Last().Rating); + var favoriteShowIds = showStatuses.Where(s => s.Status == ShowStatusCsvParser.FavoriteStatus).Select(s => s.TvShowId).ToHashSet(); + var wantToWatchShowIds = showStatuses.Where(s => s.Status == ShowStatusCsvParser.ForLaterStatus).Select(s => s.TvShowId).ToHashSet(); + var notesByShowId = showComments + .GroupBy(c => c.TvShowId) + .ToDictionary(g => g.Key, g => FormatComments(g.Select(c => (c.CreatedAt, c.Comment)))); + + foreach (var show in followedShows) + { + var key = NormalizeTitle(show.Title); + var isNew = !showsByTitle.TryGetValue(key, out var model); + model ??= NewShow(ownerId, show.Title); + + model.Title = show.Title; + if (ratingByShowId.TryGetValue(show.TvShowId, out var rating)) model.Rating = rating; + if (favoriteShowIds.Contains(show.TvShowId)) model.IsFavorite = true; + if (wantToWatchShowIds.Contains(show.TvShowId)) model.WantToWatch = true; + if (notesByShowId.TryGetValue(show.TvShowId, out var notes)) model.Notes = notes; + + if (await SaveAsync(tvShowRepository, model, ownerId, isNew)) result.ShowsCreated++; + else result.ShowsUpdated++; + + showsByTitle[key] = model; + } + + return showsByTitle; + } + + private async Task ImportEpisodesAsync( + string ownerId, + Dictionary showsByTitle, + List seenEpisodes, + List episodeComments, + ImportResultDto result) + { + var notesByEpisodeKey = episodeComments + .GroupBy(c => (Title: NormalizeTitle(c.ShowTitle), c.SeasonNumber, c.EpisodeNumber)) + .ToDictionary(g => g.Key, g => FormatComments(g.Select(c => (c.CreatedAt, c.Comment)))); + + foreach (var showGroup in seenEpisodes.GroupBy(e => NormalizeTitle(e.ShowTitle))) + { + if (!showsByTitle.TryGetValue(showGroup.Key, out var show) || show.Id is null) + { + result.Warnings.Add($"Episode watch history for unknown show '{showGroup.First().ShowTitle}' was skipped."); + continue; + } + + // one bulk fetch per show, so matching each watched episode doesn't need its own database round trip + var existingEpisodes = (await episodeRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, + NewEpisode(ownerId, show.Id, 0, 0))) + .Items + .ToDictionary(e => (e.SeasonNumber, e.EpisodeNumber)); + + foreach (var seen in showGroup) + { + var episodeKey = (seen.SeasonNumber, seen.EpisodeNumber); + var isNew = !existingEpisodes.TryGetValue(episodeKey, out var episode); + episode ??= NewEpisode(ownerId, show.Id, seen.SeasonNumber, seen.EpisodeNumber); + + episode.WatchedAt = DateOnly.FromDateTime(seen.WatchedAt); + if (notesByEpisodeKey.TryGetValue((showGroup.Key, seen.SeasonNumber, seen.EpisodeNumber), out var notes)) episode.Notes = notes; + + if (await SaveAsync(episodeRepository, episode, ownerId, isNew)) result.EpisodesCreated++; + else result.EpisodesUpdated++; + + existingEpisodes[episodeKey] = episode; + } + } + } + + private async Task ImportMoviesAsync( + string ownerId, + List movieVotes, + HashSet favoriteMovieUuids, + ImportResultDto result) + { + var moviesByTitle = (await movieRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, NewMovie(ownerId, string.Empty))) + .Items + .ToDictionary(movie => NormalizeTitle(movie.Title)); + + foreach (var titleGroup in movieVotes.GroupBy(v => NormalizeTitle(v.MovieName))) + { + var isNew = !moviesByTitle.TryGetValue(titleGroup.Key, out var model); + model ??= NewMovie(ownerId, titleGroup.First().MovieName); + + if (titleGroup.Any(v => favoriteMovieUuids.Contains(v.Uuid))) model.IsFavorite = true; + + if (await SaveAsync(movieRepository, model, ownerId, isNew)) result.MoviesCreated++; + else result.MoviesUpdated++; + + moviesByTitle[titleGroup.Key] = model; + } + } + + /// + /// Creates or updates (in place, preserving fields this import doesn't touch) a single model, + /// shared by the show/episode/movie upserts above. + /// + private static async Task SaveAsync(IDataRepository repository, TModel model, string ownerId, bool isNew) + where TModel : class, IHasIdAndOwnerId + { + if (isNew) + { + var created = await repository.CreateAsync(model); + model.Id = created.Id; + return true; + } + + await repository.UpdateAsync(model.Id!, model, ownerId); + return false; + } + + private static TvShowModel NewShow(string ownerId, string title) => new() { OwnerId = ownerId, Title = title }; + + private static MovieModel NewMovie(string ownerId, string title) => new() { OwnerId = ownerId, Title = title }; + + private static EpisodeModel NewEpisode(string ownerId, string tvShowId, int seasonNumber, int episodeNumber) => + new() { OwnerId = ownerId, TvShowId = tvShowId, SeasonNumber = seasonNumber, EpisodeNumber = episodeNumber }; + + private static string NormalizeTitle(string title) => title.Trim().ToLowerInvariant(); + + private static string FormatComments(IEnumerable<(DateTime CreatedAt, string Comment)> comments) => + string.Join('\n', comments.OrderBy(c => c.CreatedAt).Select(c => $"{c.CreatedAt:yyyy-MM-dd}: {c.Comment}")); + + private static TResult? ReadCsvEntry(ZipArchive archive, string entryName, Func parse) + where TResult : class + { + var entry = archive.GetEntry(entryName); + if (entry is null) return null; + using var stream = entry.Open(); + return parse(stream); + } +} diff --git a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs index acf92a2..9bbe56b 100644 --- a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs +++ b/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs @@ -12,6 +12,9 @@ public DataStorageMappingProfile() CreateMap(); CreateMap(); + CreateMap(); + CreateMap(); + CreateMap() .ForMember(x => x.AllocineId, opt => opt.MapFrom( x => x.Allocine != null ? x.Allocine.Id : null)) diff --git a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs index a0341fe..30b2446 100644 --- a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs +++ b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs @@ -21,6 +21,10 @@ public WebServiceMappingProfile() .ForMember(x => x.OwnerId, opt => opt.Ignore()); CreateMap(); + CreateMap() + .ForMember(x => x.OwnerId, opt => opt.Ignore()); + CreateMap(); + CreateMap() .ForMember(x => x.OwnerId, opt => opt.Ignore()); CreateMap(); diff --git a/src/WebApi/Program.cs b/src/WebApi/Program.cs index 377d033..b5e1d0b 100644 --- a/src/WebApi/Program.cs +++ b/src/WebApi/Program.cs @@ -13,6 +13,8 @@ }, typeof(Program).Assembly); builder.Services.AddHealthChecks(); +builder.Services.AddSingleton(); +builder.Services.AddScoped(); builder.Services.AddMongoDbInfrastructure(configuration); builder.Services.AddOpenApiWithBearerAuth(configuration); builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) diff --git a/src/WebApi/WatchNext/WatchNextController.cs b/src/WebApi/WatchNext/WatchNextController.cs new file mode 100644 index 0000000..c6b7768 --- /dev/null +++ b/src/WebApi/WatchNext/WatchNextController.cs @@ -0,0 +1,39 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Controllers; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.WatchNext; + +[ApiController] +[Authorize] +[Route("api/watch-next")] +public class WatchNextController( + ITvShowRepository tvShowRepository, + IEpisodeRepository episodeRepository, + IMovieRepository movieRepository, + WatchNextService watchNextService, + IMapper mapper) : ControllerBase +{ + [HttpGet] + [ProducesResponseType(200)] + [ProducesResponseType(500)] + public async Task> Get() + { + var ownerId = this.GetUserId(); + + var shows = await tvShowRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, + new TvShowModel { OwnerId = ownerId, Title = string.Empty }); + var episodes = await episodeRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, + new EpisodeModel { OwnerId = ownerId, TvShowId = string.Empty, SeasonNumber = 0, EpisodeNumber = 0 }); + var moviesToWatch = await movieRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, + new MovieModel { OwnerId = ownerId, Title = string.Empty, WantToWatch = true }); + + return Ok(new WatchNextDto + { + NextEpisodes = watchNextService.ComputeNextEpisodes(shows.Items, episodes.Items), + MoviesToWatch = mapper.Map>(moviesToWatch.Items) + }); + } +} diff --git a/src/WebApi/WatchNext/WatchNextService.cs b/src/WebApi/WatchNext/WatchNextService.cs new file mode 100644 index 0000000..a3794a7 --- /dev/null +++ b/src/WebApi/WatchNext/WatchNextService.cs @@ -0,0 +1,42 @@ +using System.Collections.Generic; +using System.Linq; +using Keeptrack.Domain.Models; + +namespace Keeptrack.WebApi.WatchNext; + +/// +/// Computes, for each in-progress TV show, the next episode to watch. +/// +public class WatchNextService +{ + /// + /// For every show that has at least one watched episode and isn't finished, proposes the episode + /// right after the highest (season, episode) watched so far. + /// + public List ComputeNextEpisodes(IEnumerable shows, IEnumerable episodes) + { + var inProgressShows = shows.Where(s => s.FinishedAt is null).ToDictionary(s => s.Id!); + + return episodes + .Where(e => inProgressShows.ContainsKey(e.TvShowId)) + .GroupBy(e => e.TvShowId) + .Select(group => + { + var show = inProgressShows[group.Key]; + var lastWatched = group + .OrderByDescending(e => e.SeasonNumber) + .ThenByDescending(e => e.EpisodeNumber) + .First(); + return new NextEpisodeDto + { + TvShowId = show.Id!, + TvShowTitle = show.Title, + NextSeasonNumber = lastWatched.SeasonNumber, + NextEpisodeNumber = lastWatched.EpisodeNumber + 1, + LastWatchedAt = lastWatched.WatchedAt + }; + }) + .OrderByDescending(n => n.LastWatchedAt) + .ToList(); + } +} diff --git a/src/WebApi/WebApi.csproj b/src/WebApi/WebApi.csproj index bc78fd9..1159962 100644 --- a/src/WebApi/WebApi.csproj +++ b/src/WebApi/WebApi.csproj @@ -12,6 +12,7 @@ + diff --git a/test/WebApi.IntegrationTests/Resources/MovieResourceTest.cs b/test/WebApi.IntegrationTests/Resources/MovieResourceTest.cs index a9aaf72..203e7f3 100644 --- a/test/WebApi.IntegrationTests/Resources/MovieResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/MovieResourceTest.cs @@ -1,4 +1,5 @@ -using System.Linq; +using System; +using System.Linq; using System.Net; using System.Threading.Tasks; using AwesomeAssertions; @@ -49,4 +50,27 @@ public async Task MovieResourceLocalhostFullCycle_IsOk() await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); } } + + [Fact] + public async Task MovieResourceSearch_FiltersToMatchingTitle_IsOk() + { + await Authenticate(); + + var uniqueTitle = $"UniqueSearchTarget-{Guid.NewGuid():N}"; + var input = new Faker().Rules((f, o) => { o.Title = uniqueTitle; }).Generate(); + var created = await PostAsync($"/{ResourceEndpoint}", input); + + try + { + var matching = await GetAsync>($"/{ResourceEndpoint}?search={uniqueTitle}"); + matching.Items.Should().Contain(m => m.Id == created.Id); + + var nonMatching = await GetAsync>($"/{ResourceEndpoint}?search={Guid.NewGuid():N}"); + nonMatching.Items.Should().NotContain(m => m.Id == created.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } } diff --git a/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs b/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs index 4e07c8f..70590b4 100644 --- a/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs +++ b/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs @@ -69,6 +69,21 @@ protected async Task PutAsync(string url, T body, HttpStatusCode httpStatusCo response.StatusCode.Should().Be(httpStatusCode); } + protected async Task PostFileAsync(string url, string fieldName, byte[] fileContent, string fileName, HttpStatusCode httpStatusCode = HttpStatusCode.OK) + { + using var content = new MultipartFormDataContent(); + using var byteContent = new ByteArrayContent(fileContent); + content.Add(byteContent, fieldName, fileName); + + var response = await _httpClient.PostAsync(url, content); + response.StatusCode.Should().Be(httpStatusCode); + + var stringResponse = await response.Content.ReadAsStringAsync(); + var output = JsonSerializer.Deserialize(stringResponse, JsonSerializerOptions.Web); + output.Should().NotBeNull(); + return output; + } + protected async Task DeleteAsync(string url, HttpStatusCode httpStatusCode = HttpStatusCode.NoContent) { var response = await _httpClient.DeleteAsync(url); diff --git a/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs b/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs new file mode 100644 index 0000000..d6bf1df --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs @@ -0,0 +1,80 @@ +using System.Collections.Generic; +using System.IO; +using System.IO.Compression; +using System.Text; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Builds a small, synthetic TV Time GDPR export zip for tests: representative rows of each file +/// shape the importer reads, for a single fake show/movie. Never use the real personal export in tests. +/// +internal static class TvTimeFixtureZipBuilder +{ + public const string ShowTitle = "Keeptrack Integration Test Show"; + + public const string MovieTitle = "Keeptrack Integration Test Movie"; + + private const string MovieUuid = "11111111-1111-1111-1111-111111111111"; + + public static byte[] Build() + { + var entries = new Dictionary + { + ["followed_tv_show.csv"] = $""" + updated_at,active,notification_type,folder_id,archived,notification_offset,user_id,tv_show_id,tv_show_name,created_at,diffusion + 2020-01-01 00:00:00,1,2,,0,1440,999,999001,{ShowTitle},2020-01-01 00:00:00,original + + """, + ["seen_episode_source.csv"] = $""" + updated_at,tv_show_name,episode_season_number,episode_number,user_id,episode_id,source,created_at + 2020-01-02 00:00:00,{ShowTitle},1,1,999,1,episode-detail,2020-01-02 00:00:00 + 2020-01-03 00:00:00,{ShowTitle},1,2,999,2,episode-detail,2020-01-03 00:00:00 + + """, + ["tv_show_rate.csv"] = $""" + created_at,updated_at,tv_show_name,user_id,tv_show_id,rating + 2020-01-01 00:00:00,2020-01-01 00:00:00,{ShowTitle},999,999001,4.5 + + """, + ["user_show_special_status.csv"] = $""" + created_at,updated_at,tv_show_name,user_id,tv_show_id,status + 2020-01-01 00:00:00,2020-01-01 00:00:00,{ShowTitle},999,999001,favorite + + """, + ["show_comment.csv"] = $""" + spoiler_count,nb_likes,lang,tv_show_name,created_at,parent_comment_id,source,only_to_fans,user_id,posted_on_fb,posted_on_twitter,comment_type,highlight_level,extended_comment,id,tv_show_id,comment,updated_at,unappropriate_count,depth,valid,same_ip_likes,featured + 0,0,en,{ShowTitle},2020-01-01 00:00:00,,mobile,1,999,0,0,comment,5,null,1,999001,Great show,2020-01-01 00:00:00,0,0,1,0,0 + + """, + ["episode_comment.csv"] = $""" + source,episode_number,episode_id,updated_at,spoiler_count,nb_likes,depth,comment_type,lang,highlight_level,same_ip_likes,episode_season_number,id,posted_on_fb,parent_comment_id,valid,nb_points,tv_show_name,user_id,comment,created_at,posted_on_twitter,unappropriate_count,extended_comment + mobile,1,1,2020-01-02 00:00:00,0,0,1,comment,en,5,0,1,1,0,,0,0,{ShowTitle},999,Great pilot,2020-01-02 00:00:00,0,0,null + + """, + ["ratings-v2-prod-votes.csv"] = $""" + uuid,user_id,episode_id,movie_name,vote_key,series_name,season_number,episode_number + {MovieUuid},999,0,{MovieTitle},{MovieUuid}-999-3,,, + + """, + ["lists-prod-lists.csv"] = $""" + s_key,user_id,objects,name,is_public,created_at,ordering,type,description,lists,list_count + favorite-movies,999,"[map[created_at:1.577836800e+09 type:movie uuid:{MovieUuid}]]",,false,2020-01-01 00:00:00,0,list,,, + + """ + }; + + using var zipStream = new MemoryStream(); + using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Create, leaveOpen: true)) + { + foreach (var (fileName, content) in entries) + { + var entry = archive.CreateEntry(fileName); + using var writer = new StreamWriter(entry.Open(), Encoding.UTF8); + writer.Write(content); + } + } + + return zipStream.ToArray(); + } +} diff --git a/test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs b/test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs new file mode 100644 index 0000000..79d0be6 --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs @@ -0,0 +1,77 @@ +using System; +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Keeptrack.Common.System; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +public class TvTimeImportResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + [Fact] + public async Task ImportTvTime_UpsertsShowsEpisodesAndMovies_AndIsIdempotent() + { + await Authenticate(); + + var zip = TvTimeFixtureZipBuilder.Build(); + + var firstResult = await PostFileAsync("/api/import/tv-time", "file", zip, "gdpr-data.zip"); + firstResult.ShowsCreated.Should().Be(1); + firstResult.EpisodesCreated.Should().Be(2); + firstResult.MoviesCreated.Should().Be(1); + + try + { + var shows = await GetAsync>($"/api/tv-shows?search={Uri.EscapeDataString(TvTimeFixtureZipBuilder.ShowTitle)}"); + var show = shows.Items.Should().ContainSingle().Subject; + show.Rating.Should().Be(4.5f); + show.IsFavorite.Should().BeTrue(); + show.Notes.Should().Contain("Great show"); + + var episodes = await GetAsync>($"/api/episodes?TvShowId={show.Id}"); + episodes.Items.Should().HaveCount(2); + episodes.Items.Should().Contain(e => e.SeasonNumber == 1 && e.EpisodeNumber == 1 && e.Notes == "Great pilot"); + + var movies = await GetAsync>($"/api/movies?search={Uri.EscapeDataString(TvTimeFixtureZipBuilder.MovieTitle)}"); + var movie = movies.Items.Should().ContainSingle().Subject; + movie.IsFavorite.Should().BeTrue(); + + // re-importing the same export must upsert, not duplicate + var secondResult = await PostFileAsync("/api/import/tv-time", "file", zip, "gdpr-data.zip"); + secondResult.ShowsCreated.Should().Be(0); + secondResult.ShowsUpdated.Should().Be(1); + secondResult.EpisodesCreated.Should().Be(0); + secondResult.EpisodesUpdated.Should().Be(2); + secondResult.MoviesCreated.Should().Be(0); + secondResult.MoviesUpdated.Should().Be(1); + + var showsAfterReimport = await GetAsync>($"/api/tv-shows?search={Uri.EscapeDataString(TvTimeFixtureZipBuilder.ShowTitle)}"); + showsAfterReimport.Items.Should().ContainSingle(); + } + finally + { + var shows = await GetAsync>($"/api/tv-shows?search={Uri.EscapeDataString(TvTimeFixtureZipBuilder.ShowTitle)}"); + foreach (var show in shows.Items) + { + var episodes = await GetAsync>($"/api/episodes?TvShowId={show.Id}"); + foreach (var episode in episodes.Items.Where(e => e.Id is not null)) + { + await DeleteAsync($"/api/episodes/{episode.Id}"); + } + + await DeleteAsync($"/api/tv-shows/{show.Id}"); + } + + var movies = await GetAsync>($"/api/movies?search={Uri.EscapeDataString(TvTimeFixtureZipBuilder.MovieTitle)}"); + foreach (var movie in movies.Items.Where(m => m.Id is not null)) + { + await DeleteAsync($"/api/movies/{movie.Id}"); + } + } + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/CsvTestHelper.cs b/test/WebApi.UnitTests/Import/Parsers/CsvTestHelper.cs new file mode 100644 index 0000000..1f1d880 --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/CsvTestHelper.cs @@ -0,0 +1,9 @@ +using System.IO; +using System.Text; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +internal static class CsvTestHelper +{ + public static Stream ToStream(string csv) => new MemoryStream(Encoding.UTF8.GetBytes(csv)); +} diff --git a/test/WebApi.UnitTests/Import/Parsers/EpisodeCommentsCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/EpisodeCommentsCsvParserTest.cs new file mode 100644 index 0000000..a75bf62 --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/EpisodeCommentsCsvParserTest.cs @@ -0,0 +1,26 @@ +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class EpisodeCommentsCsvParserTest +{ + [Fact] + public void Parse_ReturnsShowTitleSeasonEpisodeAndComment() + { + const string csv = """ + source,episode_number,episode_id,updated_at,spoiler_count,nb_likes,depth,comment_type,lang,highlight_level,same_ip_likes,episode_season_number,id,posted_on_fb,parent_comment_id,valid,nb_points,tv_show_name,user_id,comment,created_at,posted_on_twitter,unappropriate_count,extended_comment + mobile,10,6347559,2018-01-07 14:38:00,0,0,1,comment,en,5,0,1,10687229,0,10266504,0,0,Dark,13397917,I think so too,2018-01-07 14:38:00,0,0,null + """; + + var result = EpisodeCommentsCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].ShowTitle.Should().Be("Dark"); + result[0].SeasonNumber.Should().Be(1); + result[0].EpisodeNumber.Should().Be(10); + result[0].Comment.Should().Be("I think so too"); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/FavoriteMoviesListParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/FavoriteMoviesListParserTest.cs new file mode 100644 index 0000000..5796b68 --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/FavoriteMoviesListParserTest.cs @@ -0,0 +1,41 @@ +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class FavoriteMoviesListParserTest +{ + [Fact] + public void ParseObjectsField_ExtractsOnlyMovieUuids() + { + const string objectsField = "[map[created_at:1.566819863e+09 type:movie uuid:1be8d227-5d39-4561-8dfa-7520b8c51d0f] " + + "map[created_at:1.563396726e+09 id:70761 type:series] " + + "map[created_at:1.586728877e+09 type:movie uuid:f891ce51-fcd0-47ff-b05d-7131efafa20e]]"; + + var result = FavoriteMoviesListParser.ParseObjectsField(objectsField); + + result.Should().BeEquivalentTo(["1be8d227-5d39-4561-8dfa-7520b8c51d0f", "f891ce51-fcd0-47ff-b05d-7131efafa20e"]); + } + + [Fact] + public void ParseObjectsField_IgnoresSeriesEntriesThatAlsoCarryAUuid() + { + const string objectsField = "[map[created_at:1.729463362e+09 id:269586 type:series uuid:39fe9fe1-5dc7-4b4d-92f2-1b536c17f0ed]]"; + + var result = FavoriteMoviesListParser.ParseObjectsField(objectsField); + + result.Should().BeEmpty(); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + public void ParseObjectsField_ReturnsEmptySet_WhenFieldIsMissing(string? objectsField) + { + var result = FavoriteMoviesListParser.ParseObjectsField(objectsField); + + result.Should().BeEmpty(); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/FollowedShowsCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/FollowedShowsCsvParserTest.cs new file mode 100644 index 0000000..8e405ab --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/FollowedShowsCsvParserTest.cs @@ -0,0 +1,24 @@ +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class FollowedShowsCsvParserTest +{ + [Fact] + public void Parse_ReturnsShowIdAndTitle() + { + const string csv = """ + updated_at,active,notification_type,folder_id,archived,notification_offset,user_id,tv_show_id,tv_show_name,created_at,diffusion + 2017-12-23 22:16:20,1,2,,0,1440,13397917,70327,Buffy the Vampire Slayer,2017-12-23 22:16:20,original + """; + + var result = FollowedShowsCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].TvShowId.Should().Be("70327"); + result[0].Title.Should().Be("Buffy the Vampire Slayer"); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/MovieVotesCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/MovieVotesCsvParserTest.cs new file mode 100644 index 0000000..0d943ba --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/MovieVotesCsvParserTest.cs @@ -0,0 +1,39 @@ +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class MovieVotesCsvParserTest +{ + [Fact] + public void Parse_SkipsRowsWithoutAMovieName() + { + const string csv = """ + uuid,user_id,episode_id,movie_name,vote_key,series_name,season_number,episode_number + 4273cc26-528e-463e-814e-534e3e50eceb,13397917,0,Bohemian Rhapsody,4273cc26-528e-463e-814e-534e3e50eceb-13397917-3,,, + aaaaaaaa-528e-463e-814e-534e3e50eceb,13397917,4383263,,aaaaaaaa-13397917-3,The Americans,1,1 + """; + + var result = MovieVotesCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].Uuid.Should().Be("4273cc26-528e-463e-814e-534e3e50eceb"); + result[0].MovieName.Should().Be("Bohemian Rhapsody"); + } + + [Fact] + public void Parse_HandlesTheDifferentColumnOrderOfTheLiveVotesFile() + { + const string csv = """ + vote_key,episode_id,user_id,uuid,movie_name + 46166a01-b4cf-41ec-8a3b-51e1adbe9c44-13397917-29,0,13397917,46166a01-b4cf-41ec-8a3b-51e1adbe9c44,Terminator: Dark Fate + """; + + var result = MovieVotesCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].MovieName.Should().Be("Terminator: Dark Fate"); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/SeenEpisodesCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/SeenEpisodesCsvParserTest.cs new file mode 100644 index 0000000..3b418cd --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/SeenEpisodesCsvParserTest.cs @@ -0,0 +1,27 @@ +using System; +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class SeenEpisodesCsvParserTest +{ + [Fact] + public void Parse_ReturnsShowTitleSeasonEpisodeAndWatchedDate() + { + const string csv = """ + updated_at,tv_show_name,episode_season_number,episode_number,user_id,episode_id,source,created_at + 2018-10-08 20:35:17,Charmed,1,1,13397917,16029,episode-detail,2018-10-08 20:35:17 + """; + + var result = SeenEpisodesCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].ShowTitle.Should().Be("Charmed"); + result[0].SeasonNumber.Should().Be(1); + result[0].EpisodeNumber.Should().Be(1); + result[0].WatchedAt.Should().Be(new DateTime(2018, 10, 8, 20, 35, 17)); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/ShowCommentsCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/ShowCommentsCsvParserTest.cs new file mode 100644 index 0000000..8a942c3 --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/ShowCommentsCsvParserTest.cs @@ -0,0 +1,22 @@ +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class ShowCommentsCsvParserTest +{ + [Fact] + public void Parse_PreservesMultiLineQuotedComment() + { + const string csv = "spoiler_count,nb_likes,lang,tv_show_name,created_at,parent_comment_id,source,only_to_fans,user_id,posted_on_fb,posted_on_twitter,comment_type,highlight_level,extended_comment,id,tv_show_id,comment,updated_at,unappropriate_count,depth,valid,same_ip_likes,featured\n" + + "0,3,en,Dark,2019-05-12 18:45:53,,mobile,1,13397917,0,0,comment,5,null,1244578,334824,\"Amazing show, really worth watching.\nI don't know another show like this one.\",2019-05-12 18:45:53,0,0,1,0,0\n"; + + var result = ShowCommentsCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].TvShowId.Should().Be("334824"); + result[0].Comment.Should().Be("Amazing show, really worth watching.\nI don't know another show like this one."); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/ShowRatingsCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/ShowRatingsCsvParserTest.cs new file mode 100644 index 0000000..918254e --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/ShowRatingsCsvParserTest.cs @@ -0,0 +1,24 @@ +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class ShowRatingsCsvParserTest +{ + [Fact] + public void Parse_ReturnsShowIdAndRating() + { + const string csv = """ + created_at,updated_at,tv_show_name,user_id,tv_show_id,rating + 2018-06-01 20:16:07,2018-06-01 20:16:07,Prison Break,13397917,75340,2.50 + """; + + var result = ShowRatingsCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].TvShowId.Should().Be("75340"); + result[0].Rating.Should().Be(2.50f); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/ShowStatusCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/ShowStatusCsvParserTest.cs new file mode 100644 index 0000000..9cf8a09 --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/ShowStatusCsvParserTest.cs @@ -0,0 +1,26 @@ +using System.Linq; +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class ShowStatusCsvParserTest +{ + [Fact] + public void Parse_ReturnsFavoriteAndForLaterStatuses() + { + const string csv = """ + created_at,updated_at,tv_show_name,user_id,tv_show_id,status + 2018-10-21 10:25:34,2018-10-21 10:25:34,Charmed,13397917,70626,for_later + 2018-11-14 20:25:51,2018-11-14 20:25:51,ER,13397917,70761,favorite + """; + + var result = ShowStatusCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().HaveCount(2); + result.Single(r => r.TvShowId == "70626").Status.Should().Be(ShowStatusCsvParser.ForLaterStatus); + result.Single(r => r.TvShowId == "70761").Status.Should().Be(ShowStatusCsvParser.FavoriteStatus); + } +} diff --git a/test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs b/test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs new file mode 100644 index 0000000..8e68548 --- /dev/null +++ b/test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs @@ -0,0 +1,91 @@ +using System; +using System.Collections.Generic; +using AwesomeAssertions; +using Keeptrack.Domain.Models; +using Keeptrack.WebApi.WatchNext; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.WatchNext; + +[Trait("Category", "UnitTests")] +public class WatchNextServiceTest +{ + private readonly WatchNextService _service = new(); + + private static TvShowModel Show(string id, string title, DateOnly? finishedAt = null) => + new() { Id = id, OwnerId = "owner", Title = title, FinishedAt = finishedAt }; + + private static EpisodeModel Episode(string showId, int season, int episode, DateOnly? watchedAt = null) => + new() { OwnerId = "owner", TvShowId = showId, SeasonNumber = season, EpisodeNumber = episode, WatchedAt = watchedAt }; + + [Fact] + public void ComputeNextEpisodes_ProposesTheEpisodeAfterTheHighestWatched() + { + var shows = new[] { Show("show-1", "Dark") }; + var episodes = new[] + { + Episode("show-1", 1, 1, new DateOnly(2024, 1, 1)), + Episode("show-1", 1, 2, new DateOnly(2024, 1, 2)) + }; + + var result = _service.ComputeNextEpisodes(shows, episodes); + + result.Should().ContainSingle(); + result[0].TvShowTitle.Should().Be("Dark"); + result[0].NextSeasonNumber.Should().Be(1); + result[0].NextEpisodeNumber.Should().Be(3); + result[0].LastWatchedAt.Should().Be(new DateOnly(2024, 1, 2)); + } + + [Fact] + public void ComputeNextEpisodes_ProposesTheFirstEpisodeOfTheNextSeason_WhenTheHighestWatchedEndsASeason() + { + var shows = new[] { Show("show-1", "Dark") }; + var episodes = new[] { Episode("show-1", 1, 8, new DateOnly(2024, 1, 1)) }; + + var result = _service.ComputeNextEpisodes(shows, episodes); + + // the service only knows the highest (season, episode) watched, not each season's episode count, + // so "next" is always season N episode M+1 - a documented heuristic, not season-finale-aware. + result[0].NextSeasonNumber.Should().Be(1); + result[0].NextEpisodeNumber.Should().Be(9); + } + + [Fact] + public void ComputeNextEpisodes_ExcludesFinishedShows() + { + var shows = new[] { Show("show-1", "Dark", finishedAt: new DateOnly(2024, 6, 1)) }; + var episodes = new[] { Episode("show-1", 1, 1) }; + + var result = _service.ComputeNextEpisodes(shows, episodes); + + result.Should().BeEmpty(); + } + + [Fact] + public void ComputeNextEpisodes_ExcludesShowsWithNoWatchedEpisodes() + { + var shows = new[] { Show("show-1", "Dark") }; + + var result = _service.ComputeNextEpisodes(shows, []); + + result.Should().BeEmpty(); + } + + [Fact] + public void ComputeNextEpisodes_OrdersByLastWatchedDescending() + { + var shows = new[] { Show("show-1", "Older"), Show("show-2", "Newer") }; + var episodes = new[] + { + Episode("show-1", 1, 1, new DateOnly(2024, 1, 1)), + Episode("show-2", 1, 1, new DateOnly(2024, 6, 1)) + }; + + var result = _service.ComputeNextEpisodes(shows, episodes); + + result.Should().HaveCount(2); + result[0].TvShowTitle.Should().Be("Newer"); + result[1].TvShowTitle.Should().Be("Older"); + } +} From 86827239d0c1374af7ef6663ee4d0630d5661d67 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 6 Jul 2026 18:11:06 +0200 Subject: [PATCH 06/44] Improve episode parsing --- CLAUDE.md | 2 + .../Import/Parsers/EpisodeWatchCsvParser.cs | 20 ++++++ .../Parsers/LegacyEpisodeWatchCsvParser.cs | 18 +++++ .../Parsers/RawEpisodeWatchRowParser.cs | 44 +++++++++++++ .../Import/Parsers/SeenEpisodesCsvParser.cs | 14 +++- .../Import/Parsers/ShowActivityCsvParser.cs | 34 ++++++++++ src/WebApi/Import/TvTimeImportService.cs | 65 +++++++++++++++++-- .../Resources/TvTimeFixtureZipBuilder.cs | 53 +++++++++++++++ .../Resources/TvTimeImportResourceTest.cs | 11 +++- .../Parsers/EpisodeWatchCsvParserTest.cs | 29 +++++++++ .../LegacyEpisodeWatchCsvParserTest.cs | 29 +++++++++ .../Parsers/ShowActivityCsvParserTest.cs | 24 +++++++ 12 files changed, 333 insertions(+), 10 deletions(-) create mode 100644 src/WebApi/Import/Parsers/EpisodeWatchCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/LegacyEpisodeWatchCsvParser.cs create mode 100644 src/WebApi/Import/Parsers/RawEpisodeWatchRowParser.cs create mode 100644 src/WebApi/Import/Parsers/ShowActivityCsvParser.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/EpisodeWatchCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/LegacyEpisodeWatchCsvParserTest.cs create mode 100644 test/WebApi.UnitTests/Import/Parsers/ShowActivityCsvParserTest.cs diff --git a/CLAUDE.md b/CLAUDE.md index 0c34020..06d8ca6 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -92,6 +92,8 @@ Follow the existing types (`Book`, `Movie`, `MusicAlbum`, `TvShow`, `VideoGame`, Not every endpoint is per-item CRUD. `WebApi/WatchNext/` (a read-only cross-entity aggregation) and `WebApi/Import/` (the TV Time GDPR-export upsert, using `CsvHelper` for parsing) are their own feature folders with a plain `ControllerBase` and a small service class, rather than being force-fit into `DataCrudControllerBase`. Follow that folder-per-feature shape for future non-CRUD endpoints instead of stretching the generic CRUD base to cover them. +`seen_episode_source.csv` alone is a drastically incomplete picture of a user's episode history (it's only written when an episode is marked watched via TV Time's episode-detail screen) - confirmed against real export data, not assumed. `TvTimeImportService` also reads `tracking-prod-records.csv` and `tracking-prod-records-v2.csv`, TV Time's generic event logs, which capture episodes marked watched any other way (bulk/season actions). All three are merged and de-duplicated per (show, season, episode), earliest date wins, before upserting `Episode`s. If a future TV Time export field looks suspiciously sparse, check the raw export files directly (`grep` the show name across every `*.csv`) before assuming the current parser set is complete - this is exactly how the tracking files were found. + ### Blazor app `InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, which wraps the typed `HttpClient` calls to the Web API (its `GetAsync` takes an optional extra-query-parameters dictionary, used by features that filter on more than search/page/pageSize). Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. diff --git a/src/WebApi/Import/Parsers/EpisodeWatchCsvParser.cs b/src/WebApi/Import/Parsers/EpisodeWatchCsvParser.cs new file mode 100644 index 0000000..29b3034 --- /dev/null +++ b/src/WebApi/Import/Parsers/EpisodeWatchCsvParser.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.IO; +using CsvHelper; + +namespace Keeptrack.WebApi.Import.Parsers; + +/// +/// Parses TV Time's tracking-prod-records-v2.csv: the newer-generation replacement for +/// tracking-prod-records.csv, same idea - a generic event log with an individually dated row per +/// episode watch, identified by its "gsi" column starting with "watch-episode-". Other row types in +/// this file (one per-show summary row with an aggregate "most_recent_ep_watched" field) are skipped. +/// +public static class EpisodeWatchCsvParser +{ + private const string EpisodeWatchPrefix = "watch-episode-"; + + public static List Parse(Stream csvStream) => + RawEpisodeWatchRowParser.Parse(csvStream, csv => (csv.GetField("gsi") ?? string.Empty).StartsWith(EpisodeWatchPrefix, StringComparison.Ordinal)); +} diff --git a/src/WebApi/Import/Parsers/LegacyEpisodeWatchCsvParser.cs b/src/WebApi/Import/Parsers/LegacyEpisodeWatchCsvParser.cs new file mode 100644 index 0000000..f638db9 --- /dev/null +++ b/src/WebApi/Import/Parsers/LegacyEpisodeWatchCsvParser.cs @@ -0,0 +1,18 @@ +using System.Collections.Generic; +using System.IO; +using CsvHelper; + +namespace Keeptrack.WebApi.Import.Parsers; + +/// +/// Parses TV Time's tracking-prod-records.csv: a generic, older-generation event log that includes +/// (among many other event types) an individually dated row per episode watch. Far more complete +/// than seen_episode_source.csv, which only covers episodes marked watched via the episode-detail +/// screen. A genuine episode watch row has type "watch" and entity_type "episode"; every other row +/// type (show-level counters, "last episode watched" summaries, ...) is skipped. +/// +public static class LegacyEpisodeWatchCsvParser +{ + public static List Parse(Stream csvStream) => + RawEpisodeWatchRowParser.Parse(csvStream, csv => csv.GetField("type") == "watch" && csv.GetField("entity_type") == "episode"); +} diff --git a/src/WebApi/Import/Parsers/RawEpisodeWatchRowParser.cs b/src/WebApi/Import/Parsers/RawEpisodeWatchRowParser.cs new file mode 100644 index 0000000..48d4d42 --- /dev/null +++ b/src/WebApi/Import/Parsers/RawEpisodeWatchRowParser.cs @@ -0,0 +1,44 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using CsvHelper; + +namespace Keeptrack.WebApi.Import.Parsers; + +/// +/// Shared row-by-row reader for TV Time files that mix genuine per-episode watch events together +/// with other row types (show-level summaries, counters, ...) in the same CSV. Each source file has +/// its own way of telling those apart, so the discriminator is supplied by the caller; everything +/// else (opening the stream, skipping rows without a season/episode, building the result) is common. +/// +internal static class RawEpisodeWatchRowParser +{ + public static List Parse(Stream csvStream, Func isEpisodeWatchRow) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + csv.Read(); + csv.ReadHeader(); + + var records = new List(); + while (csv.Read()) + { + if (!isEpisodeWatchRow(csv)) continue; + + var seasonNumber = csv.GetField("season_number"); + var episodeNumber = csv.GetField("episode_number"); + if (string.IsNullOrEmpty(seasonNumber) || string.IsNullOrEmpty(episodeNumber)) continue; + + records.Add(new SeenEpisodeRecord + { + ShowTitle = csv.GetField("series_name") ?? string.Empty, + SeasonNumber = int.Parse(seasonNumber, CultureInfo.InvariantCulture), + EpisodeNumber = int.Parse(episodeNumber, CultureInfo.InvariantCulture), + WatchedAt = csv.GetField("created_at") + }); + } + + return records; + } +} diff --git a/src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs b/src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs index f0928ba..1a960ee 100644 --- a/src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs +++ b/src/WebApi/Import/Parsers/SeenEpisodesCsvParser.cs @@ -7,12 +7,17 @@ namespace Keeptrack.WebApi.Import.Parsers; +/// +/// One episode watch event. The column names differ slightly across the several files that carry +/// this same information (see , , +/// ), so both naming variants are accepted here. +/// public class SeenEpisodeRecord { - [Name("tv_show_name")] + [Name("tv_show_name", "series_name")] public required string ShowTitle { get; set; } - [Name("episode_season_number")] + [Name("episode_season_number", "season_number")] public required int SeasonNumber { get; set; } [Name("episode_number")] @@ -24,7 +29,10 @@ public class SeenEpisodeRecord /// /// Parses TV Time's seen_episode_source.csv: one row per episode watch event, with a date. -/// Episodes here are only identified by show name (no show id in this file). +/// Episodes here are only identified by show name (no show id in this file). This file alone is +/// usually far from complete - it's only written when an episode is marked watched via the +/// episode-detail screen. and +/// cover the much larger volume of episodes marked watched other ways. /// public static class SeenEpisodesCsvParser { diff --git a/src/WebApi/Import/Parsers/ShowActivityCsvParser.cs b/src/WebApi/Import/Parsers/ShowActivityCsvParser.cs new file mode 100644 index 0000000..d547c1e --- /dev/null +++ b/src/WebApi/Import/Parsers/ShowActivityCsvParser.cs @@ -0,0 +1,34 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CsvHelper; +using CsvHelper.Configuration.Attributes; + +namespace Keeptrack.WebApi.Import.Parsers; + +public class ShowActivityRecord +{ + [Name("tv_show_id")] + public required string TvShowId { get; set; } + + /// + /// TV Time's own count of episodes seen for this show, including ones marked via bulk/season + /// actions that never get an individual row in seen_episode_source.csv. + /// + [Name("nb_episodes_seen")] + public required int EpisodesSeenCount { get; set; } +} + +/// +/// Parses TV Time's user_tv_show_data.csv: per-show aggregate activity, notably a total episode +/// count that can be higher than what seen_episode_source.csv captures in detail. +/// +public static class ShowActivityCsvParser +{ + public static List Parse(Stream csvStream) + { + using var reader = new StreamReader(csvStream); + using var csv = new CsvReader(reader, TvTimeCsvConfiguration.Instance); + return csv.GetRecords().ToList(); + } +} diff --git a/src/WebApi/Import/TvTimeImportService.cs b/src/WebApi/Import/TvTimeImportService.cs index b7a925d..7b2af04 100644 --- a/src/WebApi/Import/TvTimeImportService.cs +++ b/src/WebApi/Import/TvTimeImportService.cs @@ -33,11 +33,21 @@ public async Task ImportAsync(Stream zipStream, string ownerId) using var archive = new ZipArchive(zipStream, ZipArchiveMode.Read); var followedShows = ReadCsvEntry(archive, "followed_tv_show.csv", FollowedShowsCsvParser.Parse) ?? []; - var seenEpisodes = ReadCsvEntry(archive, "seen_episode_source.csv", SeenEpisodesCsvParser.Parse) ?? []; + + // Three overlapping sources of "episode watched on this date", oldest/least complete to newest/most complete. + // seen_episode_source.csv alone is usually drastically incomplete (only episode-detail-screen taps); the two + // tracking-prod-records files are TV Time's generic event logs and capture episodes marked watched any other + // way too. All three are merged and de-duplicated per (show, season, episode) in ImportEpisodesAsync. + var seenEpisodes = (ReadCsvEntry(archive, "seen_episode_source.csv", SeenEpisodesCsvParser.Parse) ?? []) + .Concat(ReadCsvEntry(archive, "tracking-prod-records.csv", LegacyEpisodeWatchCsvParser.Parse) ?? []) + .Concat(ReadCsvEntry(archive, "tracking-prod-records-v2.csv", EpisodeWatchCsvParser.Parse) ?? []) + .ToList(); + var showRatings = ReadCsvEntry(archive, "tv_show_rate.csv", ShowRatingsCsvParser.Parse) ?? []; var showStatuses = ReadCsvEntry(archive, "user_show_special_status.csv", ShowStatusCsvParser.Parse) ?? []; var showComments = ReadCsvEntry(archive, "show_comment.csv", ShowCommentsCsvParser.Parse) ?? []; var episodeComments = ReadCsvEntry(archive, "episode_comment.csv", EpisodeCommentsCsvParser.Parse) ?? []; + var showActivity = ReadCsvEntry(archive, "user_tv_show_data.csv", ShowActivityCsvParser.Parse) ?? []; var favoriteMovieUuids = ReadCsvEntry(archive, "lists-prod-lists.csv", FavoriteMoviesListParser.Parse) ?? []; var movieVotes = MovieVoteFileNames @@ -49,7 +59,8 @@ public async Task ImportAsync(Stream zipStream, string ownerId) var result = new ImportResultDto(); var showsByTitle = await ImportShowsAsync(ownerId, followedShows, showRatings, showStatuses, showComments, result); - await ImportEpisodesAsync(ownerId, showsByTitle, seenEpisodes, episodeComments, result); + var detailedEpisodeCountByShowTitle = await ImportEpisodesAsync(ownerId, showsByTitle, seenEpisodes, episodeComments, result); + AnnotateWatchCompleteness(followedShows, showActivity, detailedEpisodeCountByShowTitle, result); await ImportMoviesAsync(ownerId, movieVotes, favoriteMovieUuids, result); return result; @@ -95,7 +106,14 @@ private async Task> ImportShowsAsync( return showsByTitle; } - private async Task ImportEpisodesAsync( + /// + /// Upserts episodes from the merged watch-event sources (see ), taking the + /// earliest recorded date per (show, season, episode) when more than one source reports it. Returns, + /// per normalized show title, how many distinct episodes got a watch date - used by + /// to flag shows where TV Time's own reported total is still + /// higher than what these files captured in detail. + /// + private async Task> ImportEpisodesAsync( string ownerId, Dictionary showsByTitle, List seenEpisodes, @@ -106,6 +124,8 @@ private async Task ImportEpisodesAsync( .GroupBy(c => (Title: NormalizeTitle(c.ShowTitle), c.SeasonNumber, c.EpisodeNumber)) .ToDictionary(g => g.Key, g => FormatComments(g.Select(c => (c.CreatedAt, c.Comment)))); + var detailedEpisodeCountByShowTitle = new Dictionary(); + foreach (var showGroup in seenEpisodes.GroupBy(e => NormalizeTitle(e.ShowTitle))) { if (!showsByTitle.TryGetValue(showGroup.Key, out var show) || show.Id is null) @@ -114,13 +134,21 @@ private async Task ImportEpisodesAsync( continue; } + // de-duplicate across the merged sources: one row per (season, episode), earliest date wins + var episodesWatched = showGroup + .GroupBy(e => (e.SeasonNumber, e.EpisodeNumber)) + .Select(g => (g.Key.SeasonNumber, g.Key.EpisodeNumber, WatchedAt: g.Min(e => e.WatchedAt))) + .ToList(); + + detailedEpisodeCountByShowTitle[showGroup.Key] = episodesWatched.Count; + // one bulk fetch per show, so matching each watched episode doesn't need its own database round trip var existingEpisodes = (await episodeRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, NewEpisode(ownerId, show.Id, 0, 0))) .Items .ToDictionary(e => (e.SeasonNumber, e.EpisodeNumber)); - foreach (var seen in showGroup) + foreach (var seen in episodesWatched) { var episodeKey = (seen.SeasonNumber, seen.EpisodeNumber); var isNew = !existingEpisodes.TryGetValue(episodeKey, out var episode); @@ -135,6 +163,35 @@ private async Task ImportEpisodesAsync( existingEpisodes[episodeKey] = episode; } } + + return detailedEpisodeCountByShowTitle; + } + + /// + /// TV Time only writes a row to seen_episode_source.csv when an episode is marked watched via + /// its episode-detail screen; episodes marked watched through bulk/season actions never get an + /// individual date there, even though user_tv_show_data.csv's own episode count includes them. + /// Surface that gap as a warning instead of silently importing a suspiciously short watch history. + /// + private static void AnnotateWatchCompleteness( + List followedShows, + List showActivity, + Dictionary detailedEpisodeCountByShowTitle, + ImportResultDto result) + { + var reportedCountByTvShowId = showActivity.ToDictionary(a => a.TvShowId, a => a.EpisodesSeenCount); + + foreach (var show in followedShows) + { + if (!reportedCountByTvShowId.TryGetValue(show.TvShowId, out var reportedCount)) continue; + + var detailedCount = detailedEpisodeCountByShowTitle.GetValueOrDefault(NormalizeTitle(show.Title)); + if (reportedCount <= detailedCount) continue; + + result.Warnings.Add( + $"{show.Title}: TV Time reports {reportedCount} episodes seen, but only {detailedCount} have per-episode watch dates in this export " + + "(TV Time doesn't log detail for episodes marked via bulk/season actions)."); + } } private async Task ImportMoviesAsync( diff --git a/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs b/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs index d6bf1df..df363a9 100644 --- a/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs +++ b/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs @@ -1,6 +1,7 @@ using System.Collections.Generic; using System.IO; using System.IO.Compression; +using System.Linq; using System.Text; namespace Keeptrack.WebApi.IntegrationTests.Resources; @@ -32,6 +33,47 @@ public static byte[] Build() 2020-01-03 00:00:00,{ShowTitle},1,2,999,2,episode-detail,2020-01-03 00:00:00 """, + // covers episodes marked watched other ways, which seen_episode_source.csv alone misses (the real bug + // this fixture guards against): one extra episode each from the legacy and current tracking exports. + ["tracking-prod-records.csv"] = BuildCsv( + ["series_name", "uuid", "type-uuid-n", "watch_count", "type", "updated_at", "created_at", "series_id", "user_id", + "watches", "movie_name", "runtime", "entity_type", "alpha_range_key", "follow_date_range_key", "release_date", + "release_date_range_key", "rewatch_count", "series_uuid", "season_number", "episode_id", "watch_date", + "episode_number", "total_movies_runtime", "total_series_runtime", "country", "bulk_type", + "watched_episode_range_key", "watch_date_range_key", "unitarian"], + new Dictionary + { + ["series_name"] = ShowTitle, ["uuid"] = "aaaa", ["type-uuid-n"] = "count-watch-episode-series-aaaa", + ["type"] = "count-watch-episode-series", ["created_at"] = "2020-01-04 00:00:00", ["series_id"] = "999001", ["user_id"] = "999" + }, + new Dictionary + { + ["series_name"] = ShowTitle, ["uuid"] = "bbbb", ["type-uuid-n"] = "watch-bbbb-0", ["type"] = "watch", + ["created_at"] = "2020-01-04 00:00:00", ["series_id"] = "999001", ["user_id"] = "999", ["entity_type"] = "episode", + ["season_number"] = "1", ["episode_number"] = "3" + }), + ["tracking-prod-records-v2.csv"] = BuildCsv( + ["s_id", "user_id", "episode_id", "series_name", "gsi", "runtime", "created_at", "season_number", "episode_number", + "ep_no", "ep_id", "s_no", "key", "ep_watch_count", "total_movies_runtime", "total_series_runtime", + "series_follow_count", "movie_watch_count", "updated_at", "is_followed", "most_recent_ep_watched", "is_for_later", + "uuid", "followed_at", "is_archived", "is_unitary", "rewatch_count", "bulk_type", "is_special"], + new Dictionary + { + ["s_id"] = "999001", ["user_id"] = "999", ["series_name"] = ShowTitle, ["created_at"] = "2020-01-01 00:00:00", + ["key"] = "user-series-999001", ["ep_watch_count"] = "4", ["updated_at"] = "2020-01-05 00:00:00", ["is_followed"] = "true", + ["uuid"] = "999001-summary", ["is_archived"] = "false" + }, + new Dictionary + { + ["s_id"] = "999001", ["user_id"] = "999", ["episode_id"] = "4", ["series_name"] = ShowTitle, + ["gsi"] = "watch-episode-1578182400", ["created_at"] = "2020-01-05 00:00:00", ["season_number"] = "2", + ["episode_number"] = "1", ["key"] = "watch-episode-999001-cccc", ["updated_at"] = "2020-01-05 00:00:00", ["is_unitary"] = "true" + }), + ["user_tv_show_data.csv"] = $""" + user_id,tv_show_id,is_followed,is_favorited,nb_episodes_seen,tv_show_name + 999,999001,1,1,5,{ShowTitle} + + """, ["tv_show_rate.csv"] = $""" created_at,updated_at,tv_show_name,user_id,tv_show_id,rating 2020-01-01 00:00:00,2020-01-01 00:00:00,{ShowTitle},999,999001,4.5 @@ -77,4 +119,15 @@ public static byte[] Build() return zipStream.ToArray(); } + + /// + /// Builds a CSV from an explicit header list and one dictionary of column values per row (columns + /// not present in a row default to empty) - avoids manually counting commas for wide, mostly-empty rows. + /// + private static string BuildCsv(string[] headers, params Dictionary[] rows) + { + var lines = new List { string.Join(',', headers) }; + lines.AddRange(rows.Select(row => string.Join(',', headers.Select(h => row.GetValueOrDefault(h, string.Empty))))); + return string.Join('\n', lines) + '\n'; + } } diff --git a/test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs b/test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs index 79d0be6..a5411f0 100644 --- a/test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/TvTimeImportResourceTest.cs @@ -22,8 +22,11 @@ public async Task ImportTvTime_UpsertsShowsEpisodesAndMovies_AndIsIdempotent() var firstResult = await PostFileAsync("/api/import/tv-time", "file", zip, "gdpr-data.zip"); firstResult.ShowsCreated.Should().Be(1); - firstResult.EpisodesCreated.Should().Be(2); + // 2 from seen_episode_source.csv + 1 from tracking-prod-records.csv + 1 from tracking-prod-records-v2.csv + firstResult.EpisodesCreated.Should().Be(4); firstResult.MoviesCreated.Should().Be(1); + // user_tv_show_data.csv reports 5 episodes seen, but only 4 got a watch date from the sources above + firstResult.Warnings.Should().Contain(w => w.Contains(TvTimeFixtureZipBuilder.ShowTitle) && w.Contains("reports 5") && w.Contains("only 4")); try { @@ -34,8 +37,10 @@ public async Task ImportTvTime_UpsertsShowsEpisodesAndMovies_AndIsIdempotent() show.Notes.Should().Contain("Great show"); var episodes = await GetAsync>($"/api/episodes?TvShowId={show.Id}"); - episodes.Items.Should().HaveCount(2); + episodes.Items.Should().HaveCount(4); episodes.Items.Should().Contain(e => e.SeasonNumber == 1 && e.EpisodeNumber == 1 && e.Notes == "Great pilot"); + episodes.Items.Should().Contain(e => e.SeasonNumber == 1 && e.EpisodeNumber == 3); + episodes.Items.Should().Contain(e => e.SeasonNumber == 2 && e.EpisodeNumber == 1); var movies = await GetAsync>($"/api/movies?search={Uri.EscapeDataString(TvTimeFixtureZipBuilder.MovieTitle)}"); var movie = movies.Items.Should().ContainSingle().Subject; @@ -46,7 +51,7 @@ public async Task ImportTvTime_UpsertsShowsEpisodesAndMovies_AndIsIdempotent() secondResult.ShowsCreated.Should().Be(0); secondResult.ShowsUpdated.Should().Be(1); secondResult.EpisodesCreated.Should().Be(0); - secondResult.EpisodesUpdated.Should().Be(2); + secondResult.EpisodesUpdated.Should().Be(4); secondResult.MoviesCreated.Should().Be(0); secondResult.MoviesUpdated.Should().Be(1); diff --git a/test/WebApi.UnitTests/Import/Parsers/EpisodeWatchCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/EpisodeWatchCsvParserTest.cs new file mode 100644 index 0000000..2cd3fba --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/EpisodeWatchCsvParserTest.cs @@ -0,0 +1,29 @@ +using System; +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class EpisodeWatchCsvParserTest +{ + [Fact] + public void Parse_ExtractsOnlyGenuineEpisodeWatchRows() + { + const string csv = """ + s_id,user_id,episode_id,series_name,gsi,runtime,created_at,season_number,episode_number,ep_no,ep_id,s_no,key,ep_watch_count,total_movies_runtime,total_series_runtime,series_follow_count,movie_watch_count,updated_at,is_followed,most_recent_ep_watched,is_for_later,uuid,followed_at,is_archived,is_unitary,rewatch_count,bulk_type,is_special + 258541,13397917,,Chicago Fire,,,2017-06-09 22:13:33,,,,,,user-series-e8fb922a-0799-4daf-b1b9-2d3d25f92e8e,292,,,,,2026-05-04 11:47:17,true,map[ep_id:1.1680091e+07 ep_no:18 s_no:14 uuid:40c0029d-af3f-49fb-968f-195f01df9463 watch_date:1.777895237135508e+15],false,e8fb922a-0799-4daf-b1b9-2d3d25f92e8e,,false,,,, + 258541,13397917,8956036,Chicago Fire,watch-episode-1702296819,2520,2023-12-11 12:13:39,10,14,14,8956036,10,watch-episode-e8fb922a-0799-4daf-b1b9-2d3d25f92e8e-001e2d1e-1621-4380-8f76-8f3730dd6a01,,,,,,2023-12-11 12:13:39,,,,,,,true,,, + """; + + var result = EpisodeWatchCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + // the per-show summary row (empty "gsi") is skipped; only the "watch-episode-*" row survives + result.Should().ContainSingle(); + result[0].ShowTitle.Should().Be("Chicago Fire"); + result[0].SeasonNumber.Should().Be(10); + result[0].EpisodeNumber.Should().Be(14); + result[0].WatchedAt.Should().Be(new DateTime(2023, 12, 11, 12, 13, 39)); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/LegacyEpisodeWatchCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/LegacyEpisodeWatchCsvParserTest.cs new file mode 100644 index 0000000..19fe5a8 --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/LegacyEpisodeWatchCsvParserTest.cs @@ -0,0 +1,29 @@ +using System; +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class LegacyEpisodeWatchCsvParserTest +{ + [Fact] + public void Parse_ExtractsOnlyGenuineEpisodeWatchRows() + { + const string csv = """ + series_name,uuid,type-uuid-n,watch_count,type,updated_at,created_at,series_id,user_id,watches,movie_name,runtime,entity_type,alpha_range_key,follow_date_range_key,release_date,release_date_range_key,rewatch_count,series_uuid,season_number,episode_id,watch_date,episode_number,total_movies_runtime,total_series_runtime,country,bulk_type,watched_episode_range_key,watch_date_range_key,unitarian + Chicago Fire,e8fb922a-0799-4daf-b1b9-2d3d25f92e8e,count-watch-episode-series-e8fb922a-0799-4daf-b1b9-2d3d25f92e8e,16,count-watch-episode-series,2021-10-28 10:53:37,2021-01-19 14:37:14,258541,13397917,,,,,,,,,,,,,,,,,,,,, + Chicago Fire,01ef3f79-a57b-4913-861e-1c9c3a4f7122,watch-01ef3f79-a57b-4913-861e-1c9c3a4f7122-0,,watch,2021-06-22 11:22:30,2021-06-22 11:22:30,258541,13397917,,,,episode,,,,,,e8fb922a-0799-4daf-b1b9-2d3d25f92e8e,9,8305607,1624360950,16,,,us,,watched-episode-e8fb922a-0799-4daf-b1b9-2d3d25f92e8e-01ef3f79-a57b-4913-861e-1c9c3a4f7122,watch-date-1624360950,true + """; + + var result = LegacyEpisodeWatchCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + // the "count-watch-episode-series" summary row is skipped; only the "watch"/"episode" row survives + result.Should().ContainSingle(); + result[0].ShowTitle.Should().Be("Chicago Fire"); + result[0].SeasonNumber.Should().Be(9); + result[0].EpisodeNumber.Should().Be(16); + result[0].WatchedAt.Should().Be(new DateTime(2021, 6, 22, 11, 22, 30)); + } +} diff --git a/test/WebApi.UnitTests/Import/Parsers/ShowActivityCsvParserTest.cs b/test/WebApi.UnitTests/Import/Parsers/ShowActivityCsvParserTest.cs new file mode 100644 index 0000000..a1d6b55 --- /dev/null +++ b/test/WebApi.UnitTests/Import/Parsers/ShowActivityCsvParserTest.cs @@ -0,0 +1,24 @@ +using AwesomeAssertions; +using Keeptrack.WebApi.Import.Parsers; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Import.Parsers; + +[Trait("Category", "UnitTests")] +public class ShowActivityCsvParserTest +{ + [Fact] + public void Parse_ReturnsShowIdAndEpisodesSeenCount() + { + const string csv = """ + user_id,tv_show_id,is_followed,is_favorited,nb_episodes_seen,tv_show_name + 13397917,258541,1,0,291,Chicago Fire + """; + + var result = ShowActivityCsvParser.Parse(CsvTestHelper.ToStream(csv)); + + result.Should().ContainSingle(); + result[0].TvShowId.Should().Be("258541"); + result[0].EpisodesSeenCount.Should().Be(291); + } +} From 88e25fdb47486e88c9844cbd8b09d45e9dd37cca Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 6 Jul 2026 18:55:12 +0200 Subject: [PATCH 07/44] Fix episodes seen --- CLAUDE.md | 12 +++ CONTRIBUTING.md | 69 +++++++++++-- .../Components/Import/ImportPage.razor | 60 ++++++++++-- .../Import/TvTimeImportApiClient.cs | 12 ++- .../Layout/ReconnectModal.razor.css | 36 ++++--- .../Components/WatchNext/WatchNextPage.razor | 21 ++-- src/BlazorApp/wwwroot/app.css | 11 ++- src/WebApi.Contracts/Dto/ImportJobDto.cs | 38 +++++++ src/WebApi.Contracts/Dto/WatchNextDto.cs | 12 ++- src/WebApi/Import/ImportJobStore.cs | 68 +++++++++++++ .../Import/Parsers/EpisodeWatchCsvParser.cs | 2 +- .../Parsers/LegacyEpisodeWatchCsvParser.cs | 2 +- .../Parsers/RawEpisodeWatchRowParser.cs | 3 +- .../Import/Parsers/SeenEpisodesCsvParser.cs | 12 +++ src/WebApi/Import/TvTimeImportController.cs | 66 +++++++++++-- src/WebApi/Import/TvTimeImportService.cs | 98 +++++++++++++------ src/WebApi/Program.cs | 1 + src/WebApi/WatchNext/WatchNextController.cs | 2 +- src/WebApi/WatchNext/WatchNextService.cs | 17 ++-- .../Resources/TvTimeFixtureZipBuilder.cs | 31 +++++- .../Resources/TvTimeImportResourceTest.cs | 72 +++++++++++--- .../Parsers/EpisodeWatchCsvParserTest.cs | 1 + .../LegacyEpisodeWatchCsvParserTest.cs | 1 + .../WatchNext/WatchNextServiceTest.cs | 36 +++---- 24 files changed, 545 insertions(+), 138 deletions(-) create mode 100644 src/WebApi.Contracts/Dto/ImportJobDto.cs create mode 100644 src/WebApi/Import/ImportJobStore.cs diff --git a/CLAUDE.md b/CLAUDE.md index 06d8ca6..41fb811 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -94,6 +94,14 @@ Not every endpoint is per-item CRUD. `WebApi/WatchNext/` (a read-only cross-enti `seen_episode_source.csv` alone is a drastically incomplete picture of a user's episode history (it's only written when an episode is marked watched via TV Time's episode-detail screen) - confirmed against real export data, not assumed. `TvTimeImportService` also reads `tracking-prod-records.csv` and `tracking-prod-records-v2.csv`, TV Time's generic event logs, which capture episodes marked watched any other way (bulk/season actions). All three are merged and de-duplicated per (show, season, episode), earliest date wins, before upserting `Episode`s. If a future TV Time export field looks suspiciously sparse, check the raw export files directly (`grep` the show name across every `*.csv`) before assuming the current parser set is complete - this is exactly how the tracking files were found. +`followed_tv_show.csv` is not a complete list of shows either - confirmed with a real show ("The Pitt") that has genuine watch history in the tracking files but no row in `followed_tv_show.csv` at all. `ImportEpisodesAsync` creates a show on the fly from watch-event data (title, plus the show's TV Time id when the source file has one, applying the same rating/favorite/notes enrichment a normally-followed show gets) rather than skipping shows that aren't already known. Don't reintroduce a "skip if not already followed" check here. + +When a `SeenEpisodeRecord`-shaped property is only present in *some* of the three source files' headers (like `TvShowId`, absent from `seen_episode_source.csv`), it needs `[Optional]` from `CsvHelper.Configuration.Attributes` in addition to not being C#'s `required` - CsvHelper's header validation throws on a missing column for any `[Name]`-decorated property regardless of C# nullability unless that attribute is present. This only surfaces at runtime against a real file missing the column, not at compile time - a unit test with a realistic fixture (matching `seen_episode_source.csv`'s actual header) is what caught it. + +The import runs as a background job rather than a single request/response, so the UI can show real progress: `POST /api/import/tv-time` buffers the upload, kicks off the work via `IServiceScopeFactory.CreateScope()` (the request's own DI scope is gone by the time the background work runs), and returns a job id immediately; `GET /api/import/tv-time/{jobId}` reports the current `ImportStage`. `ImportJobStore` is an in-memory singleton keyed by job id and checks the caller's owner id on every read, so a job is only ever visible to the user who started it. Follow this shape (buffer input, background `Task` via a fresh scope, pollable status keyed by owner) for any other future long-running action - don't block a request on multi-second server work just because the current single-endpoint pattern is simpler to write. + +Watch Next deliberately reports the *last watched* episode per in-progress show, never a guessed "next" one: Keeptrack has no episode-guide data, so it can't tell whether a further episode exists (the user might already be fully caught up). Don't reintroduce a "+1" heuristic here - it was tried and shipped a real, confirmed-wrong result. + ### Blazor app `InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, which wraps the typed `HttpClient` calls to the Web API (its `GetAsync` takes an optional extra-query-parameters dictionary, used by features that filter on more than search/page/pageSize). Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. @@ -104,6 +112,10 @@ Pages that aren't a generic CRUD list (`TvShowDetail.razor`, `WatchNext/WatchNex `app.css` is a light+dark theme driven by `data-bs-theme` on `` (Bootstrap 5.3's native color-mode support), with Keeptrack's own `--kt-*` tokens layered on top for custom components (sidebar, `kt-table-wrap`, `kt-modal`, etc.). `wwwroot/theme.js` sets the initial theme from `localStorage`/`prefers-color-scheme` before first paint (avoiding a flash of the wrong theme) and exposes `ktToggleTheme()`, called directly from a plain button in `NavMenu.razor` — no Blazor/JS interop needed for the toggle itself. Use system-ui fonts only; no decorative/display webfonts. +Enhanced navigation re-fetches and diffs the whole document on every in-app link click; anything set on ``/`` by client-side JS rather than server-rendered markup (like `data-bs-theme`) gets stripped back out unless it's explicitly re-applied. `wwwroot/Keeptrack.BlazorApp.lib.module.js` is a JS initializer (auto-loaded by Blazor because its name matches the assembly - don't add a manual ` + diff --git a/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs b/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs index 1c4497e..b753dc5 100644 --- a/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs +++ b/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs @@ -7,6 +7,13 @@ public abstract class InventoryApiClientBase(HttpClient http) { protected abstract string ApiResourceName { get; } + /// + /// Exposes the HttpClient to subclasses that add their own calls (e.g. a refresh-reference endpoint) - + /// lets them reuse this instance instead of capturing their own HttpClient primary-constructor + /// parameter as a second field holding the same reference. + /// + protected HttpClient Http => http; + public async Task> GetAsync(string search, int page, int pageSize, IReadOnlyDictionary? extraQuery = null) { var query = $"{ApiResourceName}?search={Uri.EscapeDataString(search)}&page={page}&pageSize={pageSize}"; diff --git a/src/BlazorApp/Components/Inventory/Clients/MovieApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/MovieApiClient.cs index 2773d99..66c9540 100644 --- a/src/BlazorApp/Components/Inventory/Clients/MovieApiClient.cs +++ b/src/BlazorApp/Components/Inventory/Clients/MovieApiClient.cs @@ -6,4 +6,16 @@ public sealed class MovieApiClient(HttpClient http) : InventoryApiClientBase(http) { protected override string ApiResourceName => "/api/movies"; + + /// + /// User-triggered, exact-match-only re-check against the local reference collection + /// (POST api/movies/{id}/refresh-reference on WebApi). Returns the (possibly now-linked) item so the + /// caller can tell whether a match was actually found. + /// + public async Task RefreshReferenceAsync(string id) + { + var response = await Http.PostAsync($"{ApiResourceName}/{id}/refresh-reference", null); + response.EnsureSuccessStatusCode(); + return (await response.Content.ReadFromJsonAsync())!; + } } diff --git a/src/BlazorApp/Components/Inventory/Clients/TvShowApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/TvShowApiClient.cs index bc52495..6458d35 100644 --- a/src/BlazorApp/Components/Inventory/Clients/TvShowApiClient.cs +++ b/src/BlazorApp/Components/Inventory/Clients/TvShowApiClient.cs @@ -6,4 +6,16 @@ public class TvShowApiClient(HttpClient http) : InventoryApiClientBase(http) { protected override string ApiResourceName => "/api/tv-shows"; + + /// + /// User-triggered, exact-match-only re-check against the local reference collection + /// (POST api/tv-shows/{id}/refresh-reference on WebApi). Returns the (possibly now-linked) item so the + /// caller can tell whether a match was actually found. + /// + public async Task RefreshReferenceAsync(string id) + { + var response = await Http.PostAsync($"{ApiResourceName}/{id}/refresh-reference", null); + response.EnsureSuccessStatusCode(); + return (await response.Content.ReadFromJsonAsync())!; + } } diff --git a/src/BlazorApp/Components/Inventory/Pages/MovieDetail.razor b/src/BlazorApp/Components/Inventory/Pages/MovieDetail.razor index c24750c..81bbe6d 100644 --- a/src/BlazorApp/Components/Inventory/Pages/MovieDetail.razor +++ b/src/BlazorApp/Components/Inventory/Pages/MovieDetail.razor @@ -21,23 +21,29 @@ else if (_movie is null) else {
- - - - - - - - +
+ + + @if (_refreshMessage is not null) + { + @_refreshMessage + } +
- @if (string.IsNullOrEmpty(_movie.ReferenceId)) { - + + + + + }
@@ -107,9 +113,15 @@ else [Inject] private ReferenceDataApiClient ReferenceDataApi { get; set; } = null!; + private static readonly TimeSpan RefreshMessageDuration = TimeSpan.FromSeconds(4); + private bool _loading = true; private MovieDto? _movie; private MovieReferenceDto? _reference; + private bool _refreshingReference; + private string? _refreshMessage; + private string _refreshMessageStyle = "neutral"; + private object? _refreshMessageToken; protected override async Task OnParametersSetAsync() => await LoadAsync(); @@ -165,6 +177,54 @@ else await MovieApi.UpdateAsync(_movie); } + private async Task RefreshReferenceAsync() + { + if (_movie?.Id is null) return; + + var previousReferenceId = _movie.ReferenceId; + _refreshingReference = true; + _refreshMessage = null; + try + { + var refreshed = await MovieApi.RefreshReferenceAsync(_movie.Id); + await LoadAsync(); + + (_refreshMessage, _refreshMessageStyle) = string.IsNullOrEmpty(refreshed.ReferenceId) + ? string.IsNullOrEmpty(previousReferenceId) ? ("No match found", "neutral") : ("Unlinked - no match", "danger") + : refreshed.ReferenceId == previousReferenceId ? ("Already linked", "neutral") : ("Linked!", "success"); + } + catch (Exception ex) + { + _refreshMessage = $"Error: {ex.Message}"; + _refreshMessageStyle = "danger"; + } + finally + { + _refreshingReference = false; + } + + ScheduleRefreshMessageClear(); + } + + /// + /// The toast is a small, auto-dismissing pill next to the refresh icon, not a permanent line of text - + /// a token guards against an in-flight delay from a previous click clearing a newer message. + /// + private void ScheduleRefreshMessageClear() + { + var token = new object(); + _refreshMessageToken = token; + _ = ClearRefreshMessageAfterDelayAsync(token); + } + + private async Task ClearRefreshMessageAfterDelayAsync(object token) + { + await Task.Delay(RefreshMessageDuration); + if (!ReferenceEquals(_refreshMessageToken, token)) return; + _refreshMessage = null; + await InvokeAsync(StateHasChanged); + } + private async Task SaveYearAsync(ChangeEventArgs e) { if (_movie is null) return; diff --git a/src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor b/src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor index 3eb18e0..a6cfe6a 100644 --- a/src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor +++ b/src/BlazorApp/Components/Inventory/Pages/TvShowDetail.razor @@ -21,14 +21,17 @@ else if (_show is null) else {
- - - - - - - - +
+ + + @if (_refreshMessage is not null) + { + @_refreshMessage + } +
@@ -43,7 +46,11 @@ else @if (string.IsNullOrEmpty(_show.ReferenceId)) { - + + + + + }
@@ -217,6 +224,11 @@ else private List _unresolvedSeasons = []; private int _selectedSeason; private string? _error; + private static readonly TimeSpan RefreshMessageDuration = TimeSpan.FromSeconds(4); + private bool _refreshingReference; + private string? _refreshMessage; + private string _refreshMessageStyle = "neutral"; + private object? _refreshMessageToken; private int _newSeason = 1; private int _newEpisode = 1; @@ -302,6 +314,54 @@ else await TvShowApi.UpdateAsync(_show); } + private async Task RefreshReferenceAsync() + { + if (_show?.Id is null) return; + + var previousReferenceId = _show.ReferenceId; + _refreshingReference = true; + _refreshMessage = null; + try + { + var refreshed = await TvShowApi.RefreshReferenceAsync(_show.Id); + await LoadAsync(); + + (_refreshMessage, _refreshMessageStyle) = string.IsNullOrEmpty(refreshed.ReferenceId) + ? string.IsNullOrEmpty(previousReferenceId) ? ("No match found", "neutral") : ("Unlinked - no match", "danger") + : refreshed.ReferenceId == previousReferenceId ? ("Already linked", "neutral") : ("Linked!", "success"); + } + catch (Exception ex) + { + _refreshMessage = $"Error: {ex.Message}"; + _refreshMessageStyle = "danger"; + } + finally + { + _refreshingReference = false; + } + + ScheduleRefreshMessageClear(); + } + + /// + /// The toast is a small, auto-dismissing pill next to the refresh icon, not a permanent line of text - + /// a token guards against an in-flight delay from a previous click clearing a newer message. + /// + private void ScheduleRefreshMessageClear() + { + var token = new object(); + _refreshMessageToken = token; + _ = ClearRefreshMessageAfterDelayAsync(token); + } + + private async Task ClearRefreshMessageAfterDelayAsync(object token) + { + await Task.Delay(RefreshMessageDuration); + if (!ReferenceEquals(_refreshMessageToken, token)) return; + _refreshMessage = null; + await InvokeAsync(StateHasChanged); + } + private async Task SaveYearAsync(ChangeEventArgs e) { if (_show is null) return; diff --git a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs index d78c979..40c9ad5 100644 --- a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs +++ b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs @@ -1,3 +1,4 @@ +using System.Net.Http.Headers; using Keeptrack.WebApi.Contracts.Dto; namespace Keeptrack.BlazorApp.Components.ReferenceDataAdmin; @@ -24,4 +25,30 @@ public async Task LinkAsync(LinkReferenceRequestDto request) var response = await http.PostAsJsonAsync("/api/reference-data/link", request); response.EnsureSuccessStatusCode(); } + + /// + /// The full reference dataset (TV shows, movies, cast) as a zip, for seeding a fresh environment. + /// + public async Task ExportAsync() + { + var response = await http.GetAsync("/api/reference-data/export"); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadAsByteArrayAsync(); + } + + /// + /// Idempotent (upsert-by-id) re-import of a previously exported zip. + /// + public async Task ImportAsync(Stream zipStream, string fileName) + { + using var content = new MultipartFormDataContent(); + using var streamContent = new StreamContent(zipStream); + streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/zip"); + content.Add(streamContent, "file", fileName); + + var response = await http.PostAsync("/api/reference-data/import", content); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadFromJsonAsync() + ?? new ReferenceDataImportResultDto { TvShowCount = 0, MovieCount = 0, PersonCount = 0 }; + } } diff --git a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor index 2d39599..e857670 100644 --- a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor +++ b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor @@ -7,6 +7,31 @@

Reference data

+
+

+ Export the whole reference dataset (TV shows, movies, cast) as a zip, or re-import a previously + exported one - re-importing is safe to run more than once, since every document is upserted by id. +

+
+ + + @if (_importing) + { + + } +
+ @if (_importResult is not null) + { +
+ Imported @_importResult.TvShowCount TV show(s), @_importResult.MovieCount movie(s), @_importResult.PersonCount person(s). +
+ } + @if (_importExportError is not null) + { +
@_importExportError
+ } +
+

Titles below couldn't be automatically matched to a TMDB entry (no result, or more than one @@ -104,8 +129,12 @@

@code { + private const long MaxImportFileSize = 50_000_000; + [Inject] private ReferenceDataAdminApiClient Api { get; set; } = null!; + [Inject] private IJSRuntime JsRuntime { get; set; } = null!; + private ReferenceItemType _type = ReferenceItemType.TvShow; private List _unresolved = []; private UnresolvedReferenceDto? _selected; @@ -114,6 +143,50 @@ private bool _linking; private string? _error; + private bool _exporting; + private bool _importing; + private ReferenceDataImportResultDto? _importResult; + private string? _importExportError; + + private async Task ExportAsync() + { + _exporting = true; + _importExportError = null; + try + { + var bytes = await Api.ExportAsync(); + await JsRuntime.InvokeVoidAsync("ktDownloadFile", "keeptrack-reference-data.zip", "application/zip", Convert.ToBase64String(bytes)); + } + catch (Exception ex) + { + _importExportError = ex.Message; + } + finally + { + _exporting = false; + } + } + + private async Task OnImportFileSelectedAsync(InputFileChangeEventArgs e) + { + _importing = true; + _importExportError = null; + _importResult = null; + try + { + await using var stream = e.File.OpenReadStream(MaxImportFileSize); + _importResult = await Api.ImportAsync(stream, e.File.Name); + } + catch (Exception ex) + { + _importExportError = ex.Message; + } + finally + { + _importing = false; + } + } + protected override async Task OnInitializedAsync() => await LoadUnresolvedAsync(); private async Task LoadUnresolvedAsync() diff --git a/src/BlazorApp/Components/WatchNext/WatchNextPage.razor b/src/BlazorApp/Components/WatchNext/WatchNextPage.razor index 95b2873..8efdd1e 100644 --- a/src/BlazorApp/Components/WatchNext/WatchNextPage.razor +++ b/src/BlazorApp/Components/WatchNext/WatchNextPage.razor @@ -17,13 +17,13 @@ else {

In progress

- Where you left off - Keeptrack doesn't know if a new episode is out yet, so check the show itself for that. + Current shows with a confirmed new episode ready to watch.

@if (_data.InProgressShows.Count == 0) {
◈
-

No shows in progress. Mark an episode as watched to see it here.

+

Nothing new to watch. Shows need a "Current" status and a linked reference to appear here.

} else @@ -32,12 +32,10 @@ else @foreach (var show in _data.InProgressShows) { - Last seen S@(show.LastSeasonNumber.ToString("00"))E@(show.LastEpisodeNumber.ToString("00")) + Next: S@(show.NextSeasonNumber.ToString("00"))E@(show.NextEpisodeNumber.ToString("00"))

@show.TvShowTitle

- @if (show.LastWatchedAt is not null) - { -

@show.LastWatchedAt.Value.ToString("yyyy-MM-dd")

- } +

@show.NextEpisodeTitle

+

Last seen S@(show.LastSeasonNumber.ToString("00"))E@(show.LastEpisodeNumber.ToString("00"))

 }
diff --git a/src/BlazorApp/wwwroot/app.css b/src/BlazorApp/wwwroot/app.css index 6560b39..ce669bc 100644 --- a/src/BlazorApp/wwwroot/app.css +++ b/src/BlazorApp/wwwroot/app.css @@ -397,7 +397,10 @@ button.nav-link:hover { color: var(--kt-danger) !important; background: rgba(199 .kt-page-header h1 { font-size: 2rem; color: var(--kt-text); margin: 0; line-height: 1; } .kt-page-header h1 span { color: var(--kt-accent); } -/* editable "title" input on a detail page, styled to read as a heading until you interact with it */ +/* editable "title" input on a detail page, styled to read as a heading until you interact with it. + flex/min-width let it fill its row (rather than a fixed browser-default input width), so a button placed + right after it (e.g. the reference-refresh icon) sits at a predictable spot instead of trailing right + after wherever the visible text happens to end. */ .kt-title-input { font-size: 2rem; font-weight: 700; @@ -408,12 +411,52 @@ button.nav-link:hover { color: var(--kt-danger) !important; background: rgba(199 padding: 0.1rem 0.5rem; margin: 0 0 0 -0.5rem; max-width: 100%; + flex: 1 1 auto; + min-width: 0; font-family: var(--kt-font); } .kt-title-input:hover:not(:disabled) { border-color: var(--kt-border); } .kt-title-input:focus { border-color: var(--kt-accent); outline: none; background: var(--kt-surface); } .kt-title-input:disabled { cursor: not-allowed; } +/* small icon-only button next to the title (e.g. "check for reference match") - borderless/transparent + until hover, matching the title input's own minimal look, instead of standing out as a heavy bordered button */ +.kt-icon-btn { + display: inline-flex; + align-items: center; + justify-content: center; + width: 2.25rem; + height: 2.25rem; + flex-shrink: 0; + border: none; + background: transparent; + border-radius: var(--kt-radius); + color: var(--kt-text-muted); + font-size: 1.2rem; + cursor: pointer; +} +.kt-icon-btn:hover:not(:disabled) { background: var(--kt-surface-3); color: var(--kt-text); } +.kt-icon-btn:disabled { cursor: not-allowed; opacity: 0.5; } + +/* small transient pill next to an inline action button (e.g. the refresh-reference result), instead of a + plain unstyled paragraph that reads like leftover debug output. Same pill shape as .kt-status-badge, with + generic semantic colors instead of TvShowStatus-specific ones. Auto-dismissed from code-behind after a + few seconds - see RefreshReferenceAsync in MovieDetail.razor/TvShowDetail.razor. */ +.kt-inline-toast { + display: inline-flex; + align-items: center; + padding: 0.2rem 0.6rem; + font-size: 0.75rem; + font-weight: 600; + border-radius: 20px; + white-space: nowrap; + animation: kt-toast-in 0.15s ease-out; +} +.kt-inline-toast.success { background: var(--kt-success-bg); color: var(--kt-success); } +.kt-inline-toast.neutral { background: var(--kt-surface-3); color: var(--kt-text-muted); } +.kt-inline-toast.danger { background: var(--kt-danger-bg); color: var(--kt-danger); } +@keyframes kt-toast-in { from { opacity: 0; transform: translateY(-2px); } to { opacity: 1; transform: translateY(0); } } + /* ── Form card ─────────────────────────────────────────────────────── */ .kt-form-card { position: relative; @@ -482,6 +525,10 @@ button.nav-link:hover { color: var(--kt-danger) !important; background: rgba(199 .kt-loading { display: flex; align-items: center; gap: 0.75rem; color: var(--kt-text-muted); font-size: 0.9rem; padding: 4rem 0; justify-content: center; } .kt-spinner { width: 18px; height: 18px; border: 2px solid var(--kt-surface-3); border-top-color: var(--kt-accent); border-radius: 50%; animation: spin 0.75s linear infinite; flex-shrink: 0; } @keyframes spin { to { transform: rotate(360deg); } } + +/* plain monochrome glyph (not a color emoji) for a small inline action button, e.g. "check for reference + match" - spins in place using the same animation as .kt-spinner while the action is running */ +.kt-icon-spin { display: inline-block; animation: spin 0.75s linear infinite; } .kt-empty { text-align: center; padding: 5rem 2rem; } .kt-empty-icon { font-size: 2.5rem; color: var(--kt-text-subtle); display: block; margin-bottom: 1rem; } .kt-empty p { font-size: 0.9rem; color: var(--kt-text-muted); margin: 0; line-height: 1.8; } diff --git a/src/BlazorApp/wwwroot/download.js b/src/BlazorApp/wwwroot/download.js new file mode 100644 index 0000000..8dc6bb6 --- /dev/null +++ b/src/BlazorApp/wwwroot/download.js @@ -0,0 +1,11 @@ +// Triggers a browser save-as for bytes already fetched by C# (e.g. a zip export) - there's no other way +// to hand raw bytes from a Blazor Server component to the browser's download mechanism, since the file +// only exists in the server-side response, not at a public URL the browser could navigate to directly. +window.ktDownloadFile = (fileName, contentType, base64Data) => { + const link = document.createElement('a'); + link.href = `data:${contentType};base64,${base64Data}`; + link.download = fileName; + document.body.appendChild(link); + link.click(); + link.remove(); +}; diff --git a/src/Domain/Models/MovieReferenceModel.cs b/src/Domain/Models/MovieReferenceModel.cs index 816a05f..cb369cf 100644 --- a/src/Domain/Models/MovieReferenceModel.cs +++ b/src/Domain/Models/MovieReferenceModel.cs @@ -22,6 +22,13 @@ public class MovieReferenceModel : IHasId public required Dictionary ExternalIds { get; set; } + /// + /// Every normalized title string that has ever been confirmed (via TMDB resolution, automatic or + /// admin-picked) to mean this movie - not just . See + /// for the full rationale. + /// + public List MatchedTitles { get; set; } = []; + public List Genres { get; set; } = []; public List Cast { get; set; } = []; diff --git a/src/Domain/Models/TvShowReferenceModel.cs b/src/Domain/Models/TvShowReferenceModel.cs index 1ae4434..c8b2833 100644 --- a/src/Domain/Models/TvShowReferenceModel.cs +++ b/src/Domain/Models/TvShowReferenceModel.cs @@ -29,6 +29,15 @@ public class TvShowReferenceModel : IHasId /// public required Dictionary ExternalIds { get; set; } + /// + /// Every normalized title string that has ever been confirmed (via TMDB resolution, automatic or + /// admin-picked) to mean this show - not just . A tenant typing a + /// different-language title, a typo, or a regional variant that an admin resolved to this same TMDB + /// entry gets remembered here, so the next tenant with that exact same text matches instantly without + /// a fresh TMDB search. Always includes itself. + /// + public List MatchedTitles { get; set; } = []; + public List Episodes { get; set; } = []; public List Genres { get; set; } = []; diff --git a/src/Domain/Repositories/IMovieReferenceRepository.cs b/src/Domain/Repositories/IMovieReferenceRepository.cs index 4d3474a..65f8ff4 100644 --- a/src/Domain/Repositories/IMovieReferenceRepository.cs +++ b/src/Domain/Repositories/IMovieReferenceRepository.cs @@ -1,3 +1,4 @@ +using System.Collections.Generic; using System.Threading.Tasks; using Keeptrack.Domain.Models; @@ -13,5 +14,24 @@ public interface IMovieReferenceRepository Task FindByTitleYearAsync(string title, int? year); + /// + /// Title-only fallback match (normalized, ignores year) for "or just title" matching when a + /// title+year lookup finds nothing - e.g. the tenant's recorded year is wrong or missing. + /// + Task FindByTitleAsync(string title); + + /// + /// Looks up a reference document by external provider id (e.g. its TMDB id) - the strongest possible + /// "is this genuinely the same movie" signal, unaffected by title text ever diverging. See + /// for the equivalent on cast members. + /// + Task FindByExternalIdAsync(string provider, string externalId); + Task UpsertAsync(MovieReferenceModel model); + + /// + /// Every reference document, for admin export. Bounded, shared metadata (not per-tenant), so a + /// full unpaged read is fine. + /// + Task> FindAllAsync(); } diff --git a/src/Domain/Repositories/IPersonReferenceRepository.cs b/src/Domain/Repositories/IPersonReferenceRepository.cs index 009766f..aed8d88 100644 --- a/src/Domain/Repositories/IPersonReferenceRepository.cs +++ b/src/Domain/Repositories/IPersonReferenceRepository.cs @@ -1,3 +1,4 @@ +using System.Collections.Generic; using System.Threading.Tasks; using Keeptrack.Domain.Models; @@ -14,4 +15,10 @@ public interface IPersonReferenceRepository Task FindByExternalIdAsync(string provider, string externalId); Task UpsertAsync(PersonReferenceModel model); + + /// + /// Every reference document, for admin export. Bounded, shared metadata (not per-tenant), so a + /// full unpaged read is fine. + /// + Task> FindAllAsync(); } diff --git a/src/Domain/Repositories/ITvShowReferenceRepository.cs b/src/Domain/Repositories/ITvShowReferenceRepository.cs index 30f96d7..cb03aca 100644 --- a/src/Domain/Repositories/ITvShowReferenceRepository.cs +++ b/src/Domain/Repositories/ITvShowReferenceRepository.cs @@ -1,3 +1,4 @@ +using System.Collections.Generic; using System.Threading.Tasks; using Keeptrack.Domain.Models; @@ -14,5 +15,24 @@ public interface ITvShowReferenceRepository Task FindByTitleYearAsync(string title, int? year); + /// + /// Title-only fallback match (normalized, ignores year) for "or just title" matching when a + /// title+year lookup finds nothing - e.g. the tenant's recorded year is wrong or missing. + /// + Task FindByTitleAsync(string title); + + /// + /// Looks up a reference document by external provider id (e.g. its TMDB id) - the strongest possible + /// "is this genuinely the same show" signal, unaffected by title text ever diverging. See + /// for the equivalent on cast members. + /// + Task FindByExternalIdAsync(string provider, string externalId); + Task UpsertAsync(TvShowReferenceModel model); + + /// + /// Every reference document, for admin export. Bounded, shared metadata (not per-tenant), so a + /// full unpaged read is fine. + /// + Task> FindAllAsync(); } diff --git a/src/Infrastructure.MongoDb/Entities/MovieReference.cs b/src/Infrastructure.MongoDb/Entities/MovieReference.cs index 4eefe25..865eab8 100644 --- a/src/Infrastructure.MongoDb/Entities/MovieReference.cs +++ b/src/Infrastructure.MongoDb/Entities/MovieReference.cs @@ -27,6 +27,9 @@ public class MovieReference [BsonElement("external_ids")] public required Dictionary ExternalIds { get; set; } + [BsonElement("matched_titles")] + public List MatchedTitles { get; set; } = []; + public List Genres { get; set; } = []; public List Cast { get; set; } = []; diff --git a/src/Infrastructure.MongoDb/Entities/TvShowReference.cs b/src/Infrastructure.MongoDb/Entities/TvShowReference.cs index 2a042c4..be63e38 100644 --- a/src/Infrastructure.MongoDb/Entities/TvShowReference.cs +++ b/src/Infrastructure.MongoDb/Entities/TvShowReference.cs @@ -27,6 +27,9 @@ public class TvShowReference [BsonElement("external_ids")] public required Dictionary ExternalIds { get; set; } + [BsonElement("matched_titles")] + public List MatchedTitles { get; set; } = []; + public List Episodes { get; set; } = []; public List Genres { get; set; } = []; diff --git a/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs index b3d94ef..f2e2bad 100644 --- a/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs @@ -1,3 +1,5 @@ +using System.Collections.Generic; +using System.Linq; using System.Threading.Tasks; using AutoMapper; using Keeptrack.Common.System; @@ -24,15 +26,43 @@ public class MovieReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp public async Task FindByTitleYearAsync(string title, int? year) { - var filter = Builders.Filter.Eq(x => x.TitleNormalized, TitleNormalizer.Normalize(title)) + // matches against every known-good title variant for this reference (see MatchedTitles), not just + // its canonical TitleNormalized - AnyEq generates an array-contains filter (matched_titles is a + // multikey index), so a differently-titled tenant that previously resolved to this same reference + // is found instantly, with no fresh TMDB search. + var filter = Builders.Filter.AnyEq(x => x.MatchedTitles, TitleNormalizer.Normalize(title)) & Builders.Filter.Eq(x => x.Year, year); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); return entity is null ? null : mapper.Map(entity); } + public async Task FindByTitleAsync(string title) + { + var filter = Builders.Filter.AnyEq(x => x.MatchedTitles, TitleNormalizer.Normalize(title)); + var entity = await Collection.Find(filter).FirstOrDefaultAsync(); + return entity is null ? null : mapper.Map(entity); + } + + public async Task FindByExternalIdAsync(string provider, string externalId) + { + // a string field-path filter, not an expression indexer - the driver's expression-to-filter + // translation doesn't support indexing a Dictionary by a runtime key. + var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); + var entity = await Collection.Find(filter).FirstOrDefaultAsync(); + return entity is null ? null : mapper.Map(entity); + } + + public async Task> FindAllAsync() + { + var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); + return entities.Select(mapper.Map).ToList(); + } + public async Task UpsertAsync(MovieReferenceModel model) { model.TitleNormalized = TitleNormalizer.Normalize(model.Title); + // the canonical title is always itself a valid match, whether or not the caller remembered to include it + if (!model.MatchedTitles.Contains(model.TitleNormalized)) model.MatchedTitles.Add(model.TitleNormalized); var entity = mapper.Map(model); if (string.IsNullOrEmpty(entity.Id)) diff --git a/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs index ccbf232..ddd093b 100644 --- a/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs @@ -1,3 +1,5 @@ +using System.Collections.Generic; +using System.Linq; using System.Threading.Tasks; using AutoMapper; using Keeptrack.Domain.Models; @@ -30,6 +32,12 @@ public class PersonReferenceRepository(IMongoDatabase mongoDatabase, IMapper map return entity is null ? null : mapper.Map(entity); } + public async Task> FindAllAsync() + { + var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); + return entities.Select(mapper.Map).ToList(); + } + public async Task UpsertAsync(PersonReferenceModel model) { var entity = mapper.Map(model); diff --git a/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs index c8ed0f9..887c89c 100644 --- a/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs @@ -1,3 +1,5 @@ +using System.Collections.Generic; +using System.Linq; using System.Threading.Tasks; using AutoMapper; using Keeptrack.Common.System; @@ -24,15 +26,43 @@ public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, IMapper map public async Task FindByTitleYearAsync(string title, int? year) { - var filter = Builders.Filter.Eq(x => x.TitleNormalized, TitleNormalizer.Normalize(title)) + // matches against every known-good title variant for this reference (see MatchedTitles), not just + // its canonical TitleNormalized - AnyEq generates an array-contains filter (matched_titles is a + // multikey index), so a differently-titled tenant that previously resolved to this same reference + // is found instantly, with no fresh TMDB search. + var filter = Builders.Filter.AnyEq(x => x.MatchedTitles, TitleNormalizer.Normalize(title)) & Builders.Filter.Eq(x => x.Year, year); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); return entity is null ? null : mapper.Map(entity); } + public async Task FindByTitleAsync(string title) + { + var filter = Builders.Filter.AnyEq(x => x.MatchedTitles, TitleNormalizer.Normalize(title)); + var entity = await Collection.Find(filter).FirstOrDefaultAsync(); + return entity is null ? null : mapper.Map(entity); + } + + public async Task FindByExternalIdAsync(string provider, string externalId) + { + // a string field-path filter, not an expression indexer - the driver's expression-to-filter + // translation doesn't support indexing a Dictionary by a runtime key. + var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); + var entity = await Collection.Find(filter).FirstOrDefaultAsync(); + return entity is null ? null : mapper.Map(entity); + } + + public async Task> FindAllAsync() + { + var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); + return entities.Select(mapper.Map).ToList(); + } + public async Task UpsertAsync(TvShowReferenceModel model) { model.TitleNormalized = TitleNormalizer.Normalize(model.Title); + // the canonical title is always itself a valid match, whether or not the caller remembered to include it + if (!model.MatchedTitles.Contains(model.TitleNormalized)) model.MatchedTitles.Add(model.TitleNormalized); var entity = mapper.Map(model); if (string.IsNullOrEmpty(entity.Id)) diff --git a/src/WebApi.Contracts/Dto/ReferenceDataImportResultDto.cs b/src/WebApi.Contracts/Dto/ReferenceDataImportResultDto.cs new file mode 100644 index 0000000..15e65d7 --- /dev/null +++ b/src/WebApi.Contracts/Dto/ReferenceDataImportResultDto.cs @@ -0,0 +1,13 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Counts of documents upserted by a reference-data zip import (POST /api/reference-data/import). +/// +public class ReferenceDataImportResultDto +{ + public required int TvShowCount { get; set; } + + public required int MovieCount { get; set; } + + public required int PersonCount { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/WatchNextDto.cs b/src/WebApi.Contracts/Dto/WatchNextDto.cs index 7358b17..f8aad27 100644 --- a/src/WebApi.Contracts/Dto/WatchNextDto.cs +++ b/src/WebApi.Contracts/Dto/WatchNextDto.cs @@ -4,9 +4,9 @@ namespace Keeptrack.WebApi.Contracts.Dto; /// -/// A TV show in progress, with the last episode Keeptrack knows was watched. Deliberately does not -/// guess a "next" episode number: Keeptrack has no episode-guide data, so it has no way to know -/// whether a further episode actually exists (the show might already be fully caught up). +/// A TV show in progress, with the last episode Keeptrack knows was watched and the next confirmed-unseen +/// one from its TMDB episode guide. Only shows with a resolved reference and a confirmed aired-but-unwatched +/// episode are reported at all - see WatchNextService in WebApi. /// public class InProgressShowDto { @@ -19,6 +19,12 @@ public class InProgressShowDto public required int LastEpisodeNumber { get; set; } public DateOnly? LastWatchedAt { get; set; } + + public required int NextSeasonNumber { get; set; } + + public required int NextEpisodeNumber { get; set; } + + public required string NextEpisodeTitle { get; set; } } /// diff --git a/src/WebApi/Controllers/DataCrudControllerBase.cs b/src/WebApi/Controllers/DataCrudControllerBase.cs index 38eced6..3554c18 100644 --- a/src/WebApi/Controllers/DataCrudControllerBase.cs +++ b/src/WebApi/Controllers/DataCrudControllerBase.cs @@ -14,6 +14,13 @@ public abstract class DataCrudControllerBase(IMapper mapper, IData : ControllerBase where TModel : class, IHasIdAndOwnerId { + /// + /// Exposes the mapper to subclasses that add their own actions (e.g. a refresh-reference endpoint) - + /// lets them reuse this instance instead of capturing their own IMapper primary-constructor + /// parameter as a second field holding the same reference. + /// + protected IMapper Mapper => mapper; + [HttpGet] [ProducesResponseType(200)] [ProducesResponseType(400)] diff --git a/src/WebApi/Controllers/MovieController.cs b/src/WebApi/Controllers/MovieController.cs index ef31152..b8ace84 100644 --- a/src/WebApi/Controllers/MovieController.cs +++ b/src/WebApi/Controllers/MovieController.cs @@ -11,7 +11,12 @@ namespace Keeptrack.WebApi.Controllers; [ApiController] [Authorize] [Route("api/movies")] -public class MovieController(IMapper mapper, IMovieRepository dataRepository, IServiceScopeFactory scopeFactory, ILogger logger) +public class MovieController( + IMapper mapper, + IMovieRepository dataRepository, + ReferenceEnrichmentService enrichmentService, + IServiceScopeFactory scopeFactory, + ILogger logger) : DataCrudControllerBase(mapper, dataRepository) { /// @@ -26,8 +31,8 @@ protected override Task OnCreatedAsync(MovieModel model) try { using var scope = scopeFactory.CreateScope(); - var enrichmentService = scope.ServiceProvider.GetRequiredService(); - await enrichmentService.TryAutoResolveMovieAsync(title, year); + var scopedEnrichmentService = scope.ServiceProvider.GetRequiredService(); + await scopedEnrichmentService.TryAutoResolveMovieAsync(title, year); } catch (Exception ex) { @@ -36,4 +41,20 @@ protected override Task OnCreatedAsync(MovieModel model) }); return Task.CompletedTask; } + + /// + /// User-triggered, exact-match-only re-check against the local reference collection - see + /// . + /// + [HttpPost("{id}/refresh-reference")] + [ProducesResponseType(200)] + [ProducesResponseType(404)] + public async Task> RefreshReference(string id) + { + var model = await dataRepository.FindOneAsync(id, this.GetUserId()); + if (model is null) return NotFound(); + + model = await enrichmentService.TryLinkExistingMovieReferenceAsync(model); + return Ok(Mapper.Map(model)); + } } diff --git a/src/WebApi/Controllers/TvShowController.cs b/src/WebApi/Controllers/TvShowController.cs index 8dfe2f3..a01ccf9 100644 --- a/src/WebApi/Controllers/TvShowController.cs +++ b/src/WebApi/Controllers/TvShowController.cs @@ -11,7 +11,12 @@ namespace Keeptrack.WebApi.Controllers; [ApiController] [Authorize] [Route("api/tv-shows")] -public class TvShowController(IMapper mapper, ITvShowRepository dataRepository, IServiceScopeFactory scopeFactory, ILogger logger) +public class TvShowController( + IMapper mapper, + ITvShowRepository dataRepository, + ReferenceEnrichmentService enrichmentService, + IServiceScopeFactory scopeFactory, + ILogger logger) : DataCrudControllerBase(mapper, dataRepository) { /// @@ -27,8 +32,8 @@ protected override Task OnCreatedAsync(TvShowModel model) try { using var scope = scopeFactory.CreateScope(); - var enrichmentService = scope.ServiceProvider.GetRequiredService(); - await enrichmentService.TryAutoResolveTvShowAsync(title, year); + var scopedEnrichmentService = scope.ServiceProvider.GetRequiredService(); + await scopedEnrichmentService.TryAutoResolveTvShowAsync(title, year); } catch (Exception ex) { @@ -37,4 +42,21 @@ protected override Task OnCreatedAsync(TvShowModel model) }); return Task.CompletedTask; } + + /// + /// User-triggered, exact-match-only re-check against the local reference collection - no TMDB call. + /// Distinct from the admin-only live TMDB search/linker: this only ever picks up a match that already + /// exists locally (e.g. after the tenant fixes a typo'd title), so any user can trigger it. + /// + [HttpPost("{id}/refresh-reference")] + [ProducesResponseType(200)] + [ProducesResponseType(404)] + public async Task> RefreshReference(string id) + { + var model = await dataRepository.FindOneAsync(id, this.GetUserId()); + if (model is null) return NotFound(); + + model = await enrichmentService.TryLinkExistingTvShowReferenceAsync(model); + return Ok(Mapper.Map(model)); + } } diff --git a/src/WebApi/ReferenceData/ReferenceDataAdminController.cs b/src/WebApi/ReferenceData/ReferenceDataAdminController.cs index 39d1068..858b0b9 100644 --- a/src/WebApi/ReferenceData/ReferenceDataAdminController.cs +++ b/src/WebApi/ReferenceData/ReferenceDataAdminController.cs @@ -1,6 +1,10 @@ using System.Collections.Generic; +using System.IO; +using System.IO.Compression; using System.Linq; +using System.Text.Json; using System.Threading.Tasks; +using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -18,8 +22,96 @@ public class ReferenceDataAdminController( ITvShowRepository tvShowRepository, IMovieRepository movieRepository, ITmdbClient tmdbClient, - ReferenceEnrichmentService enrichmentService) : ControllerBase + ReferenceEnrichmentService enrichmentService, + ITvShowReferenceRepository tvShowReferenceRepository, + IMovieReferenceRepository movieReferenceRepository, + IPersonReferenceRepository personReferenceRepository) : ControllerBase { + private const string TvShowEntryName = "tvshow_reference.json"; + private const string MovieEntryName = "movie_reference.json"; + private const string PersonEntryName = "person_reference.json"; + + /// + /// Every reference document (TV shows, movies, cast) as a zip, so an admin can seed a fresh + /// environment's reference data without re-earning every TMDB match one search at a time. + /// + [HttpGet("export")] + [ProducesResponseType(200)] + public async Task Export() + { + var tvShows = await tvShowReferenceRepository.FindAllAsync(); + var movies = await movieReferenceRepository.FindAllAsync(); + var people = await personReferenceRepository.FindAllAsync(); + + var buffer = new MemoryStream(); + using (var archive = new ZipArchive(buffer, ZipArchiveMode.Create, leaveOpen: true)) + { + await WriteJsonEntryAsync(archive, TvShowEntryName, tvShows); + await WriteJsonEntryAsync(archive, MovieEntryName, movies); + await WriteJsonEntryAsync(archive, PersonEntryName, people); + } + + buffer.Position = 0; + return File(buffer, "application/zip", "keeptrack-reference-data.zip"); + } + + /// + /// Idempotent (upsert-by-id) re-import of a previously exported zip - re-running the same import + /// twice is a no-op the second time, since every document already carries the id it was exported with. + /// + [HttpPost("import")] + [RequestSizeLimit(50_000_000)] + [Consumes("multipart/form-data")] + [ProducesResponseType(200)] + [ProducesResponseType(400)] + public async Task> Import(IFormFile file) + { + if (file.Length == 0) return BadRequest(); + + await using var uploadStream = file.OpenReadStream(); + using var archive = new ZipArchive(uploadStream, ZipArchiveMode.Read); + + var tvShowCount = 0; + var movieCount = 0; + var personCount = 0; + + foreach (var show in await ReadJsonEntryAsync(archive, TvShowEntryName)) + { + await tvShowReferenceRepository.UpsertAsync(show); + tvShowCount++; + } + + foreach (var movie in await ReadJsonEntryAsync(archive, MovieEntryName)) + { + await movieReferenceRepository.UpsertAsync(movie); + movieCount++; + } + + foreach (var person in await ReadJsonEntryAsync(archive, PersonEntryName)) + { + await personReferenceRepository.UpsertAsync(person); + personCount++; + } + + return Ok(new ReferenceDataImportResultDto { TvShowCount = tvShowCount, MovieCount = movieCount, PersonCount = personCount }); + } + + private static async Task WriteJsonEntryAsync(ZipArchive archive, string entryName, T value) + { + var entry = archive.CreateEntry(entryName, CompressionLevel.Optimal); + await using var entryStream = entry.Open(); + await JsonSerializer.SerializeAsync(entryStream, value); + } + + private static async Task> ReadJsonEntryAsync(ZipArchive archive, string entryName) + { + var entry = archive.GetEntry(entryName); + if (entry is null) return []; + + await using var entryStream = entry.Open(); + return await JsonSerializer.DeserializeAsync>(entryStream) ?? []; + } + /// /// Distinct (title, year) pairs, across every tenant, still missing a reference-data link. /// diff --git a/src/WebApi/ReferenceData/ReferenceEnrichmentService.cs b/src/WebApi/ReferenceData/ReferenceEnrichmentService.cs index 3900a66..02845cb 100644 --- a/src/WebApi/ReferenceData/ReferenceEnrichmentService.cs +++ b/src/WebApi/ReferenceData/ReferenceEnrichmentService.cs @@ -28,6 +28,79 @@ public class ReferenceEnrichmentService( /// private const int MaxCastMembers = 15; + /// + /// User-triggered "check for reference match" - looks only at the local reference collection (title+year, + /// falling back to title-only, against every title ever confirmed for that reference - see + /// ), never TMDB. Cheap enough to run on demand from a + /// detail page: no HTTP call, just an indexed Mongo lookup. Deliberately does NOT short-circuit when the + /// model already has a link: the whole point is to let a tenant who isn't happy with the current match + /// fix the title/year and re-check, replacing a wrong link - "don't guess" only applies to inventing a + /// match from nothing, not to re-verifying one the tenant explicitly asked to redo. Updates only this + /// tenant's own document directly (not the broad cross-tenant , + /// which refuses to touch already-linked documents by design), but still calls that method with the + /// pre-edit title/year afterward so any other still-unresolved tenant sharing that text benefits too. + /// If no match is found for the current title/year and the document WAS linked, the link is cleared + /// rather than left pointing at something the tenant just told us (by editing the title) is wrong - + /// clearing ReferenceId is also exactly what puts it back into the admin's unresolved queue + /// () for a manual TMDB search. + /// + public async Task TryLinkExistingTvShowReferenceAsync(TvShowModel model) + { + var reference = await tvShowReferenceRepository.FindByTitleYearAsync(model.Title, model.Year) + ?? await tvShowReferenceRepository.FindByTitleAsync(model.Title); + + if (reference is null) + { + if (!string.IsNullOrEmpty(model.ReferenceId)) + { + model.ReferenceId = string.Empty; + await tvShowRepository.UpdateAsync(model.Id!, model, model.OwnerId); + } + + return model; + } + + var originalTitle = model.Title; + var originalYear = model.Year; + + model.ReferenceId = reference.Id; + model.Title = reference.Title; + await tvShowRepository.UpdateAsync(model.Id!, model, model.OwnerId); + await tvShowRepository.SetReferenceLinkAsync(originalTitle, originalYear, reference.Id!, reference.Title); + + return model; + } + + /// + /// Movie equivalent of . + /// + public async Task TryLinkExistingMovieReferenceAsync(MovieModel model) + { + var reference = await movieReferenceRepository.FindByTitleYearAsync(model.Title, model.Year) + ?? await movieReferenceRepository.FindByTitleAsync(model.Title); + + if (reference is null) + { + if (!string.IsNullOrEmpty(model.ReferenceId)) + { + model.ReferenceId = string.Empty; + await movieRepository.UpdateAsync(model.Id!, model, model.OwnerId); + } + + return model; + } + + var originalTitle = model.Title; + var originalYear = model.Year; + + model.ReferenceId = reference.Id; + model.Title = reference.Title; + await movieRepository.UpdateAsync(model.Id!, model, model.OwnerId); + await movieRepository.SetReferenceLinkAsync(originalTitle, originalYear, reference.Id!, reference.Title); + + return model; + } + /// /// Best-effort automatic match: does nothing if the search returns zero or more than one candidate, /// leaving the show unresolved for the admin queue instead of guessing. @@ -59,7 +132,12 @@ public async Task ResolveTvShowAsync(string title, int? ye ?? throw new InvalidOperationException($"TMDB show {tmdbId} could not be fetched."); var cast = await tmdbClient.GetTvShowCastAsync(tmdbId); - var existing = await tvShowReferenceRepository.FindByTitleYearAsync(title, year); + // tmdbId is checked first and is authoritative: two tenants resolving the exact same TMDB show under + // different title text (a translation, a typo an admin corrected) must reuse the same reference + // document, not create a duplicate - title/year matching alone can't guarantee that, only the id can. + var existing = await tvShowReferenceRepository.FindByExternalIdAsync("tmdb", tmdbId) + ?? await tvShowReferenceRepository.FindByTitleYearAsync(title, year) + ?? await tvShowReferenceRepository.FindByTitleAsync(title); var externalIds = existing?.ExternalIds ?? new Dictionary(); externalIds["tmdb"] = tmdbId; @@ -71,6 +149,9 @@ public async Task ResolveTvShowAsync(string title, int? ye Year = details.Year ?? year, Synopsis = details.Synopsis, ExternalIds = externalIds, + // remembers both the canonical TMDB title and whatever text the tenant actually searched with - + // see MatchedTitles: this is what lets a later, differently-titled tenant match instantly + MatchedTitles = MergeMatchedTitles(existing?.MatchedTitles, details.Title, title), Episodes = details.Episodes .Select(e => new ReferenceEpisodeModel { SeasonNumber = e.SeasonNumber, EpisodeNumber = e.EpisodeNumber, Title = e.Title, AirDate = e.AirDate }) .ToList(), @@ -94,7 +175,12 @@ public async Task ResolveMovieAsync(string title, int? year ?? throw new InvalidOperationException($"TMDB movie {tmdbId} could not be fetched."); var cast = await tmdbClient.GetMovieCastAsync(tmdbId); - var existing = await movieReferenceRepository.FindByTitleYearAsync(title, year); + // tmdbId is checked first and is authoritative: two tenants resolving the exact same TMDB movie under + // different title text (a translation, a typo an admin corrected) must reuse the same reference + // document, not create a duplicate - title/year matching alone can't guarantee that, only the id can. + var existing = await movieReferenceRepository.FindByExternalIdAsync("tmdb", tmdbId) + ?? await movieReferenceRepository.FindByTitleYearAsync(title, year) + ?? await movieReferenceRepository.FindByTitleAsync(title); var externalIds = existing?.ExternalIds ?? new Dictionary(); externalIds["tmdb"] = tmdbId; @@ -106,6 +192,9 @@ public async Task ResolveMovieAsync(string title, int? year Year = details.Year ?? year, Synopsis = details.Synopsis, ExternalIds = externalIds, + // remembers both the canonical TMDB title and whatever text the tenant actually searched with - + // see MatchedTitles: this is what lets a later, differently-titled tenant match instantly + MatchedTitles = MergeMatchedTitles(existing?.MatchedTitles, details.Title, title), Genres = details.Genres, Cast = await ResolveCastAsync(cast), PosterUrl = details.PosterUrl, @@ -117,6 +206,23 @@ public async Task ResolveMovieAsync(string title, int? year return saved; } + /// + /// Combines whatever title variants a reference document already remembered with the two new ones this + /// resolution just confirmed: the TMDB canonical name and the text the tenant actually searched with (which + /// may be a typo, a translation, or otherwise differ from canonical). Deduplicated and normalized. + /// + private static List MergeMatchedTitles(List? existing, string canonicalTitle, string searchedTitle) + { + var titles = new List(existing ?? []); + foreach (var title in new[] { canonicalTitle, searchedTitle }) + { + var normalized = TitleNormalizer.Normalize(title); + if (!titles.Contains(normalized)) titles.Add(normalized); + } + + return titles; + } + /// /// Upserts each cast member into the shared, owner-less person_reference collection (deduplicated by /// TMDB person id - the same actor credited in two different shows only ever gets one document), then diff --git a/src/WebApi/WatchNext/WatchNextController.cs b/src/WebApi/WatchNext/WatchNextController.cs index 251b62c..d74cfce 100644 --- a/src/WebApi/WatchNext/WatchNextController.cs +++ b/src/WebApi/WatchNext/WatchNextController.cs @@ -13,6 +13,7 @@ public class WatchNextController( ITvShowRepository tvShowRepository, IEpisodeRepository episodeRepository, IMovieRepository movieRepository, + ITvShowReferenceRepository tvShowReferenceRepository, WatchNextService watchNextService, IMapper mapper) : ControllerBase { @@ -30,9 +31,18 @@ public async Task> Get() var moviesToWatch = await movieRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, new MovieModel { OwnerId = ownerId, Title = string.Empty, WantToWatch = true }); + // only current shows with a reference link can possibly appear in the result (see WatchNextService), + // so only those need their (small, bounded) episode guide fetched + var referencesByShowId = new Dictionary(); + foreach (var show in shows.Items.Where(s => s.Status == Domain.Models.TvShowStatus.Current && !string.IsNullOrEmpty(s.ReferenceId))) + { + var reference = await tvShowReferenceRepository.FindByIdAsync(show.ReferenceId!); + if (reference is not null) referencesByShowId[show.Id!] = reference; + } + return Ok(new WatchNextDto { - InProgressShows = watchNextService.ComputeInProgressShows(shows.Items, episodes.Items), + InProgressShows = watchNextService.ComputeInProgressShows(shows.Items, episodes.Items, referencesByShowId), MoviesToWatch = mapper.Map>(moviesToWatch.Items) }); } diff --git a/src/WebApi/WatchNext/WatchNextService.cs b/src/WebApi/WatchNext/WatchNextService.cs index 3a85de9..56d07b2 100644 --- a/src/WebApi/WatchNext/WatchNextService.cs +++ b/src/WebApi/WatchNext/WatchNextService.cs @@ -1,3 +1,4 @@ +using System; using System.Collections.Generic; using System.Linq; using Keeptrack.Domain.Models; @@ -6,41 +7,61 @@ namespace Keeptrack.WebApi.WatchNext; /// -/// Computes, for each in-progress TV show, the last episode Keeptrack knows was watched. +/// Computes, for each in-progress TV show, whether there is a confirmed unseen episode to watch next. /// public class WatchNextService { /// - /// For every show that has at least one watched episode and isn't finished, reports the highest - /// (season, episode) watched so far. Deliberately doesn't propose a "next" episode: without - /// episode-guide data, Keeptrack can't tell whether a further episode exists yet, so guessing one - /// (e.g. "+1") can claim a show still has more to watch when it's actually fully caught up. + /// A show only appears here if it's marked AND has a resolved TMDB + /// episode guide () confirming an aired episode exists after the + /// last one watched. Without a reference, Keeptrack has no episode-guide data and can't tell whether a + /// further episode actually exists (the show might already be fully caught up) - so unlinked shows are + /// excluded rather than guessed at, the same "don't guess" principle as before, now enforced by data. /// - public List ComputeInProgressShows(IEnumerable shows, IEnumerable episodes) + public List ComputeInProgressShows( + IEnumerable shows, + IEnumerable episodes, + IReadOnlyDictionary referencesByShowId) { - var inProgressShows = shows - .Where(s => s.Status != Domain.Models.TvShowStatus.Finished && s.Status != Domain.Models.TvShowStatus.Stopped) - .ToDictionary(s => s.Id!); + var currentShows = shows.Where(s => s.Status == Domain.Models.TvShowStatus.Current).ToDictionary(s => s.Id!); + var today = DateOnly.FromDateTime(DateTime.Today); return episodes - .Where(e => inProgressShows.ContainsKey(e.TvShowId)) + .Where(e => currentShows.ContainsKey(e.TvShowId)) .GroupBy(e => e.TvShowId) .Select(group => { - var show = inProgressShows[group.Key]; + var show = currentShows[group.Key]; var lastWatched = group .OrderByDescending(e => e.SeasonNumber) .ThenByDescending(e => e.EpisodeNumber) .First(); + + if (!referencesByShowId.TryGetValue(group.Key, out var reference)) return null; + + var nextEpisode = reference.Episodes + .Where(e => e.SeasonNumber > lastWatched.SeasonNumber + || (e.SeasonNumber == lastWatched.SeasonNumber && e.EpisodeNumber > lastWatched.EpisodeNumber)) + .Where(e => e.AirDate is null || e.AirDate <= today) + .OrderBy(e => e.SeasonNumber) + .ThenBy(e => e.EpisodeNumber) + .FirstOrDefault(); + if (nextEpisode is null) return null; + return new InProgressShowDto { TvShowId = show.Id!, TvShowTitle = show.Title, LastSeasonNumber = lastWatched.SeasonNumber, LastEpisodeNumber = lastWatched.EpisodeNumber, - LastWatchedAt = lastWatched.WatchedAt + LastWatchedAt = lastWatched.WatchedAt, + NextSeasonNumber = nextEpisode.SeasonNumber, + NextEpisodeNumber = nextEpisode.EpisodeNumber, + NextEpisodeTitle = nextEpisode.Title }; }) + .Where(dto => dto is not null) + .Select(dto => dto!) .OrderByDescending(n => n.LastWatchedAt) .ToList(); } diff --git a/test/WebApi.IntegrationTests/Resources/ReferenceDataExportImportTest.cs b/test/WebApi.IntegrationTests/Resources/ReferenceDataExportImportTest.cs new file mode 100644 index 0000000..a82d8e3 --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/ReferenceDataExportImportTest.cs @@ -0,0 +1,131 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using AwesomeAssertions; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Microsoft.Extensions.DependencyInjection; +using MongoDB.Driver; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Exercises the reference repositories' FindAllAsync (backs the admin zip export) directly against +/// real MongoDB, and confirms re-upserting an already-exported document (the zip import path) is a true +/// no-op the second time - the whole point of "idempotent" for POST /api/reference-data/import. +/// +public class ReferenceDataExportImportTest(KestrelWebAppFactory factory) : IClassFixture> +{ + [Fact] + public async Task TvShowReferenceRepository_FindAllAsync_IncludesEveryDocument() + { + using var scope = factory.Services.CreateScope(); + var repository = scope.ServiceProvider.GetRequiredService(); + var title = $"Export Test Show {Guid.NewGuid()}"; + + var created = await repository.UpsertAsync(new TvShowReferenceModel + { + Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["tmdb"] = "1" } + }); + + try + { + var all = await repository.FindAllAsync(); + + all.Should().Contain(m => m.Id == created.Id && m.Title == title); + } + finally + { + await DeleteAsync(scope, "tvshow_reference", created.Id!); + } + } + + [Fact] + public async Task TvShowReferenceRepository_ReimportingTheSameExportedDocument_IsANoOp() + { + using var scope = factory.Services.CreateScope(); + var repository = scope.ServiceProvider.GetRequiredService(); + var title = $"Reimport Test Show {Guid.NewGuid()}"; + + var created = await repository.UpsertAsync(new TvShowReferenceModel + { + Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["tmdb"] = "1" } + }); + + try + { + // simulates re-running an import of a previously exported document: same id, same content + await repository.UpsertAsync(new TvShowReferenceModel + { + Id = created.Id, Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, + ExternalIds = new Dictionary { ["tmdb"] = "1" } + }); + + var all = await repository.FindAllAsync(); + + all.Count(m => m.Id == created.Id).Should().Be(1); + } + finally + { + await DeleteAsync(scope, "tvshow_reference", created.Id!); + } + } + + [Fact] + public async Task MovieReferenceRepository_FindAllAsync_IncludesEveryDocument() + { + using var scope = factory.Services.CreateScope(); + var repository = scope.ServiceProvider.GetRequiredService(); + var title = $"Export Test Movie {Guid.NewGuid()}"; + + var created = await repository.UpsertAsync(new MovieReferenceModel + { + Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["tmdb"] = "1" } + }); + + try + { + var all = await repository.FindAllAsync(); + + all.Should().Contain(m => m.Id == created.Id && m.Title == title); + } + finally + { + await DeleteAsync(scope, "movie_reference", created.Id!); + } + } + + [Fact] + public async Task PersonReferenceRepository_FindAllAsync_IncludesEveryDocument() + { + using var scope = factory.Services.CreateScope(); + var repository = scope.ServiceProvider.GetRequiredService(); + var tmdbId = Guid.NewGuid().ToString(); + + var created = await repository.UpsertAsync(new PersonReferenceModel + { + Name = "Export Test Actor", ExternalIds = new Dictionary { ["tmdb"] = tmdbId } + }); + + try + { + var all = await repository.FindAllAsync(); + + all.Should().Contain(p => p.Id == created.Id && p.Name == "Export Test Actor"); + } + finally + { + await DeleteAsync(scope, "person_reference", created.Id!); + } + } + + private static async Task DeleteAsync(IServiceScope scope, string collectionName, string id) where TEntity : class + { + var collection = scope.ServiceProvider.GetRequiredService().GetCollection(collectionName); + await collection.DeleteOneAsync(Builders.Filter.Eq("_id", id), TestContext.Current.CancellationToken); + } +} diff --git a/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs b/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs new file mode 100644 index 0000000..47b064b --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections.Generic; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Microsoft.Extensions.DependencyInjection; +using MongoDB.Driver; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Exercises POST /api/tv-shows/{id}/refresh-reference and /api/movies/{id}/refresh-reference - the +/// user-triggered, exact-match-only re-check against the local reference collection. Deliberately not +/// admin-gated (unlike the TMDB search/link endpoints), so the standard test user can call it directly. +/// +public class RefreshReferenceResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + [Fact] + public async Task RefreshReference_LinksTvShow_WhenAnExistingReferenceMatchesByTitleAndYear() + { + using var scope = Factory.Services.CreateScope(); + var referenceRepository = scope.ServiceProvider.GetRequiredService(); + var title = $"Refresh Reference Test Show {Guid.NewGuid()}"; + const int year = 2019; + + var reference = await referenceRepository.UpsertAsync(new TvShowReferenceModel + { + Title = "Canonical Title", TitleNormalized = "canonical title", Year = year, ExternalIds = new Dictionary { ["tmdb"] = "1" } + }); + + await Authenticate(); + var created = await PostAsync("/api/tv-shows", new TvShowDto { Title = title, Year = year }); + + try + { + var refreshed = await PostAsync($"/api/tv-shows/{created.Id}/refresh-reference", null, HttpStatusCode.OK); + + refreshed!.ReferenceId.Should().Be(reference.Id); + refreshed.Title.Should().Be("Canonical Title"); + } + finally + { + await DeleteAsync($"/api/tv-shows/{created.Id}"); + await DeleteReferenceAsync(scope, "tvshow_reference", reference.Id!); + } + } + + [Fact] + public async Task RefreshReference_LeavesTvShowUnresolved_WhenNoMatchingReferenceExists() + { + await Authenticate(); + var title = $"Refresh Reference No Match {Guid.NewGuid()}"; + var created = await PostAsync("/api/tv-shows", new TvShowDto { Title = title, Year = 2019 }); + + try + { + var refreshed = await PostAsync($"/api/tv-shows/{created.Id}/refresh-reference", null, HttpStatusCode.OK); + + refreshed!.ReferenceId.Should().BeNullOrEmpty(); + } + finally + { + await DeleteAsync($"/api/tv-shows/{created.Id}"); + } + } + + [Fact] + public async Task RefreshReference_LinksMovie_WhenAnExistingReferenceMatchesByTitleAndYear() + { + using var scope = Factory.Services.CreateScope(); + var referenceRepository = scope.ServiceProvider.GetRequiredService(); + var title = $"Refresh Reference Test Movie {Guid.NewGuid()}"; + const int year = 2019; + + var reference = await referenceRepository.UpsertAsync(new MovieReferenceModel + { + Title = "Canonical Movie Title", TitleNormalized = "canonical movie title", Year = year, ExternalIds = new Dictionary { ["tmdb"] = "1" } + }); + + await Authenticate(); + var created = await PostAsync("/api/movies", new MovieDto { Title = title, Year = year }); + + try + { + var refreshed = await PostAsync($"/api/movies/{created.Id}/refresh-reference", null, HttpStatusCode.OK); + + refreshed!.ReferenceId.Should().Be(reference.Id); + refreshed.Title.Should().Be("Canonical Movie Title"); + } + finally + { + await DeleteAsync($"/api/movies/{created.Id}"); + await DeleteReferenceAsync(scope, "movie_reference", reference.Id!); + } + } + + private static async Task DeleteReferenceAsync(IServiceScope scope, string collectionName, string id) where TEntity : class + { + var collection = scope.ServiceProvider.GetRequiredService().GetCollection(collectionName); + await collection.DeleteOneAsync(Builders.Filter.Eq("_id", id), TestContext.Current.CancellationToken); + } +} diff --git a/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs b/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs index 70590b4..31d9785 100644 --- a/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs +++ b/test/WebApi.IntegrationTests/Resources/ResourceTestBase.cs @@ -17,6 +17,13 @@ public abstract class ResourceTestBase(KestrelWebAppFactory factory) { private const string MediaTypeJson = "application/json"; + /// + /// Exposes the factory to subclasses that also need a DI scope (e.g. to seed data directly via a + /// repository) alongside the HTTP helpers below - avoids a second, redundant capture of the same + /// constructor parameter as its own field. + /// + protected KestrelWebAppFactory Factory => factory; + private HttpClient _httpClient = null!; public ValueTask InitializeAsync() diff --git a/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs b/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs new file mode 100644 index 0000000..c509dc9 --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs @@ -0,0 +1,114 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using AwesomeAssertions; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Microsoft.Extensions.DependencyInjection; +using MongoDB.Driver; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Exercises / +/// against real MongoDB - both now match against every entry in MatchedTitles (an array-contains +/// filter via Builders.Filter.AnyEq, backing a multikey index), not just the document's own +/// canonical TitleNormalized. This is exactly the kind of hand-written Mongo filter that has hidden +/// real bugs before (see docs/code-quality-findings.md), so it's verified against a real database, not mocks. +/// +public class TvShowReferenceRepositoryTest(KestrelWebAppFactory factory) : IClassFixture> +{ + [Fact] + public async Task FindByTitleYearAsync_MatchesAnAlternateTitle_NotJustTheCanonicalOne() + { + using var scope = factory.Services.CreateScope(); + var repository = scope.ServiceProvider.GetRequiredService(); + var alternateTitle = $"Alternate Title {Guid.NewGuid()}"; + const int year = 2005; + + var created = await repository.UpsertAsync(new TvShowReferenceModel + { + Title = "Canonical Title", + TitleNormalized = "canonical title", + Year = year, + ExternalIds = new Dictionary { ["tmdb"] = "1" }, + MatchedTitles = [alternateTitle.ToLowerInvariant()] + }); + + try + { + // case-insensitive: normalization lower-cases before comparing + var found = await repository.FindByTitleYearAsync(alternateTitle.ToUpperInvariant(), year); + + found.Should().NotBeNull(); + found!.Id.Should().Be(created.Id); + } + finally + { + await DeleteAsync(scope, created.Id!); + } + } + + [Fact] + public async Task FindByTitleAsync_MatchesAnAlternateTitle_IgnoringYear() + { + using var scope = factory.Services.CreateScope(); + var repository = scope.ServiceProvider.GetRequiredService(); + var alternateTitle = $"Alternate Title {Guid.NewGuid()}"; + + var created = await repository.UpsertAsync(new TvShowReferenceModel + { + Title = "Canonical Title", + TitleNormalized = "canonical title", + Year = 2005, + ExternalIds = new Dictionary { ["tmdb"] = "1" }, + MatchedTitles = [alternateTitle.ToLowerInvariant()] + }); + + try + { + var found = await repository.FindByTitleAsync(alternateTitle); + + found.Should().NotBeNull(); + found!.Id.Should().Be(created.Id); + } + finally + { + await DeleteAsync(scope, created.Id!); + } + } + + [Fact] + public async Task UpsertAsync_AlwaysIncludesTheCanonicalTitleInMatchedTitles_EvenIfTheCallerForgot() + { + using var scope = factory.Services.CreateScope(); + var repository = scope.ServiceProvider.GetRequiredService(); + var title = $"Canonical Only Title {Guid.NewGuid()}"; + + var created = await repository.UpsertAsync(new TvShowReferenceModel + { + Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2010, ExternalIds = new Dictionary { ["tmdb"] = "1" } + }); + + try + { + var found = await repository.FindByTitleAsync(title); + + found.Should().NotBeNull(); + found!.Id.Should().Be(created.Id); + } + finally + { + await DeleteAsync(scope, created.Id!); + } + } + + private static async Task DeleteAsync(IServiceScope scope, string id) + { + var collection = scope.ServiceProvider.GetRequiredService().GetCollection("tvshow_reference"); + await collection.DeleteOneAsync(Builders.Filter.Eq(x => x.Id, id), TestContext.Current.CancellationToken); + } +} diff --git a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs index 209df3f..01f9e5d 100644 --- a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs +++ b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs @@ -77,6 +77,68 @@ public async Task ResolveTvShowAsync_PropagatesTheUpsertedReferenceId() _tvShowRepository.Verify(r => r.SetReferenceLinkAsync("Some Show", 2020, "reference-1", "Some Show"), Times.Once); } + [Fact] + public async Task ResolveTvShowAsync_ReusesTheSameReferenceByTmdbId_EvenWhenTitleTextDiffersEntirely() + { + // regression test: resolving the exact same TMDB show twice under two completely unrelated title + // strings (e.g. a translation an admin didn't recognize) used to create a second, duplicate + // reference document, because the "does this already exist" check only ever looked at title/year - + // tmdbId is now checked first and is authoritative. + var tmdbClient = FakeTmdbClient.WithTvShowSearchResults(); + tmdbClient.TvShowDetails["42"] = new TmdbTvShowDetails("42", "The Wire", 2002, "Synopsis", [], [], null); + _tvShowReferenceRepository + .Setup(r => r.FindByExternalIdAsync("tmdb", "42")) + .ReturnsAsync(new TvShowReferenceModel + { + Id = "reference-1", Title = "The Wire", TitleNormalized = "the wire", ExternalIds = new Dictionary { ["tmdb"] = "42" }, MatchedTitles = ["the wire"] + }); + _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); + var service = CreateService(tmdbClient); + + var result = await service.ResolveTvShowAsync("Totally Unrelated Search Text", null, "42"); + + result.Id.Should().Be("reference-1"); + _tvShowReferenceRepository.Verify(r => r.UpsertAsync(It.Is(m => m.Id == "reference-1")), Times.Once); + } + + [Fact] + public async Task ResolveTvShowAsync_RecordsBothTheSearchedAndCanonicalTitleAsMatchedTitles() + { + var tmdbClient = FakeTmdbClient.WithTvShowSearchResults(); + tmdbClient.TvShowDetails["42"] = new TmdbTvShowDetails("42", "The Wire", 2002, "Synopsis", [], [], null); + _tvShowReferenceRepository + .Setup(r => r.UpsertAsync(It.IsAny())) + .ReturnsAsync((TvShowReferenceModel m) => { m.Id ??= "reference-1"; return m; }); + var service = CreateService(tmdbClient); + + // the tenant searched with a different-language title than TMDB's canonical English one + await service.ResolveTvShowAsync("Le Fil", 2002, "42"); + + _tvShowReferenceRepository.Verify(r => r.UpsertAsync(It.Is( + m => m.MatchedTitles.Contains("the wire") && m.MatchedTitles.Contains("le fil"))), Times.Once); + } + + [Fact] + public async Task ResolveTvShowAsync_PreservesPreviouslyKnownMatchedTitles_WhenReResolvingAnExistingReference() + { + var tmdbClient = FakeTmdbClient.WithTvShowSearchResults(); + tmdbClient.TvShowDetails["42"] = new TmdbTvShowDetails("42", "The Wire", 2002, "Synopsis", [], [], null); + _tvShowReferenceRepository + .Setup(r => r.FindByTitleYearAsync("Le Fil", 2002)) + .ReturnsAsync(new TvShowReferenceModel + { + Id = "reference-1", Title = "The Wire", TitleNormalized = "the wire", ExternalIds = [], MatchedTitles = ["the wire", "il filo"] + }); + _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); + var service = CreateService(tmdbClient); + + await service.ResolveTvShowAsync("Le Fil", 2002, "42"); + + // an alias contributed by a third tenant earlier (il filo) must survive a later re-resolution + _tvShowReferenceRepository.Verify(r => r.UpsertAsync(It.Is( + m => m.MatchedTitles.Contains("the wire") && m.MatchedTitles.Contains("il filo") && m.MatchedTitles.Contains("le fil"))), Times.Once); + } + [Fact] public async Task ResolveTvShowAsync_ReusesExistingPersonReference_ForAnAlreadyKnownActor() { @@ -103,6 +165,134 @@ public async Task ResolveTvShowAsync_ReusesExistingPersonReference_ForAnAlreadyK result.Cast.Should().ContainSingle(c => c.PersonReferenceId == "person-1" && c.CharacterName == "A Character"); } + [Fact] + public async Task TryLinkExistingTvShowReferenceAsync_RelinksToTheNewMatch_WhenTitleWasEditedAwayFromTheCurrentLink() + { + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new TvShowModel { Id = "show-1", OwnerId = "owner", Title = "A Different Show", Year = 2021, ReferenceId = "old-reference" }; + _tvShowReferenceRepository + .Setup(r => r.FindByTitleYearAsync("A Different Show", 2021)) + .ReturnsAsync(new TvShowReferenceModel { Id = "new-reference", Title = "A Different Show", TitleNormalized = "a different show", ExternalIds = [] }); + + var result = await service.TryLinkExistingTvShowReferenceAsync(model); + + result.ReferenceId.Should().Be("new-reference"); + _tvShowRepository.Verify(r => r.UpdateAsync("show-1", It.Is(m => m.ReferenceId == "new-reference"), "owner"), Times.Once); + } + + [Fact] + public async Task TryLinkExistingTvShowReferenceAsync_Unlinks_WhenAlreadyLinkedButNoMatchFoundForTheCurrentTitle() + { + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new TvShowModel { Id = "show-1", OwnerId = "owner", Title = "Some Show", Year = 2020, ReferenceId = "old-reference" }; + _tvShowReferenceRepository.Setup(r => r.FindByTitleYearAsync("Some Show", 2020)).ReturnsAsync((TvShowReferenceModel?)null); + _tvShowReferenceRepository.Setup(r => r.FindByTitleAsync("Some Show")).ReturnsAsync((TvShowReferenceModel?)null); + + var result = await service.TryLinkExistingTvShowReferenceAsync(model); + + // no match for the current title means the previously stored link no longer corresponds to what + // the tenant just told us is correct - clear it (which also puts it back in the admin's unresolved queue) + result.ReferenceId.Should().BeEmpty(); + _tvShowRepository.Verify(r => r.UpdateAsync("show-1", It.Is(m => m.ReferenceId == string.Empty), "owner"), Times.Once); + } + + [Fact] + public async Task TryLinkExistingTvShowReferenceAsync_FallsBackToTitleOnlyMatch_WhenTheTenantHasNoYearSet() + { + // regression test: the title-only fallback used to be skipped whenever Year was null, which meant + // any linked show with no recorded year would unlink itself on every refresh, since the title+year + // query can never succeed with a null year against a reference that has a real one. + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new TvShowModel { Id = "show-1", OwnerId = "owner", Title = "Some Show", Year = null, ReferenceId = "reference-1" }; + _tvShowReferenceRepository.Setup(r => r.FindByTitleYearAsync("Some Show", null)).ReturnsAsync((TvShowReferenceModel?)null); + _tvShowReferenceRepository + .Setup(r => r.FindByTitleAsync("Some Show")) + .ReturnsAsync(new TvShowReferenceModel { Id = "reference-1", Title = "Some Show", TitleNormalized = "some show", Year = 2020, ExternalIds = [] }); + + var result = await service.TryLinkExistingTvShowReferenceAsync(model); + + result.ReferenceId.Should().Be("reference-1"); + } + + [Fact] + public async Task TryLinkExistingTvShowReferenceAsync_LinksAndUpdatesTitle_OnTitleYearMatch() + { + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new TvShowModel { Id = "show-1", OwnerId = "owner", Title = "Some Typo'd Show", Year = 2020 }; + _tvShowReferenceRepository + .Setup(r => r.FindByTitleYearAsync("Some Typo'd Show", 2020)) + .ReturnsAsync(new TvShowReferenceModel { Id = "reference-1", Title = "Some Show", TitleNormalized = "some show", ExternalIds = [] }); + + var result = await service.TryLinkExistingTvShowReferenceAsync(model); + + result.ReferenceId.Should().Be("reference-1"); + result.Title.Should().Be("Some Show"); + _tvShowRepository.Verify(r => r.UpdateAsync("show-1", It.Is(m => m.ReferenceId == "reference-1"), "owner"), Times.Once); + _tvShowRepository.Verify(r => r.SetReferenceLinkAsync("Some Typo'd Show", 2020, "reference-1", "Some Show"), Times.Once); + } + + [Fact] + public async Task TryLinkExistingTvShowReferenceAsync_FallsBackToTitleOnlyMatch_WhenTitleYearMatchMisses() + { + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new TvShowModel { Id = "show-1", OwnerId = "owner", Title = "Some Show", Year = 1999 }; + _tvShowReferenceRepository.Setup(r => r.FindByTitleYearAsync("Some Show", 1999)).ReturnsAsync((TvShowReferenceModel?)null); + _tvShowReferenceRepository + .Setup(r => r.FindByTitleAsync("Some Show")) + .ReturnsAsync(new TvShowReferenceModel { Id = "reference-1", Title = "Some Show", TitleNormalized = "some show", ExternalIds = [] }); + + var result = await service.TryLinkExistingTvShowReferenceAsync(model); + + result.ReferenceId.Should().Be("reference-1"); + } + + [Fact] + public async Task TryLinkExistingTvShowReferenceAsync_ReturnsUnchanged_WhenNoMatchFound() + { + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new TvShowModel { Id = "show-1", OwnerId = "owner", Title = "Some Show", Year = 2020 }; + _tvShowReferenceRepository.Setup(r => r.FindByTitleYearAsync("Some Show", 2020)).ReturnsAsync((TvShowReferenceModel?)null); + _tvShowReferenceRepository.Setup(r => r.FindByTitleAsync("Some Show")).ReturnsAsync((TvShowReferenceModel?)null); + + var result = await service.TryLinkExistingTvShowReferenceAsync(model); + + // was never linked and still isn't - nothing to clear, so no write should happen at all + result.ReferenceId.Should().BeNullOrEmpty(); + _tvShowRepository.Verify(r => r.SetReferenceLinkAsync(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + _tvShowRepository.Verify(r => r.UpdateAsync(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Fact] + public async Task TryLinkExistingMovieReferenceAsync_LinksAndUpdatesTitle_OnTitleYearMatch() + { + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new MovieModel { Id = "movie-1", OwnerId = "owner", Title = "Some Typo'd Movie", Year = 2020 }; + _movieReferenceRepository + .Setup(r => r.FindByTitleYearAsync("Some Typo'd Movie", 2020)) + .ReturnsAsync(new MovieReferenceModel { Id = "reference-1", Title = "Some Movie", TitleNormalized = "some movie", ExternalIds = [] }); + + var result = await service.TryLinkExistingMovieReferenceAsync(model); + + result.ReferenceId.Should().Be("reference-1"); + result.Title.Should().Be("Some Movie"); + _movieRepository.Verify(r => r.UpdateAsync("movie-1", It.Is(m => m.ReferenceId == "reference-1"), "owner"), Times.Once); + _movieRepository.Verify(r => r.SetReferenceLinkAsync("Some Typo'd Movie", 2020, "reference-1", "Some Movie"), Times.Once); + } + + [Fact] + public async Task TryLinkExistingMovieReferenceAsync_Unlinks_WhenAlreadyLinkedButNoMatchFoundForTheCurrentTitle() + { + var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); + var model = new MovieModel { Id = "movie-1", OwnerId = "owner", Title = "Some Movie", Year = 2020, ReferenceId = "old-reference" }; + _movieReferenceRepository.Setup(r => r.FindByTitleYearAsync("Some Movie", 2020)).ReturnsAsync((MovieReferenceModel?)null); + _movieReferenceRepository.Setup(r => r.FindByTitleAsync("Some Movie")).ReturnsAsync((MovieReferenceModel?)null); + + var result = await service.TryLinkExistingMovieReferenceAsync(model); + + result.ReferenceId.Should().BeEmpty(); + _movieRepository.Verify(r => r.UpdateAsync("movie-1", It.Is(m => m.ReferenceId == string.Empty), "owner"), Times.Once); + } + private sealed class FakeTmdbClient : ITmdbClient { private readonly List _tvShowSearchResults; diff --git a/test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs b/test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs index 71d7bde..98eb610 100644 --- a/test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs +++ b/test/WebApi.UnitTests/WatchNext/WatchNextServiceTest.cs @@ -12,40 +12,55 @@ public class WatchNextServiceTest { private readonly WatchNextService _service = new(); - private static TvShowModel Show(string id, string title, TvShowStatus? status = null) => - new() { Id = id, OwnerId = "owner", Title = title, Status = status }; + private static TvShowModel Show(string id, string title, TvShowStatus? status = TvShowStatus.Current, string? referenceId = null) => + new() { Id = id, OwnerId = "owner", Title = title, Status = status, ReferenceId = referenceId }; private static EpisodeModel Episode(string showId, int season, int episode, DateOnly? watchedAt = null) => new() { OwnerId = "owner", TvShowId = showId, SeasonNumber = season, EpisodeNumber = episode, WatchedAt = watchedAt }; + private static ReferenceEpisodeModel RefEpisode(int season, int episode, string title, DateOnly? airDate = null) => + new() { SeasonNumber = season, EpisodeNumber = episode, Title = title, AirDate = airDate }; + + private static TvShowReferenceModel Reference(params ReferenceEpisodeModel[] episodes) => new() + { + Title = "Reference Title", + TitleNormalized = "reference title", + ExternalIds = new Dictionary(), + Episodes = [.. episodes] + }; + [Fact] - public void ComputeInProgressShows_ReportsTheHighestSeasonAndEpisodeWatched() + public void ComputeInProgressShows_IncludesShowWithAConfirmedAiredUnwatchedNextEpisode() { - var shows = new[] { Show("show-1", "Dark") }; - var episodes = new[] + var shows = new[] { Show("show-1", "Dark", referenceId: "ref-1") }; + var episodes = new[] { Episode("show-1", 1, 1, new DateOnly(2024, 1, 1)) }; + var references = new Dictionary { - Episode("show-1", 1, 1, new DateOnly(2024, 1, 1)), - Episode("show-1", 1, 2, new DateOnly(2024, 1, 2)) + ["show-1"] = Reference(RefEpisode(1, 1, "Ep1"), RefEpisode(1, 2, "Ep2", new DateOnly(2024, 1, 8))) }; - var result = _service.ComputeInProgressShows(shows, episodes); + var result = _service.ComputeInProgressShows(shows, episodes, references); - // deliberately does NOT propose a "next" episode: Keeptrack has no episode-guide data, so it - // can't tell whether a further episode actually exists yet. result.Should().ContainSingle(); result[0].TvShowTitle.Should().Be("Dark"); result[0].LastSeasonNumber.Should().Be(1); - result[0].LastEpisodeNumber.Should().Be(2); - result[0].LastWatchedAt.Should().Be(new DateOnly(2024, 1, 2)); + result[0].LastEpisodeNumber.Should().Be(1); + result[0].NextSeasonNumber.Should().Be(1); + result[0].NextEpisodeNumber.Should().Be(2); + result[0].NextEpisodeTitle.Should().Be("Ep2"); } [Fact] public void ComputeInProgressShows_ExcludesFinishedShows() { - var shows = new[] { Show("show-1", "Dark", status: TvShowStatus.Finished) }; + var shows = new[] { Show("show-1", "Dark", status: TvShowStatus.Finished, referenceId: "ref-1") }; var episodes = new[] { Episode("show-1", 1, 1) }; + var references = new Dictionary + { + ["show-1"] = Reference(RefEpisode(1, 2, "Ep2")) + }; - var result = _service.ComputeInProgressShows(shows, episodes); + var result = _service.ComputeInProgressShows(shows, episodes, references); result.Should().BeEmpty(); } @@ -53,31 +68,82 @@ public void ComputeInProgressShows_ExcludesFinishedShows() [Fact] public void ComputeInProgressShows_ExcludesStoppedShows() { - var shows = new[] { Show("show-1", "Dark", status: TvShowStatus.Stopped) }; + var shows = new[] { Show("show-1", "Dark", status: TvShowStatus.Stopped, referenceId: "ref-1") }; var episodes = new[] { Episode("show-1", 1, 1) }; + var references = new Dictionary + { + ["show-1"] = Reference(RefEpisode(1, 2, "Ep2")) + }; - var result = _service.ComputeInProgressShows(shows, episodes); + var result = _service.ComputeInProgressShows(shows, episodes, references); result.Should().BeEmpty(); } [Fact] - public void ComputeInProgressShows_IncludesShowsWithNoStatusSet() + public void ComputeInProgressShows_ExcludesShowsWithNoStatusSet() { - var shows = new[] { Show("show-1", "Dark") }; - var episodes = new[] { Episode("show-1", 1, 1, new DateOnly(2024, 1, 1)) }; + var shows = new[] { Show("show-1", "Dark", status: null, referenceId: "ref-1") }; + var episodes = new[] { Episode("show-1", 1, 1) }; + var references = new Dictionary + { + ["show-1"] = Reference(RefEpisode(1, 2, "Ep2")) + }; - var result = _service.ComputeInProgressShows(shows, episodes); + var result = _service.ComputeInProgressShows(shows, episodes, references); - result.Should().ContainSingle(); + result.Should().BeEmpty(); } [Fact] public void ComputeInProgressShows_ExcludesShowsWithNoWatchedEpisodes() { - var shows = new[] { Show("show-1", "Dark") }; + var shows = new[] { Show("show-1", "Dark", referenceId: "ref-1") }; + var references = new Dictionary { ["show-1"] = Reference(RefEpisode(1, 1, "Ep1")) }; - var result = _service.ComputeInProgressShows(shows, []); + var result = _service.ComputeInProgressShows(shows, [], references); + + result.Should().BeEmpty(); + } + + [Fact] + public void ComputeInProgressShows_ExcludesShowsWithNoReferenceLinked() + { + var shows = new[] { Show("show-1", "Dark", referenceId: null) }; + var episodes = new[] { Episode("show-1", 1, 1) }; + + var result = _service.ComputeInProgressShows(shows, episodes, new Dictionary()); + + result.Should().BeEmpty(); + } + + [Fact] + public void ComputeInProgressShows_ExcludesShowsFullyCaughtUpWithTheReferenceGuide() + { + var shows = new[] { Show("show-1", "Dark", referenceId: "ref-1") }; + var episodes = new[] { Episode("show-1", 1, 2, new DateOnly(2024, 1, 8)) }; + var references = new Dictionary + { + // no episode after S1E2 in the guide at all + ["show-1"] = Reference(RefEpisode(1, 1, "Ep1"), RefEpisode(1, 2, "Ep2")) + }; + + var result = _service.ComputeInProgressShows(shows, episodes, references); + + result.Should().BeEmpty(); + } + + [Fact] + public void ComputeInProgressShows_ExcludesShowsWhoseOnlyUnwatchedEpisodeHasNotAiredYet() + { + var shows = new[] { Show("show-1", "Dark", referenceId: "ref-1") }; + var episodes = new[] { Episode("show-1", 1, 1, new DateOnly(2024, 1, 1)) }; + var references = new Dictionary + { + ["show-1"] = Reference(RefEpisode(1, 1, "Ep1"), RefEpisode(1, 2, "Ep2", DateOnly.FromDateTime(DateTime.Today.AddDays(30)))) + }; + + var result = _service.ComputeInProgressShows(shows, episodes, references); result.Should().BeEmpty(); } @@ -85,14 +151,19 @@ public void ComputeInProgressShows_ExcludesShowsWithNoWatchedEpisodes() [Fact] public void ComputeInProgressShows_OrdersByLastWatchedDescending() { - var shows = new[] { Show("show-1", "Older"), Show("show-2", "Newer") }; + var shows = new[] { Show("show-1", "Older", referenceId: "ref-1"), Show("show-2", "Newer", referenceId: "ref-2") }; var episodes = new[] { Episode("show-1", 1, 1, new DateOnly(2024, 1, 1)), Episode("show-2", 1, 1, new DateOnly(2024, 6, 1)) }; + var references = new Dictionary + { + ["show-1"] = Reference(RefEpisode(1, 1, "Ep1"), RefEpisode(1, 2, "Ep2")), + ["show-2"] = Reference(RefEpisode(1, 1, "Ep1"), RefEpisode(1, 2, "Ep2")) + }; - var result = _service.ComputeInProgressShows(shows, episodes); + var result = _service.ComputeInProgressShows(shows, episodes, references); result.Should().HaveCount(2); result[0].TvShowTitle.Should().Be("Newer"); From 2f6499ceb6db4c8e6cdf43da622dbf1caa3fa744 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 7 Jul 2026 11:02:10 +0200 Subject: [PATCH 14/44] Regular sync from TMDB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1. TMDB sync — ReferenceSyncBackgroundService runs in-process (no Kubernetes CronJob needed) every 24h, re-checking reference docs older than 3 days. It calls TMDB's cheap per-id /changes endpoint first and only does the expensive full re-fetch if something actually changed. Admins also get a "Sync now" button on the Reference Data admin page for an immediate forced check of everything. 2. Future/unaired episodes — excluded from the TV show detail page's episode checklist (same air-date filter Watch Next already used), so an announced-but-unaired season no longer shows checkboxes for episodes that haven't happened yet. 3. Unique TMDB id constraint — added to tvshow_reference/movie_reference/person_reference in mongodb-create-index.js (partial + unique, safe for older documents missing the field). 4. Watch Next movies — now excludes movies already marked watched, even if still flagged "want to watch" (that flag doesn't auto-clear on watch the way the TV Time import path does). 5. All emojis replaced — every color emoji sitewide (nav icons, home page pills, dropzone, dismiss button, etc.) swapped for plain symbols confirmed to have non-emoji default presentation (this caught a real bug: the old ⭐/👁 icons were never actually plain-text despite looking like it). 6. Renamed — "Best of" → Favorites, "Want to watch" → Watchlist, everywhere (buttons, list columns, forms, modals), no icons. 7. Watched flag — now green instead of yellow. 8. Favorites/Watchlist buttons — replaced the harsh solid blue/white btn-primary selected state with a soft accent-tinted pill, consistent in both themes. One thing I caught along the way: registering the new background sync service made every integration test spin up its own host that fired live TMDB calls against shared test data. I gated it behind a Features:IsReferenceSyncEnabled flag (on by default, off in the test host) so tests stay deterministic — documented in CLAUDE.md along with the rest. --- CLAUDE.md | 18 ++- CONTRIBUTING.md | 2 +- scripts/mongodb-create-index.js | 15 +- .../Components/Account/Pages/Manage.razor | 2 +- .../Components/Import/ImportPage.razor | 4 +- .../Inventory/Pages/MovieDetail.razor | 4 +- .../Components/Inventory/Pages/Movies.razor | 12 +- .../Inventory/Pages/TvShowDetail.razor | 10 +- .../Components/Inventory/Pages/TvShows.razor | 12 +- .../Components/Layout/MainLayout.razor | 2 +- src/BlazorApp/Components/Layout/NavMenu.razor | 28 ++-- src/BlazorApp/Components/Pages/Home.razor | 8 +- .../ReferenceDataAdminApiClient.cs | 11 ++ .../ReferenceDataAdminPage.razor | 50 +++++- .../Components/WatchNext/WatchNextPage.razor | 2 +- src/BlazorApp/wwwroot/app.css | 20 ++- .../Dto/ReferenceSyncResultDto.cs | 27 ++++ src/WebApi/AppConfiguration.cs | 7 + src/WebApi/Program.cs | 2 + src/WebApi/ReferenceData/ITmdbClient.cs | 12 ++ .../ReferenceDataAdminController.cs | 13 ++ .../ReferenceEnrichmentService.cs | 75 +++++++++ .../ReferenceSyncBackgroundService.cs | 50 ++++++ .../ReferenceData/ReferenceSyncService.cs | 66 ++++++++ src/WebApi/ReferenceData/TmdbClient.cs | 25 +++ src/WebApi/WatchNext/WatchNextController.cs | 2 +- src/WebApi/WatchNext/WatchNextService.cs | 9 ++ src/WebApi/appsettings.json | 3 +- .../Hosting/KestrelWebAppFactory.cs | 18 +++ .../Resources/AuxiliaryResourceTest.cs | 6 +- .../ReferenceEnrichmentServiceTest.cs | 111 +++++++++++++- .../ReferenceData/ReferenceSyncServiceTest.cs | 142 ++++++++++++++++++ .../WatchNext/WatchNextServiceTest.cs | 25 +++ 33 files changed, 735 insertions(+), 58 deletions(-) create mode 100644 src/WebApi.Contracts/Dto/ReferenceSyncResultDto.cs create mode 100644 src/WebApi/ReferenceData/ReferenceSyncBackgroundService.cs create mode 100644 src/WebApi/ReferenceData/ReferenceSyncService.cs create mode 100644 test/WebApi.UnitTests/ReferenceData/ReferenceSyncServiceTest.cs diff --git a/CLAUDE.md b/CLAUDE.md index 38aa457..d0640fd 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -106,6 +106,8 @@ These repositories (`ITvShowReferenceRepository`/`IMovieReferenceRepository`) do `ResolveTvShowAsync`/`ResolveMovieAsync`'s "does a reference document already exist for this" check now looks up by TMDB id first (`ITvShowReferenceRepository`/`IMovieReferenceRepository.FindByExternalIdAsync`, same shape as `IPersonReferenceRepository`'s cast-dedup lookup), falling back to title+year/title-only only when no document has that id yet. Title-text matching alone isn't reliable enough to prevent duplicates: two tenants (or an admin resolving the same unresolved queue twice under different title text - a translation, or a typo the admin fixed) can easily resolve the *same* TMDB entry through completely different search strings, and if the existence check only compares title text, the second resolution creates a second reference document for what's genuinely the same movie/show instead of updating the first. The TMDB id is the one signal that's invariant under any title text difference, so it's checked first and is authoritative. +`scripts/mongodb-create-index.js`'s `tvshow_reference_tmdb_id`/`movie_reference_tmdb_id`/`person_reference_tmdb_id` indexes are `unique: true` with a `partialFilterExpression: { "external_ids.tmdb": { $exists: true } }` - the application-level id-first dedup check above is what's *supposed* to prevent two documents sharing a TMDB id, but a database constraint is what actually guarantees it can never happen even if a future code path forgets to check. The partial filter (rather than a plain unique index, or the older `sparse: true` option) is required because it's only `external_ids.tmdb` that must be unique *when present* - a document from before this field existed (or any owner-less collection document that's never linked to that provider) has no such key at all, and a plain unique index would treat every one of those "missing the field" documents as colliding on the same null key. + Reference data is meant to be portable across environments, not re-earned from TMDB one search at a time per deployment: `ReferenceDataAdminController`'s `GET/POST /api/reference-data/export`/`import` round-trip the entire `tvshow_reference`/`movie_reference`/`person_reference` collections as a zip of JSON arrays. Idempotency here is free, not new logic - every repository's existing `UpsertAsync` already replaces-by-id when the model carries one, so re-importing the same export twice is a no-op the second time by construction. `FindAllAsync()` on each of the three reference repositories exists solely to back this export; it's an unpaged full-collection read, acceptable because this data is small and shared (not per-tenant). `TvTimeImportService`'s per-show/per-movie reference match (`TryEnrichShowAsync`/`TryEnrichMovieAsync`) fires on its own DI scope via `IServiceScopeFactory` (same shape as `TvShowController`/`MovieController.OnCreatedAsync`) rather than being awaited inline - a bulk import creating dozens of new shows/movies must not block on a sequential chain of TMDB HTTP calls (search + details + credits, per item) before the import job itself can report "Completed". If TV Time import feels slow again, check this path before assuming it's a missing Mongo index (already fully audited once - see `docs/code-quality-findings.md`). @@ -140,6 +142,20 @@ The import runs as a background job rather than a single request/response, so th Watch Next originally reported only the *last watched* episode per in-progress show, deliberately never guessing a "next" one, because Keeptrack had no episode-guide data to confirm a further episode actually existed. That constraint is gone now that `TvShowReferenceModel.Episodes` carries a real TMDB episode list: `WatchNextService.ComputeInProgressShows` now takes a third parameter, `referencesByShowId`, and only reports a show if (a) its `Status` is `TvShowStatus.Current` (not merely "not Finished/Stopped" as before) and (b) its linked reference's episode list has an entry after the last one watched (compared by `(SeasonNumber, EpisodeNumber)`, not by title or air-date order) whose `AirDate` has already passed (or is unset). A show with no `ReferenceId`, or no matching reference document, is excluded rather than guessed at - the same "don't guess when you don't have the info" principle as before, just enforced by data instead of by omission. `WatchNextController` only fetches the (small, bounded) reference document for shows that are `Current` and linked, since those are the only ones that can possibly appear in the result. The DTO now also reports the confirmed next episode's season/episode/title (`InProgressShowDto.Next*`) - this was withheld before purely for lack of data, not by design preference, so surfacing it once the data is trustworthy is not a reintroduction of the old "+1" heuristic that shipped a confirmed-wrong result; that heuristic guessed without confirming an episode existed; this checks a real episode-guide. +`WatchNextService.FilterMoviesToWatch` excludes a movie from the "movies to watch" list once it's marked seen (`FirstSeenAt` set), even though it's still flagged `WantToWatch` - toggling that flag on a movie's own detail page doesn't clear it on watch (unlike the TV Time import's "towatch" event handling, which never flags an already-watched movie in the first place), so the exclusion has to happen at read time here instead of relying on the flag never going stale. + +`TvShowDetail.razor`'s episode checklist filters `_reference.Episodes` to `AirDate is null || AirDate <= today` before grouping into seasons, the same air-date filter `WatchNextService` already applies for its "next episode" calc. An episode TMDB lists with a future air date (a confirmed-but-unaired next season, e.g. a renewal announced months ahead) hasn't happened yet from the viewer's perspective - it shouldn't appear as a checkbox to mark watched, and an entirely future season simply doesn't appear in the season picker at all once every one of its episodes is filtered out. + +### Keeping reference data fresh: periodic + on-demand TMDB sync + +TMDB's own data (episode air dates as seasons progress, genres, posters, cast) drifts out of date after the initial resolution - a show resolved months ago needs re-checking, not just a one-time fetch. `ReferenceSyncBackgroundService` (`WebApi/ReferenceData/`) is a plain in-process `BackgroundService` running a `PeriodicTimer` (24h interval, does an initial pass immediately on startup too) - deliberately **not** a Kubernetes CronJob or separate worker process: a second scheduled workload is real operational overhead (another manifest, another thing that can silently stop running) for a job that's cheap enough to run inside the existing API process. `ReferenceSyncService.SyncStaleReferencesAsync(staleAfter, ...)` (shared by both the periodic loop and the admin's on-demand trigger, so there's exactly one sync algorithm) skips any reference document whose `LastEnrichedAt` is more recent than `staleAfter` (3 days for the periodic pass; `TimeSpan.Zero` for the admin's forced "sync now", which therefore re-checks everything regardless of recency) and never lets one failing document (a TMDB id that's since been removed, a transient network error) abort the rest of the run - each is caught and logged individually. + +`ReferenceEnrichmentService.RefreshTvShowReferenceAsync`/`RefreshMovieReferenceAsync` do the actual per-document work, and lead with a cheap pre-check before the expensive full re-fetch: `ITmdbClient.HasTvShowChangedSinceAsync`/`HasMovieChangedSinceAsync` call TMDB's per-id `/{tv,movie}/{id}/changes?start_date=...` endpoint (one call, no season fan-out) to ask "has anything changed since this was last enriched" - this is the "if TMDB provides the last updated date... check with `last_enriched_at`" idea, implemented via TMDB's changes endpoint since TMDB doesn't expose a plain last-modified field on the show/movie details response itself. If nothing changed, only `LastEnrichedAt` is bumped (so the next periodic pass doesn't re-check an already-current document) and the costly `GetTvShowDetailsAsync` + per-season `GetTvShowCastAsync` calls are skipped entirely; a reference with no `LastEnrichedAt` yet always does the full fetch (nothing to compare against, and the changes-check would be meaningless anyway). + +An admin can force an immediate full re-check via `POST /api/reference-data/sync-now` (`ReferenceDataAdminController`, admin-only) instead of waiting for the next scheduled pass - the same "Reference data" admin page that already has export/import gets a "Sync now" button reporting checked/updated counts for both collections. + +**Gotcha:** the periodic background service is registered unconditionally in `Program.cs`, but only actually does work when `Features:IsReferenceSyncEnabled` (`AppConfiguration.IsReferenceSyncEnabled`, default `true`) is true - checked fresh on every tick, not once at startup. The integration test host (`KestrelWebAppFactory`) overrides this to `false` via `ConfigureAppConfiguration` (an in-memory source added last, so it wins over `appsettings.json`); `UseSetting` was tried first and silently didn't work for a top-level-statement minimal-hosting `Program.cs` like this one - it's loaded too early relative to the rest of configuration and gets overridden back by `appsettings.json`. Without this, every integration test run spun up its own in-process Kestrel host (one per `IClassFixture>` test class) and each one immediately fired real TMDB HTTP calls against whatever reference data the shared test MongoDB happened to hold - noisy and non-deterministic, not a real regression to chase. Any integration test using a bare `WebApplicationFactory` instead of `KestrelWebAppFactory` bypasses this override (this already bit `AuxiliaryResourceTest` once) - use `KestrelWebAppFactory` for any new integration test fixture, even one that doesn't need real Kestrel networking, specifically so it inherits this override for free instead of re-solving it. + ### Blazor app `InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, which wraps the typed `HttpClient` calls to the Web API (its `GetAsync` takes an optional extra-query-parameters dictionary, used by features that filter on more than search/page/pageSize). Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. A page that needs its own filter beyond search (e.g. `TvShows.razor.cs`'s status filter) overrides the base's `protected virtual ExtraQuery` property instead of reimplementing paging/search - `LoadAsync` is `protected` for exactly this reason, so the page can trigger a reload after changing its own filter state. Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. @@ -152,7 +168,7 @@ Pages that aren't a generic CRUD list (`TvShowDetail.razor`, `WatchNext/WatchNex `app.css` is a light+dark theme driven by `data-bs-theme` on `` (Bootstrap 5.3's native color-mode support), with Keeptrack's own `--kt-*` tokens layered on top for custom components (sidebar, `kt-table-wrap`, `kt-modal`, etc.). `wwwroot/theme.js` sets the initial theme from `localStorage`/`prefers-color-scheme` before first paint (avoiding a flash of the wrong theme) and exposes `ktToggleTheme()`, called directly from a plain button in `NavMenu.razor` — no Blazor/JS interop needed for the toggle itself. Use system-ui fonts only; no decorative/display webfonts. -Icons throughout the app are plain, single-color Unicode symbols (`⭐`, `👁`, `◈`, `✓`, `↻`), not full-color emoji (`🔄`, `⏳`) - a color emoji reads as an inconsistent, slightly unpolished note among otherwise monochrome UI that follows `--kt-text`/`--kt-accent` like everything else. `.kt-icon-spin` (reuses the same `spin` keyframes as `.kt-spinner`) makes a plain glyph rotate in place for a small inline action's "in progress" state, instead of swapping to an hourglass emoji. +Icons throughout the app are plain Unicode symbols with no default emoji presentation (`◈`, `✓`, `✕`, `★`, `▶`, `↻`, `⌂`, `⚙`, `♪`, and the Geometric Shapes block generally: `◼ ▭ ▬ ◆`), never a codepoint whose default rendering is a full-color emoji glyph (`⭐`, `👁`, `🔄`, `⏳`, `🏠`, `📚`, `🎬`, ...) - a color emoji reads as an inconsistent, slightly unpolished note among otherwise monochrome UI that follows `--kt-text`/`--kt-accent` like everything else. **Gotcha:** a codepoint isn't safe just because it "looks like" a plain symbol - `⭐` (U+2B50) and `👁` (U+1F441) were originally used as the "Best of"/"Want to watch" icons on the assumption they were plain stars/eyes, but both have `Emoji_Presentation=Yes` by default (Unicode's `emoji-data.txt`) and render as full-color glyphs on every mainstream platform; they were replaced with `★` (U+2605, Black Star, default text presentation) and `▶` (U+25B6, default text presentation) respectively. Before adding a new symbol, check whether its default presentation is text or emoji - don't assume from how it looks in this file. Appending a trailing variation selector (`️`, U+FE0F) forces emoji presentation even on an otherwise-safe codepoint, so never add one; some codepoints (`🌙`, `🚪`, `🔑`, `👤`, `📦`) have no text-presentation form at all and were simply dropped rather than replaced with an approximate glyph, since a semantically-forced match is worse than no icon when the row's label text already carries the meaning. `.kt-icon-spin` (reuses the same `spin` keyframes as `.kt-spinner`) makes a plain glyph rotate in place for a small inline action's "in progress" state, instead of swapping to an hourglass emoji. Enhanced navigation re-fetches and diffs the whole document on every in-app link click; anything set on ``/`` by client-side JS rather than server-rendered markup (like `data-bs-theme`) gets stripped back out unless it's explicitly re-applied. `wwwroot/Keeptrack.BlazorApp.lib.module.js` is a JS initializer (auto-loaded by Blazor because its name matches the assembly - don't add a manual ` diff --git a/src/BlazorApp/Components/App.razor b/src/BlazorApp/Components/App.razor index 2a7ae45..add500a 100644 --- a/src/BlazorApp/Components/App.razor +++ b/src/BlazorApp/Components/App.razor @@ -19,6 +19,7 @@ + diff --git a/test/BlazorApp.UnitTests/Account/ReturnUrlResolverTest.cs b/test/BlazorApp.UnitTests/Account/ReturnUrlResolverTest.cs new file mode 100644 index 0000000..45e44da --- /dev/null +++ b/test/BlazorApp.UnitTests/Account/ReturnUrlResolverTest.cs @@ -0,0 +1,76 @@ +using System; +using AwesomeAssertions; +using Keeptrack.BlazorApp.Components.Account; +using Xunit; + +namespace Keeptrack.BlazorApp.UnitTests.Account; + +[Trait("Category", "UnitTests")] +public class ReturnUrlResolverTest +{ + private const string AppHost = "app.example:5207"; + + // Stand-ins for the production predicate (IUrlHelper.IsLocalUrl). Tests state the predicate's answer + // explicitly so each one targets the resolver's own branch logic, not IsLocalUrl's implementation. + private static readonly Func s_treatAsLocal = _ => true; + private static readonly Func s_treatAsNotLocal = _ => false; + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData(" ")] + public void Resolve_ReturnsRoot_ForMissingReturnUrl(string? returnUrl) + { + ReturnUrlResolver.Resolve(returnUrl, AppHost, s_treatAsLocal).Should().Be("/"); + } + + [Fact] + public void Resolve_PassesThroughAUrlThePredicateAcceptsAsLocal() + { + ReturnUrlResolver.Resolve("/movies?page=2", AppHost, s_treatAsLocal) + .Should().Be("/movies?page=2"); + } + + [Fact] + public void Resolve_ReducesSameHostAbsoluteUrl_ToPathAndQuery() + { + // The genuine callers pass this app's own absolute NavigationManager.Uri. + ReturnUrlResolver.Resolve("https://app.example:5207/movies?page=2", AppHost, s_treatAsNotLocal) + .Should().Be("/movies?page=2"); + } + + [Fact] + public void Resolve_MatchesHostCaseInsensitively() + { + ReturnUrlResolver.Resolve("https://APP.EXAMPLE:5207/tv-shows", AppHost, s_treatAsNotLocal) + .Should().Be("/tv-shows"); + } + + [Fact] + public void Resolve_ReturnsRoot_ForADifferentHostAbsoluteUrl() + { + // The core open-redirect guard: never bounce a signed-in user off-site. + ReturnUrlResolver.Resolve("https://evil.example/movies", AppHost, s_treatAsNotLocal) + .Should().Be("/"); + } + + [Fact] + public void Resolve_ReturnsRoot_WhenUserInfoSpoofsTheHost() + { + // The parsed authority is evil.example (the part before '@' is userinfo), not the app host. + ReturnUrlResolver.Resolve("https://app.example:5207@evil.example/x", AppHost, s_treatAsNotLocal) + .Should().Be("/"); + } + + [Theory] + [InlineData("//evil.example/x")] + [InlineData("/\\evil.example")] + public void Resolve_ReturnsRoot_ForUrlsThePredicateRejects(string returnUrl) + { + // These are the dangerous shapes IUrlHelper.IsLocalUrl rejects (protocol-relative, backslash + // authority). The resolver defers that judgment to the predicate and does not smuggle them through + // the absolute-URL branch - neither parses as an absolute Uri - so they fall back to the app root. + ReturnUrlResolver.Resolve(returnUrl, AppHost, s_treatAsNotLocal) + .Should().Be("/"); + } +} diff --git a/test/BlazorApp.UnitTests/BlazorApp.UnitTests.csproj b/test/BlazorApp.UnitTests/BlazorApp.UnitTests.csproj new file mode 100644 index 0000000..89151a8 --- /dev/null +++ b/test/BlazorApp.UnitTests/BlazorApp.UnitTests.csproj @@ -0,0 +1,24 @@ + + + + net10.0 + Exe + Keeptrack.BlazorApp.UnitTests + Keeptrack.BlazorApp.UnitTests + enable + false + true + + + + + + + + + + + + + + From d58bb208eaec17948fc179a52d63619ca15312ac Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Wed, 8 Jul 2026 20:26:25 +0200 Subject: [PATCH 23/44] Rework video game to support multiple platform and playthroughs --- .gitignore | 3 + .../Clients/InventoryApiClientBase.cs | 6 +- .../Components/Inventory/InventoryPageBase.cs | 2 +- .../Inventory/Pages/VideoGameDetail.razor | 237 +++++++++++++----- .../Inventory/Pages/VideoGames.razor | 78 +----- .../Inventory/Pages/VideoGames.razor.cs | 50 +++- .../Components/Wishlist/WishlistPage.razor | 4 +- src/Domain/Models/PlaythroughModel.cs | 16 ++ src/Domain/Models/VideoGameCopyType.cs | 7 + src/Domain/Models/VideoGameModel.cs | 22 +- src/Domain/Models/VideoGamePlatformModel.cs | 26 ++ .../Repositories/IVideoGameRepository.cs | 2 - .../Entities/Playthrough.cs | 10 + .../Entities/VideoGame.cs | 9 +- .../Entities/VideoGamePlatform.cs | 24 ++ .../Repositories/VideoGameRepository.cs | 4 +- src/WebApi.Contracts/Dto/PlaythroughDto.cs | 20 ++ src/WebApi.Contracts/Dto/VideoGameCopyType.cs | 10 + src/WebApi.Contracts/Dto/VideoGameDto.cs | 29 ++- .../Dto/VideoGamePlatformDto.cs | 40 +++ src/WebApi/Controllers/WishlistController.cs | 2 +- .../DataStorageMappingProfile.cs | 10 +- .../WebServiceMappingProfile.cs | 6 + .../ReferenceEnrichmentService.VideoGames.cs | 5 +- .../Resources/RefreshReferenceResourceTest.cs | 2 +- .../Resources/VideoGameResourceTest.cs | 14 +- .../ReferenceEnrichmentServiceTest.cs | 20 +- .../Services/WishlistServiceTest.cs | 4 +- 28 files changed, 467 insertions(+), 195 deletions(-) create mode 100644 src/Domain/Models/PlaythroughModel.cs create mode 100644 src/Domain/Models/VideoGameCopyType.cs create mode 100644 src/Domain/Models/VideoGamePlatformModel.cs create mode 100644 src/Infrastructure.MongoDb/Entities/Playthrough.cs create mode 100644 src/Infrastructure.MongoDb/Entities/VideoGamePlatform.cs create mode 100644 src/WebApi.Contracts/Dto/PlaythroughDto.cs create mode 100644 src/WebApi.Contracts/Dto/VideoGameCopyType.cs create mode 100644 src/WebApi.Contracts/Dto/VideoGamePlatformDto.cs diff --git a/.gitignore b/.gitignore index b10602a..11e8acd 100644 --- a/.gitignore +++ b/.gitignore @@ -17,3 +17,6 @@ Local.runsettings # NPM firebase.config.js node_modules/ + +# Logs +*.log diff --git a/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs b/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs index b753dc5..0a42a77 100644 --- a/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs +++ b/src/BlazorApp/Components/Inventory/Clients/InventoryApiClientBase.cs @@ -34,9 +34,11 @@ public async Task> GetAsync(string search, int page, int pageS return await http.GetFromJsonAsync($"{ApiResourceName}/{id}"); } - public async Task AddAsync(TDto movie) + public async Task AddAsync(TDto movie) { - (await http.PostAsJsonAsync($"{ApiResourceName}", movie)).EnsureSuccessStatusCode(); + var response = await http.PostAsJsonAsync($"{ApiResourceName}", movie); + response.EnsureSuccessStatusCode(); + return (await response.Content.ReadFromJsonAsync())!; } public async Task UpdateAsync(TDto movie) diff --git a/src/BlazorApp/Components/Inventory/InventoryPageBase.cs b/src/BlazorApp/Components/Inventory/InventoryPageBase.cs index 1a2678c..aab85d9 100644 --- a/src/BlazorApp/Components/Inventory/InventoryPageBase.cs +++ b/src/BlazorApp/Components/Inventory/InventoryPageBase.cs @@ -80,7 +80,7 @@ protected void CancelForm() _error = null; } - protected async Task SaveAsync() + protected virtual async Task SaveAsync() { try { diff --git a/src/BlazorApp/Components/Inventory/Pages/VideoGameDetail.razor b/src/BlazorApp/Components/Inventory/Pages/VideoGameDetail.razor index ee2b38e..4af24c6 100644 --- a/src/BlazorApp/Components/Inventory/Pages/VideoGameDetail.razor +++ b/src/BlazorApp/Components/Inventory/Pages/VideoGameDetail.razor @@ -38,13 +38,6 @@ else
-
- @foreach (var state in VideoGames.VideoGameStates) - { - - } -
- @if (string.IsNullOrEmpty(_game.ReferenceId)) { @@ -54,31 +47,17 @@ else } + @if (!string.IsNullOrEmpty(_reference?.ImageUrl)) + { +
+ @_game.Title cover +
+ } +
- @if (!string.IsNullOrEmpty(_reference?.ImageUrl)) - { -
- @_game.Title cover -
- }
- - -
-
@@ -87,11 +66,6 @@ else
-
- - -
@if (_reference?.Platforms.Count > 0) {

Available on: @string.Join(", ", _reference.Platforms)

@@ -101,7 +75,7 @@ else

@string.Join(", ", _reference.Genres)

}
-
+
@@ -112,6 +86,78 @@ else

@_reference.Synopsis

}
+ +

Platforms

+ + @if (_game.Platforms.Count == 0) + { +

No platforms tracked yet - add one below.

+ } + + @foreach (var entry in _game.Platforms) + { +
+
+
+

@entry.Platform

+
+ + +
+
+ +
+ +
+ @foreach (var state in VideoGames.VideoGameStates) + { + + } +
+ +
+ + @if (entry.IsFullyCompleted) + { + + } +
+ +
+ + @foreach (var playthrough in entry.Playthroughs) + { +
+ + + +
+ } + +
+
+ } + +
+ +
+ + + + +
+
} @code { @@ -130,6 +176,8 @@ else private string? _refreshMessage; private string _refreshMessageStyle = "neutral"; private object? _refreshMessageToken; + private string _newPlatform = ""; + private VideoGameCopyType _newCopyType; protected override async Task OnParametersSetAsync() => await LoadAsync(); @@ -141,32 +189,33 @@ else _loading = false; } + /// Every mutation on this page follows the same shape: mutate _game locally, then PUT + /// the whole DTO - shared here since the per-platform/per-playthrough editors below call it often. + private async Task SaveGameAsync() + { + if (_game is null) return; + await VideoGameApi.UpdateAsync(_game); + } + private async Task SetRatingAsync(float rating) { if (_game is null) return; _game.Rating = rating; - await VideoGameApi.UpdateAsync(_game); + await SaveGameAsync(); } private async Task ToggleOwnedAsync() { if (_game is null) return; _game.IsOwned = !_game.IsOwned; - await VideoGameApi.UpdateAsync(_game); + await SaveGameAsync(); } private async Task ToggleWishlistedAsync() { if (_game is null) return; _game.IsWishlisted = !_game.IsWishlisted; - await VideoGameApi.UpdateAsync(_game); - } - - private async Task SetFinishedDateAsync(ChangeEventArgs e) - { - if (_game is null) return; - _game.FinishedAt = DateOnly.TryParse(e.Value?.ToString(), out var date) ? date : null; - await VideoGameApi.UpdateAsync(_game); + await SaveGameAsync(); } private async Task SaveTitleAsync(ChangeEventArgs e) @@ -175,26 +224,90 @@ else var title = e.Value?.ToString(); if (string.IsNullOrWhiteSpace(title)) return; _game.Title = title; - await VideoGameApi.UpdateAsync(_game); + await SaveGameAsync(); } - private async Task SavePlatformAsync(ChangeEventArgs e) + private async Task SaveYearAsync(ChangeEventArgs e) { if (_game is null) return; - _game.Platform = e.Value?.ToString() ?? ""; - await VideoGameApi.UpdateAsync(_game); + _game.Year = int.TryParse(e.Value?.ToString(), out var year) ? year : null; + await SaveGameAsync(); + } + + private async Task SaveNotesAsync(ChangeEventArgs e) + { + if (_game is null) return; + _game.Notes = e.Value?.ToString(); + await SaveGameAsync(); + } + + private async Task AddPlatformAsync() + { + if (_game is null || string.IsNullOrEmpty(_newPlatform)) return; + _game.Platforms.Add(new VideoGamePlatformDto { Platform = _newPlatform, CopyType = _newCopyType }); + _newPlatform = ""; + _newCopyType = VideoGameCopyType.Physical; + await SaveGameAsync(); + } + + private async Task RemovePlatformAsync(VideoGamePlatformDto entry) + { + if (_game is null) return; + _game.Platforms.Remove(entry); + await SaveGameAsync(); + } + + private async Task SetCopyTypeAsync(VideoGamePlatformDto entry, VideoGameCopyType copyType) + { + entry.CopyType = copyType; + await SaveGameAsync(); } /// - /// Clicking the already-active state button clears it back to unset - otherwise sets it. Same - /// explicit-buttons-over-dropdown reasoning as TvShowDetail.razor's SetStatusAsync: every - /// option is visible and directly selectable, nothing to guess about what a click will do. + /// Clicking the already-active state button clears it back to unset - same toggle-off-on-reclick + /// pattern as TvShowDetail.razor's SetStatusAsync, now applied per platform entry. /// - private async Task SetStateAsync(string state) + private async Task SetPlatformStateAsync(VideoGamePlatformDto entry, string state) { - if (_game is null) return; - _game.State = _game.State == state ? "" : state; - await VideoGameApi.UpdateAsync(_game); + entry.State = entry.State == state ? "" : state; + await SaveGameAsync(); + } + + private async Task ToggleFullyCompletedAsync(VideoGamePlatformDto entry) + { + entry.IsFullyCompleted = !entry.IsFullyCompleted; + entry.FullyCompletedAt = entry.IsFullyCompleted ? entry.FullyCompletedAt ?? DateOnly.FromDateTime(DateTime.Today) : null; + await SaveGameAsync(); + } + + private async Task SetFullyCompletedDateAsync(VideoGamePlatformDto entry, ChangeEventArgs e) + { + entry.FullyCompletedAt = DateOnly.TryParse(e.Value?.ToString(), out var date) ? date : null; + await SaveGameAsync(); + } + + private async Task AddPlaythroughAsync(VideoGamePlatformDto entry) + { + entry.Playthroughs.Add(new PlaythroughDto { Label = "" }); + await SaveGameAsync(); + } + + private async Task RemovePlaythroughAsync(VideoGamePlatformDto entry, PlaythroughDto playthrough) + { + entry.Playthroughs.Remove(playthrough); + await SaveGameAsync(); + } + + private async Task UpdatePlaythroughLabelAsync(PlaythroughDto playthrough, ChangeEventArgs e) + { + playthrough.Label = e.Value?.ToString() ?? ""; + await SaveGameAsync(); + } + + private async Task UpdatePlaythroughDateAsync(PlaythroughDto playthrough, ChangeEventArgs e) + { + playthrough.CompletedAt = DateOnly.TryParse(e.Value?.ToString(), out var date) ? date : null; + await SaveGameAsync(); } private async Task RefreshReferenceAsync() @@ -244,18 +357,4 @@ else _refreshMessage = null; await InvokeAsync(StateHasChanged); } - - private async Task SaveYearAsync(ChangeEventArgs e) - { - if (_game is null) return; - _game.Year = int.TryParse(e.Value?.ToString(), out var year) ? year : null; - await VideoGameApi.UpdateAsync(_game); - } - - private async Task SaveNotesAsync(ChangeEventArgs e) - { - if (_game is null) return; - _game.Notes = e.Value?.ToString(); - await VideoGameApi.UpdateAsync(_game); - } } diff --git a/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor b/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor index bde85f8..321ddfe 100644 --- a/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor +++ b/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor @@ -39,25 +39,23 @@ Title - Platform - State + Platforms Rating - Finished @game.Title - @game.Platform - @if (!string.IsNullOrEmpty(game.State)) + @foreach (var entry in game.Platforms) { - @game.State + + @entry.Platform@(string.IsNullOrEmpty(entry.State) ? "" : $" ({entry.State})") + } - @game.FinishedAt?.ToString("yyyy-MM-dd") @if (game.IsOwned) { @@ -71,40 +69,7 @@ - -
- -
- @foreach (var state in VideoGameStates) - { - - } -
-
- - -
- -
- - -
-
- - -
-
+
@@ -114,30 +79,6 @@
-
- - -
-
- -
- @foreach (var state in VideoGameStates) - { - - } -
-
@@ -146,11 +87,7 @@
-
- - -
-
+
@@ -165,5 +102,6 @@
+

Manage platforms, state and playthroughs from the game's detail page.

diff --git a/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor.cs b/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor.cs index 037caa2..fbdd569 100644 --- a/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor.cs +++ b/src/BlazorApp/Components/Inventory/Pages/VideoGames.razor.cs @@ -5,9 +5,15 @@ namespace Keeptrack.BlazorApp.Components.Inventory.Pages; public partial class VideoGames : InventoryPageBase { - /// Shared by the list's Filters buttons and the Add/Edit forms' State button group. + /// Shared by the list's Filters buttons, the detail page's per-platform State buttons, and + /// the (now-removed from the list page) Add/Edit forms' old State button group. internal static readonly string[] VideoGameStates = ["Available", "Current", "Completed", "To resume", "On-hold"]; + /// Shared by the detail page's platform picker - previously duplicated as a literal + /// <select> in three places (list add form, list edit modal, detail page). + internal static readonly string[] VideoGamePlatforms = + ["Xbox Series X", "PS5", "PC", "Xbox One X", "PS4", "WII", "Xbox 360", "PS2", "PS1"]; + /// /// The kt-status-badge modifier class for a state value (see app.css) - same badge/color /// pattern as TvShows.razor's status column, sharing its "current" modifier for the identical @@ -17,6 +23,8 @@ public partial class VideoGames : InventoryPageBase [Inject] private VideoGameApiClient VideoGameApi { get; set; } = null!; + [Inject] private NavigationManager Nav { get; set; } = null!; + protected override InventoryApiClientBase Api => VideoGameApi; private string? _stateFilter; @@ -58,13 +66,47 @@ private async Task ToggleWishlistedFilterAsync() await LoadAsync(); } + /// + /// Creating a game only ever captures Title+Year here (see FormTemplate) - platforms, state + /// and playthroughs are added on the detail page, so a successful create navigates straight there + /// instead of closing the form and staying on the list. + /// + protected override async Task SaveAsync() + { + try + { + if (_form.Id is null) + { + var created = await VideoGameApi.AddAsync(_form); + _showForm = false; + Nav.NavigateTo($"/video-games/{created.Id}"); + } + else + { + await VideoGameApi.UpdateAsync(_form); + _showForm = false; + await LoadAsync(); + } + } + catch (Exception ex) + { + _error = ex.Message; + } + } + protected override VideoGameDto CloneItem(VideoGameDto item) => new() { Id = item.Id, Title = item.Title, - Platform = item.Platform, - State = item.State, - FinishedAt = item.FinishedAt, + Platforms = item.Platforms.Select(p => new VideoGamePlatformDto + { + Platform = p.Platform, + CopyType = p.CopyType, + State = p.State, + Playthroughs = p.Playthroughs.Select(pt => new PlaythroughDto { Label = pt.Label, CompletedAt = pt.CompletedAt }).ToList(), + IsFullyCompleted = p.IsFullyCompleted, + FullyCompletedAt = p.FullyCompletedAt + }).ToList(), Notes = item.Notes, Rating = item.Rating, Year = item.Year, diff --git a/src/BlazorApp/Components/Wishlist/WishlistPage.razor b/src/BlazorApp/Components/Wishlist/WishlistPage.razor index 6d14644..ff9783d 100644 --- a/src/BlazorApp/Components/Wishlist/WishlistPage.razor +++ b/src/BlazorApp/Components/Wishlist/WishlistPage.razor @@ -118,9 +118,9 @@ else {

@game.Title

- @if (!string.IsNullOrEmpty(game.Platform)) + @if (game.Year > 0) { -

@game.Platform

+

@game.Year

} } diff --git a/src/Domain/Models/PlaythroughModel.cs b/src/Domain/Models/PlaythroughModel.cs new file mode 100644 index 0000000..e0cb18d --- /dev/null +++ b/src/Domain/Models/PlaythroughModel.cs @@ -0,0 +1,16 @@ +using System; + +namespace Keeptrack.Domain.Models; + +/// +/// One recorded run through a game - the base playthrough, an NG+ replay, a speedrun, or any other +/// attempt the tenant wants to log. is free text rather than a fixed enum because +/// replays don't fit a closed set (NG+1, NG+2, a side-run "just for fun", ...). +/// is optional so an in-progress or abandoned run can still be logged. +/// +public class PlaythroughModel +{ + public required string Label { get; set; } + + public DateOnly? CompletedAt { get; set; } +} diff --git a/src/Domain/Models/VideoGameCopyType.cs b/src/Domain/Models/VideoGameCopyType.cs new file mode 100644 index 0000000..47510d9 --- /dev/null +++ b/src/Domain/Models/VideoGameCopyType.cs @@ -0,0 +1,7 @@ +namespace Keeptrack.Domain.Models; + +public enum VideoGameCopyType +{ + Physical, + Digital +} diff --git a/src/Domain/Models/VideoGameModel.cs b/src/Domain/Models/VideoGameModel.cs index 11e42df..4e9c45e 100644 --- a/src/Domain/Models/VideoGameModel.cs +++ b/src/Domain/Models/VideoGameModel.cs @@ -1,4 +1,4 @@ -using System; +using System.Collections.Generic; using Keeptrack.Common.System; namespace Keeptrack.Domain.Models; @@ -11,9 +11,7 @@ public class VideoGameModel : IHasIdAndOwnerId public required string Title { get; set; } - public required string Platform { get; set; } - - public required string State { get; set; } + public List Platforms { get; set; } = []; public int? Year { get; set; } @@ -21,11 +19,23 @@ public class VideoGameModel : IHasIdAndOwnerId public string? Notes { get; set; } - public DateOnly? FinishedAt { get; set; } - public string? ReferenceId { get; set; } public bool IsOwned { get; set; } public bool IsWishlisted { get; set; } + + /// + /// Filter-only: matches if any entry in has this platform. Never persisted - + /// this property exists solely so can keep doubling as the filter-probe + /// object passed to IDataRepository{TModel}.FindAllAsync, the same convention every other + /// repository already relies on. + /// + public string? Platform { get; set; } + + /// + /// Filter-only: matches if any entry in has this state. Never persisted - see + /// . + /// + public string? State { get; set; } } diff --git a/src/Domain/Models/VideoGamePlatformModel.cs b/src/Domain/Models/VideoGamePlatformModel.cs new file mode 100644 index 0000000..6d4d361 --- /dev/null +++ b/src/Domain/Models/VideoGamePlatformModel.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; + +namespace Keeptrack.Domain.Models; + +/// +/// One entry per platform a game is tracked on for a given tenant - not one entry per physical copy. +/// Owning two PS5 discs of the same game is still a single entry with "PS5". +/// / ("platinum"/100%) live here rather than +/// on or on a single entry, because full +/// completion is a per-platform fact - a PS5 platinum says nothing about Xbox/PC progress on the same game. +/// +public class VideoGamePlatformModel +{ + public required string Platform { get; set; } + + public VideoGameCopyType CopyType { get; set; } + + public string State { get; set; } = ""; + + public List Playthroughs { get; set; } = []; + + public bool IsFullyCompleted { get; set; } + + public DateOnly? FullyCompletedAt { get; set; } +} diff --git a/src/Domain/Repositories/IVideoGameRepository.cs b/src/Domain/Repositories/IVideoGameRepository.cs index f7b7dd3..7aa13c1 100644 --- a/src/Domain/Repositories/IVideoGameRepository.cs +++ b/src/Domain/Repositories/IVideoGameRepository.cs @@ -10,8 +10,6 @@ public interface IVideoGameRepository : IDataRepository /// Sets , and /// (to the reference's canonical values) on every tenant's game matching /// this title/year that doesn't already have a reference link - see . - /// / are deliberately never set here - - /// they describe this tenant's own copy/progress, not the canonical release. /// Task SetReferenceLinkAsync(string title, int? year, string referenceId, string canonicalTitle, int? canonicalYear = null); diff --git a/src/Infrastructure.MongoDb/Entities/Playthrough.cs b/src/Infrastructure.MongoDb/Entities/Playthrough.cs new file mode 100644 index 0000000..d811b79 --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/Playthrough.cs @@ -0,0 +1,10 @@ +using System; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +public class Playthrough +{ + public required string Label { get; set; } + + public DateTime? CompletedAt { get; set; } +} diff --git a/src/Infrastructure.MongoDb/Entities/VideoGame.cs b/src/Infrastructure.MongoDb/Entities/VideoGame.cs index b39ad47..77148e5 100644 --- a/src/Infrastructure.MongoDb/Entities/VideoGame.cs +++ b/src/Infrastructure.MongoDb/Entities/VideoGame.cs @@ -1,4 +1,4 @@ -using System; +using System.Collections.Generic; using Keeptrack.Common.System; using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; @@ -16,9 +16,7 @@ public class VideoGame : IHasIdAndOwnerId public required string Title { get; set; } - public required string Platform { get; set; } - - public required string State { get; set; } + public List Platforms { get; set; } = []; public int? Year { get; set; } @@ -26,9 +24,6 @@ public class VideoGame : IHasIdAndOwnerId public string? Notes { get; set; } - [BsonElement("finished_at")] - public DateTime? FinishedAt { get; set; } - [BsonElement("reference_id")] public string? ReferenceId { get; set; } diff --git a/src/Infrastructure.MongoDb/Entities/VideoGamePlatform.cs b/src/Infrastructure.MongoDb/Entities/VideoGamePlatform.cs new file mode 100644 index 0000000..b2b36ad --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/VideoGamePlatform.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using MongoDB.Bson.Serialization.Attributes; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +public class VideoGamePlatform +{ + public required string Platform { get; set; } + + [BsonElement("copy_type")] + public VideoGameCopyType CopyType { get; set; } + + public string State { get; set; } = ""; + + public List Playthroughs { get; set; } = []; + + [BsonElement("is_fully_completed")] + public bool IsFullyCompleted { get; set; } + + [BsonElement("fully_completed_at")] + public DateTime? FullyCompletedAt { get; set; } +} diff --git a/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs b/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs index 0e2706b..949f437 100644 --- a/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs @@ -22,8 +22,8 @@ protected override FilterDefinition GetFilter(string ownerId, string? var builder = Builders.Filter; var filter = builder.Eq(f => f.OwnerId, ownerId); if (!string.IsNullOrEmpty(search)) filter &= builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); - if (!string.IsNullOrEmpty(input.State)) filter &= builder.Where(f => f.State == input.State); - if (!string.IsNullOrEmpty(input.Platform)) filter &= builder.Where(f => f.Platform == input.Platform); + if (!string.IsNullOrEmpty(input.State)) filter &= builder.AnyEq(f => f.Platforms.Select(p => p.State), input.State); + if (!string.IsNullOrEmpty(input.Platform)) filter &= builder.AnyEq(f => f.Platforms.Select(p => p.Platform), input.Platform); if (input.IsOwned) filter &= builder.Eq(f => f.IsOwned, true); if (input.IsWishlisted) filter &= builder.Eq(f => f.IsWishlisted, true); return filter; diff --git a/src/WebApi.Contracts/Dto/PlaythroughDto.cs b/src/WebApi.Contracts/Dto/PlaythroughDto.cs new file mode 100644 index 0000000..59c04c8 --- /dev/null +++ b/src/WebApi.Contracts/Dto/PlaythroughDto.cs @@ -0,0 +1,20 @@ +using System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// One recorded run through a game - the base playthrough, an NG+ replay, a speedrun, or any other +/// attempt worth logging. +/// +public class PlaythroughDto +{ + /// + /// Free-text label for this run (e.g. "First run", "NG+1", "Speedrun for fun"). + /// + public string? Label { get; set; } + + /// + /// When this run was completed. Unset if still in progress or abandoned. + /// + public DateOnly? CompletedAt { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/VideoGameCopyType.cs b/src/WebApi.Contracts/Dto/VideoGameCopyType.cs new file mode 100644 index 0000000..c3b835b --- /dev/null +++ b/src/WebApi.Contracts/Dto/VideoGameCopyType.cs @@ -0,0 +1,10 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Whether a tracked video game platform entry is a physical or digital copy. +/// +public enum VideoGameCopyType +{ + Physical, + Digital +} diff --git a/src/WebApi.Contracts/Dto/VideoGameDto.cs b/src/WebApi.Contracts/Dto/VideoGameDto.cs index c9155e3..7f10aee 100644 --- a/src/WebApi.Contracts/Dto/VideoGameDto.cs +++ b/src/WebApi.Contracts/Dto/VideoGameDto.cs @@ -1,4 +1,4 @@ -using System; +using System.Collections.Generic; using Keeptrack.Common.System; namespace Keeptrack.WebApi.Contracts.Dto; @@ -19,14 +19,9 @@ public class VideoGameDto : IHasId public string? Title { get; set; } /// - /// Latest plaform the game has been played on. + /// Every platform this game is tracked on - one entry per platform, not per physical copy. /// - public string? Platform { get; set; } - - /// - /// Current payling state. - /// - public string? State { get; set; } + public List Platforms { get; set; } = []; public int? Year { get; set; } @@ -34,11 +29,6 @@ public class VideoGameDto : IHasId public string? Notes { get; set; } - /// - /// Finished date. - /// - public DateOnly? FinishedAt { get; set; } - /// /// Id of the linked videogame_reference document, when a match has been found. /// @@ -47,4 +37,17 @@ public class VideoGameDto : IHasId public bool IsOwned { get; set; } public bool IsWishlisted { get; set; } + + /// + /// Filter-only query parameter: matches if any entry in has this platform. + /// Never populated on a returned game - the list endpoint binds query-string filters onto this DTO + /// before mapping to the Domain model, so this property exists purely to receive ?platform=. + /// + public string? Platform { get; set; } + + /// + /// Filter-only query parameter: matches if any entry in has this state. Never + /// populated on a returned game - see . + /// + public string? State { get; set; } } diff --git a/src/WebApi.Contracts/Dto/VideoGamePlatformDto.cs b/src/WebApi.Contracts/Dto/VideoGamePlatformDto.cs new file mode 100644 index 0000000..f7cc676 --- /dev/null +++ b/src/WebApi.Contracts/Dto/VideoGamePlatformDto.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// One entry per platform a game is tracked on - not one entry per physical copy. +/// +public class VideoGamePlatformDto +{ + /// + /// Platform name (e.g. "PS5", "Xbox Series X", "PC"). + /// + public string? Platform { get; set; } + + /// + /// Whether this is a physical or digital copy. + /// + public VideoGameCopyType CopyType { get; set; } + + /// + /// Current playing state for this platform entry. + /// + public string? State { get; set; } + + /// + /// Every recorded run through the game on this platform. + /// + public List Playthroughs { get; set; } = []; + + /// + /// Whether the game has been fully completed (e.g. platinum trophy, 1000/1000 achievements) on this platform. + /// + public bool IsFullyCompleted { get; set; } + + /// + /// When the game was fully completed on this platform. + /// + public DateOnly? FullyCompletedAt { get; set; } +} diff --git a/src/WebApi/Controllers/WishlistController.cs b/src/WebApi/Controllers/WishlistController.cs index bfd8fed..87b64fa 100644 --- a/src/WebApi/Controllers/WishlistController.cs +++ b/src/WebApi/Controllers/WishlistController.cs @@ -31,7 +31,7 @@ public async Task> Get() var books = await bookRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, new BookModel { OwnerId = ownerId, Title = string.Empty, Author = string.Empty, IsWishlisted = true }); var videoGames = await videoGameRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, - new VideoGameModel { OwnerId = ownerId, Title = string.Empty, Platform = string.Empty, State = string.Empty, IsWishlisted = true }); + new VideoGameModel { OwnerId = ownerId, Title = string.Empty, IsWishlisted = true }); return Ok(new WishlistDto { diff --git a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs index 9d3dac4..e7820fb 100644 --- a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs +++ b/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs @@ -24,9 +24,17 @@ public DataStorageMappingProfile() CreateMap(); CreateMap(); - CreateMap(); + CreateMap() + .ForMember(x => x.Platform, opt => opt.Ignore()) + .ForMember(x => x.State, opt => opt.Ignore()); CreateMap(); + CreateMap(); + CreateMap(); + + CreateMap(); + CreateMap(); + CreateMap(); CreateMap(); diff --git a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs index ce59486..cc7efe9 100644 --- a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs +++ b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs @@ -41,6 +41,12 @@ public WebServiceMappingProfile() .ForMember(x => x.OwnerId, opt => opt.Ignore()); CreateMap(); + CreateMap(); + CreateMap(); + + CreateMap(); + CreateMap(); + // WatchNext reads are one-directional (Model -> Dto): WatchNextService is a pure Domain-level // computation with no Dto dependency, so WatchNextController maps its result here. CreateMap(); diff --git a/src/WebApi/ReferenceData/ReferenceEnrichmentService.VideoGames.cs b/src/WebApi/ReferenceData/ReferenceEnrichmentService.VideoGames.cs index cc64991..780570f 100644 --- a/src/WebApi/ReferenceData/ReferenceEnrichmentService.VideoGames.cs +++ b/src/WebApi/ReferenceData/ReferenceEnrichmentService.VideoGames.cs @@ -13,8 +13,9 @@ public partial class ReferenceEnrichmentService /// User-triggered "check for reference match" for video games - see /// for the full rationale (this is the same local-only, /// no-HTTP-call lookup, just against videogame_reference). A successful match also sets - /// to the reference's canonical year. / - /// are never overwritten - they describe this tenant's own copy/progress. + /// to the reference's canonical year. + /// is never touched - each entry describes this tenant's own copy/progress on that platform, not the + /// canonical release. /// public async Task TryLinkExistingVideoGameReferenceAsync(VideoGameModel model) { diff --git a/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs b/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs index 08f41f2..3781036 100644 --- a/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs @@ -153,7 +153,7 @@ public async Task RefreshReference_LinksVideoGame_WhenAnExistingReferenceMatches }); await Authenticate(); - var created = await PostAsync("/api/video-games", new VideoGameDto { Title = title, Platform = "PC", State = "Current", Year = year }); + var created = await PostAsync("/api/video-games", new VideoGameDto { Title = title, Year = year }); try { diff --git a/test/WebApi.IntegrationTests/Resources/VideoGameResourceTest.cs b/test/WebApi.IntegrationTests/Resources/VideoGameResourceTest.cs index 2117786..f9277ea 100644 --- a/test/WebApi.IntegrationTests/Resources/VideoGameResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/VideoGameResourceTest.cs @@ -32,8 +32,7 @@ public async Task VideoGameResourceFullCycle_IsOk() .Rules((f, o) => { o.Title = f.Random.AlphaNumeric(14); - o.Platform = "PC"; - o.State = "Current"; + o.Platforms = [new VideoGamePlatformDto { Platform = "PC", CopyType = VideoGameCopyType.Physical, State = "Current" }]; }) .Generate(); var created = await PostAsync($"/{ResourceEndpoint}", input); @@ -45,7 +44,7 @@ public async Task VideoGameResourceFullCycle_IsOk() await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); - updated.Should().BeEquivalentTo(created, x => x.Excluding(item => item.FinishedAt)); // issue with DateTime and MongoDB + updated.Should().BeEquivalentTo(created); var finalItems = await GetAsync>($"/{ResourceEndpoint}"); finalItems.TotalCount.Should().BeGreaterThan(initialItems.TotalCount); @@ -65,7 +64,11 @@ public async Task VideoGameResourceSearch_FiltersToMatchingPlatform_IsOk() await Authenticate(); var title = System.Guid.NewGuid().ToString(); - var created = await PostAsync($"/{ResourceEndpoint}", new VideoGameDto { Title = title, Platform = "PS5", State = "Available" }); + var created = await PostAsync($"/{ResourceEndpoint}", new VideoGameDto + { + Title = title, + Platforms = [new VideoGamePlatformDto { Platform = "PS5", CopyType = VideoGameCopyType.Physical, State = "Available" }] + }); try { @@ -88,8 +91,7 @@ public async Task VideoGameResourceOwnedAndWishlistedFilters_OnlyReturnMatchingI var created = await PostAsync($"/{ResourceEndpoint}", new VideoGameDto { Title = title, - Platform = "PS5", - State = "Available", + Platforms = [new VideoGamePlatformDto { Platform = "PS5", CopyType = VideoGameCopyType.Physical, State = "Available" }], IsOwned = true, IsWishlisted = true }); diff --git a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs index 32c7a3a..81fa078 100644 --- a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs +++ b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs @@ -630,7 +630,11 @@ public async Task ResolveVideoGameAsync_PropagatesTheUpsertedReferenceId() public async Task TryLinkExistingVideoGameReferenceAsync_LinksAndUpdatesTitle_OnTitleYearMatch() { var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); - var model = new VideoGameModel { Id = "game-1", OwnerId = "owner", Title = "Some Typo'd Game", Platform = "PC", State = "Current", Year = 2020 }; + var model = new VideoGameModel + { + Id = "game-1", OwnerId = "owner", Title = "Some Typo'd Game", Year = 2020, + Platforms = [new VideoGamePlatformModel { Platform = "PC", State = "Current" }] + }; _videoGameReferenceRepository .Setup(r => r.FindByTitleYearAsync("Some Typo'd Game", 2020)) .ReturnsAsync(new VideoGameReferenceModel { Id = "reference-1", Title = "Some Game", TitleNormalized = "some game", ExternalIds = [] }); @@ -639,7 +643,7 @@ public async Task TryLinkExistingVideoGameReferenceAsync_LinksAndUpdatesTitle_On result.ReferenceId.Should().Be("reference-1"); result.Title.Should().Be("Some Game"); - result.Platform.Should().Be("PC"); + result.Platforms.Should().ContainSingle(p => p.Platform == "PC"); _videoGameRepository.Verify(r => r.UpdateAsync("game-1", It.Is(m => m.ReferenceId == "reference-1"), "owner"), Times.Once); } @@ -647,7 +651,11 @@ public async Task TryLinkExistingVideoGameReferenceAsync_LinksAndUpdatesTitle_On public async Task TryLinkExistingVideoGameReferenceAsync_UpdatesYearToTheReferencesCanonicalYear_OnLink() { var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); - var model = new VideoGameModel { Id = "game-1", OwnerId = "owner", Title = "Some Game", Platform = "PC", State = "Current", Year = 2019 }; + var model = new VideoGameModel + { + Id = "game-1", OwnerId = "owner", Title = "Some Game", Year = 2019, + Platforms = [new VideoGamePlatformModel { Platform = "PC", State = "Current" }] + }; _videoGameReferenceRepository .Setup(r => r.FindByTitleYearAsync("Some Game", 2019)) .ReturnsAsync(new VideoGameReferenceModel { Id = "reference-1", Title = "Some Game", TitleNormalized = "some game", Year = 2020, ExternalIds = [] }); @@ -662,7 +670,11 @@ public async Task TryLinkExistingVideoGameReferenceAsync_UpdatesYearToTheReferen public async Task TryLinkExistingVideoGameReferenceAsync_Unlinks_WhenAlreadyLinkedButNoMatchFoundForTheCurrentTitle() { var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); - var model = new VideoGameModel { Id = "game-1", OwnerId = "owner", Title = "Some Game", Platform = "PC", State = "Current", Year = 2020, ReferenceId = "old-reference" }; + var model = new VideoGameModel + { + Id = "game-1", OwnerId = "owner", Title = "Some Game", Year = 2020, ReferenceId = "old-reference", + Platforms = [new VideoGamePlatformModel { Platform = "PC", State = "Current" }] + }; _videoGameReferenceRepository.Setup(r => r.FindByTitleYearAsync("Some Game", 2020)).ReturnsAsync((VideoGameReferenceModel?)null); _videoGameReferenceRepository.Setup(r => r.FindByTitleAsync("Some Game")).ReturnsAsync((VideoGameReferenceModel?)null); diff --git a/test/WebApi.UnitTests/Services/WishlistServiceTest.cs b/test/WebApi.UnitTests/Services/WishlistServiceTest.cs index a7edb95..d04fd3c 100644 --- a/test/WebApi.UnitTests/Services/WishlistServiceTest.cs +++ b/test/WebApi.UnitTests/Services/WishlistServiceTest.cs @@ -63,8 +63,8 @@ public void SortVideoGames_OrdersByTitleAscending() { var games = new[] { - new VideoGameModel { Id = "1", OwnerId = "owner", Title = "Zelda", Platform = "Switch", State = "Available" }, - new VideoGameModel { Id = "2", OwnerId = "owner", Title = "Elden Ring", Platform = "PS5", State = "Available" } + new VideoGameModel { Id = "1", OwnerId = "owner", Title = "Zelda", Platforms = [new VideoGamePlatformModel { Platform = "Switch", State = "Available" }] }, + new VideoGameModel { Id = "2", OwnerId = "owner", Title = "Elden Ring", Platforms = [new VideoGamePlatformModel { Platform = "PS5", State = "Available" }] } }; var result = _service.SortVideoGames(games); From cda586801ef37c1e0c7a0e94cc8b035020f0e482 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Wed, 8 Jul 2026 20:35:01 +0200 Subject: [PATCH 24/44] Add migration scripts --- ...migrate-videogame-to-embedded-platforms.js | 44 +++++++++++++++++++ .../Entities/Playthrough.cs | 2 + 2 files changed, 46 insertions(+) create mode 100644 scripts/migrate-videogame-to-embedded-platforms.js diff --git a/scripts/migrate-videogame-to-embedded-platforms.js b/scripts/migrate-videogame-to-embedded-platforms.js new file mode 100644 index 0000000..4f76411 --- /dev/null +++ b/scripts/migrate-videogame-to-embedded-platforms.js @@ -0,0 +1,44 @@ +// One-off data migration: VideoGame moved from one top-level document per (owner, title, platform) to +// one document per (owner, title) with an embedded `platforms` array - see CLAUDE.md's video game +// section for the full rationale (tracking one game across multiple platforms, with NG+/completion +// tracking, used to mean duplicating the whole document per platform). +// +// This migration only reshapes each existing document's own flat `platform`/`state`/`finished_at` into +// a single-element `platforms` array - it does NOT merge separate documents that represent the same +// game on different platforms into one. That consolidation (and any manual platform/playthrough +// clean-up) is expected to be done by hand afterward, one game at a time. +// +// `copy_type` (Physical/Digital) never existed before this change, so every migrated entry defaults to +// "Physical" - re-flip individual entries to "Digital" by hand where wrong, same as the manual +// consolidation above. +// +// Idempotent: only touches documents that still have the old `platform` field and no `platforms` array +// yet, so re-running after some documents have already been migrated is a safe no-op for those. +// +// Run once per environment with pre-existing video game data, e.g.: +// mongosh "mongodb://localhost:27017/keeptrack_dev" scripts/migrate-videogame-to-embedded-platforms.js +function migrate(collection) { + let modified = 0; + collection.find({ platform: { $exists: true }, platforms: { $exists: false } }).forEach(doc => { + const platformEntry = { + platform: doc.platform || "", + copy_type: "Physical", + state: doc.state || "", + playthroughs: doc.finished_at ? [{ label: "Completed", completed_at: doc.finished_at }] : [], + is_fully_completed: false, + fully_completed_at: null + }; + + collection.updateOne( + { _id: doc._id }, + { + $set: { platforms: [platformEntry] }, + $unset: { platform: "", state: "", finished_at: "" } + } + ); + modified++; + }); + print(`${collection.getName()}: migrated ${modified} document(s)`); +} + +migrate(db.videogame); diff --git a/src/Infrastructure.MongoDb/Entities/Playthrough.cs b/src/Infrastructure.MongoDb/Entities/Playthrough.cs index d811b79..fda048a 100644 --- a/src/Infrastructure.MongoDb/Entities/Playthrough.cs +++ b/src/Infrastructure.MongoDb/Entities/Playthrough.cs @@ -1,4 +1,5 @@ using System; +using MongoDB.Bson.Serialization.Attributes; namespace Keeptrack.Infrastructure.MongoDb.Entities; @@ -6,5 +7,6 @@ public class Playthrough { public required string Label { get; set; } + [BsonElement("completed_at")] public DateTime? CompletedAt { get; set; } } From 1a1df5dda97566f00fc8716a30c453ac89c126b4 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Thu, 9 Jul 2026 00:45:47 +0200 Subject: [PATCH 25/44] Add album tracks and playlists --- CONTRIBUTING.md | 2 +- scripts/mongodb-create-index.js | 2 + .../Inventory/Clients/PlaylistApiClient.cs | 9 + .../Inventory/Clients/SongApiClient.cs | 24 ++ .../Inventory/Pages/AlbumDetail.razor | 128 ++++++++--- .../Inventory/Pages/PlaylistDetail.razor | 217 ++++++++++++++++++ .../Inventory/Pages/Playlists.razor | 51 ++++ .../Inventory/Pages/Playlists.razor.cs | 48 ++++ src/BlazorApp/Components/Layout/NavMenu.razor | 5 + .../ReferenceDataAdminApiClient.cs | 15 +- .../ReferenceDataAdminPage.razor | 62 ++++- ...frastructureServiceCollectionExtensions.cs | 4 + src/BlazorApp/wwwroot/app.css | 64 ++++++ src/Domain/Models/AlbumReferenceModel.cs | 2 + src/Domain/Models/PlaylistModel.cs | 19 ++ src/Domain/Models/ReferenceTrackModel.cs | 21 ++ src/Domain/Models/SongModel.cs | 35 +++ .../Repositories/IPlaylistRepository.cs | 7 + src/Domain/Repositories/ISongRepository.cs | 7 + .../Entities/AlbumReference.cs | 2 + .../Entities/Playlist.cs | 21 ++ .../Entities/ReferenceTrack.cs | 13 ++ src/Infrastructure.MongoDb/Entities/Song.cs | 27 +++ .../Repositories/PlaylistRepository.cs | 22 ++ .../Repositories/SongRepository.cs | 30 +++ src/WebApi.Contracts/Dto/AlbumReferenceDto.cs | 2 + src/WebApi.Contracts/Dto/PlaylistDto.cs | 25 ++ .../Dto/ReferenceSyncJobDto.cs | 39 ++++ src/WebApi.Contracts/Dto/ReferenceTrackDto.cs | 13 ++ src/WebApi.Contracts/Dto/SongDto.cs | 36 +++ src/WebApi/Controllers/PlaylistController.cs | 12 + src/WebApi/Controllers/SongController.cs | 12 + ...frastructureServiceCollectionExtensions.cs | 2 + src/WebApi/Import/ImportJobStore.cs | 68 ------ src/WebApi/Import/TvTimeImportController.cs | 13 +- src/WebApi/Jobs/JobStore.cs | 64 ++++++ .../DataStorageMappingProfile.cs | 9 + .../WebServiceMappingProfile.cs | 9 + src/WebApi/Program.cs | 13 +- src/WebApi/ReferenceData/DiscogsClient.cs | 28 ++- src/WebApi/ReferenceData/IDiscogsClient.cs | 9 +- .../ReferenceDataAdminController.cs | 57 ++++- .../ReferenceEnrichmentService.Albums.cs | 6 + .../ReferenceSyncBackgroundService.cs | 2 +- .../ReferenceData/ReferenceSyncService.cs | 7 +- .../Resources/PlaylistResourceTest.cs | 85 +++++++ .../ReferenceDataAdminResourceTest.cs | 53 ++++- .../Resources/SongResourceTest.cs | 103 +++++++++ test/WebApi.UnitTests/Jobs/JobStoreTest.cs | 91 ++++++++ .../ReferenceEnrichmentServiceTest.cs | 12 +- .../ReferenceData/ReferenceSyncServiceTest.cs | 30 ++- 51 files changed, 1508 insertions(+), 129 deletions(-) create mode 100644 src/BlazorApp/Components/Inventory/Clients/PlaylistApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Clients/SongApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Pages/PlaylistDetail.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/Playlists.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/Playlists.razor.cs create mode 100644 src/Domain/Models/PlaylistModel.cs create mode 100644 src/Domain/Models/ReferenceTrackModel.cs create mode 100644 src/Domain/Models/SongModel.cs create mode 100644 src/Domain/Repositories/IPlaylistRepository.cs create mode 100644 src/Domain/Repositories/ISongRepository.cs create mode 100644 src/Infrastructure.MongoDb/Entities/Playlist.cs create mode 100644 src/Infrastructure.MongoDb/Entities/ReferenceTrack.cs create mode 100644 src/Infrastructure.MongoDb/Entities/Song.cs create mode 100644 src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs create mode 100644 src/Infrastructure.MongoDb/Repositories/SongRepository.cs create mode 100644 src/WebApi.Contracts/Dto/PlaylistDto.cs create mode 100644 src/WebApi.Contracts/Dto/ReferenceSyncJobDto.cs create mode 100644 src/WebApi.Contracts/Dto/ReferenceTrackDto.cs create mode 100644 src/WebApi.Contracts/Dto/SongDto.cs create mode 100644 src/WebApi/Controllers/PlaylistController.cs create mode 100644 src/WebApi/Controllers/SongController.cs delete mode 100644 src/WebApi/Import/ImportJobStore.cs create mode 100644 src/WebApi/Jobs/JobStore.cs create mode 100644 test/WebApi.IntegrationTests/Resources/PlaylistResourceTest.cs create mode 100644 test/WebApi.IntegrationTests/Resources/SongResourceTest.cs create mode 100644 test/WebApi.UnitTests/Jobs/JobStoreTest.cs diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b37159b..bbfb2c6 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -290,7 +290,7 @@ Or in Rider, in "File | Settings | Build, Execution, Deployment | Unit Testing | Set `KESTREL_WEBAPP_URL` to target a specific already-running instance instead of letting the tests spin up their own. -The standard test user above has no `role` claim, which is exactly what `ReferenceDataAdminResourceTest` needs to prove the "AdminOnly" policy actually rejects a non-admin caller (403). There's no automated coverage yet of the admin-succeeds path end-to-end over HTTP, since that would need a second Firebase test user with the `role: admin` claim set (see [Admin role](#admin-role) above) plus its own `FIREBASE_ADMIN_USERNAME`/`FIREBASE_ADMIN_PASSWORD` env vars and an `AuthenticateAsAdmin()` helper - a deliberately deferred setup step, not a gap that was missed. The underlying Mongo query logic (`SetReferenceIdForTitleYearAsync`, `FindDistinctUnresolvedTitleYearsAsync`) is still covered directly against a real database in `TvShowReferenceLinkingTest`, which resolves repositories from the test host's DI container instead of going over HTTP. +The standard test user above now carries the `role: admin` custom claim (set via `scripts/firebase-set-admin.js`, see [Admin role](#admin-role) above), so `ReferenceDataAdminResourceTest` and any other admin-gated endpoint can be exercised end-to-end over HTTP with the same single test account - there's no separate non-admin test account, so there's no automated coverage of the "AdminOnly" policy actually rejecting a non-admin caller; that would need a second Firebase test user without the claim. The underlying Mongo query logic (`SetReferenceIdForTitleYearAsync`, `FindDistinctUnresolvedTitleYearsAsync`) is still covered directly against a real database in `TvShowReferenceLinkingTest`, which resolves repositories from the test host's DI container instead of going over HTTP. ## Container images diff --git a/scripts/mongodb-create-index.js b/scripts/mongodb-create-index.js index cdd02aa..090db29 100644 --- a/scripts/mongodb-create-index.js +++ b/scripts/mongodb-create-index.js @@ -25,6 +25,8 @@ ensureIndex(db.car_history, { owner_id: 1 }, { name: "car_history_owner" }); ensureIndex(db.movie, { owner_id: 1 }, { name: "movie_owner" }); ensureIndex(db.tvshow, { owner_id: 1 }, { name: "tvshow_owner" }); ensureIndex(db.videogame, { owner_id: 1 }, { name: "videogame_owner" }); +ensureIndex(db.song, { owner_id: 1 }, { name: "song_owner" }); +ensureIndex(db.playlist, { owner_id: 1 }, { name: "playlist_owner" }); // car / car_history: the only two repositories that actually issue a $text query (CarRepository has no // GetFilter override, so it falls back to MongoDbRepositoryBase's builder.Text(search); CarHistoryRepository diff --git a/src/BlazorApp/Components/Inventory/Clients/PlaylistApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/PlaylistApiClient.cs new file mode 100644 index 0000000..33d00cc --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Clients/PlaylistApiClient.cs @@ -0,0 +1,9 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Inventory.Clients; + +public sealed class PlaylistApiClient(HttpClient http) + : InventoryApiClientBase(http) +{ + protected override string ApiResourceName => "/api/playlists"; +} diff --git a/src/BlazorApp/Components/Inventory/Clients/SongApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/SongApiClient.cs new file mode 100644 index 0000000..39e7597 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Clients/SongApiClient.cs @@ -0,0 +1,24 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Inventory.Clients; + +public sealed class SongApiClient(HttpClient http) + : InventoryApiClientBase(http) +{ + protected override string ApiResourceName => "/api/songs"; + + /// + /// The single shared "add a real track" operation - reused by both AlbumDetail.razor's + /// per-track "+ Add to playlist" and PlaylistDetail.razor's "Add from album" picker, so picking + /// the same track from two different places (or twice from the same place) reuses one + /// instead of creating a duplicate. Relies on SongRepository.GetFilter's exact-match on + /// / - no dedicated WebApi endpoint needed. + /// + public async Task GetOrCreateForTrackAsync(string albumId, string position, string title, string? duration, string? artist) + { + var existing = await GetAsync("", 1, 1, new Dictionary { ["AlbumId"] = albumId, ["TrackPosition"] = position }); + if (existing.Items.Count > 0) return existing.Items[0]; + + return await AddAsync(new SongDto { Title = title, Artist = artist, AlbumId = albumId, TrackPosition = position, Duration = duration }); + } +} diff --git a/src/BlazorApp/Components/Inventory/Pages/AlbumDetail.razor b/src/BlazorApp/Components/Inventory/Pages/AlbumDetail.razor index c168e4d..6374b97 100644 --- a/src/BlazorApp/Components/Inventory/Pages/AlbumDetail.razor +++ b/src/BlazorApp/Components/Inventory/Pages/AlbumDetail.razor @@ -46,39 +46,78 @@ else }
-
+
@if (!string.IsNullOrEmpty(_reference?.ImageUrl)) { -
- @_album.Title cover -
+ @_album.Title cover } -
-
- - -
-
- - -
-
- - -
-
- - +
+
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ @if (!string.IsNullOrEmpty(_reference?.Synopsis)) + { +

@_reference.Synopsis

+ }
- @if (!string.IsNullOrEmpty(_reference?.Synopsis)) - { -
-

@_reference.Synopsis

- }
+ + @if (!string.IsNullOrEmpty(_reference?.ArtistImageUrl)) + { +

Artist

+ + } + + @if (_reference?.Tracks.Count > 0) + { +

Tracklist

+
+ @foreach (var track in _reference.Tracks) + { +
+ @track.Position @track.Title +
+ @track.Duration + +
+ @if (_openTrackMenu == track.Position) + { +
+

Add to playlist

+ @if (_playlists.Count == 0) + { +

Create a playlist first

+ } + else + { + @foreach (var playlist in _playlists) + { + + } + } +
+ } +
+ } +
+ } } @code { @@ -88,16 +127,28 @@ else [Inject] private ReferenceDataApiClient ReferenceDataApi { get; set; } = null!; + [Inject] private PlaylistApiClient PlaylistApi { get; set; } = null!; + + [Inject] private SongApiClient SongApi { get; set; } = null!; + private static readonly TimeSpan RefreshMessageDuration = TimeSpan.FromSeconds(4); private bool _loading = true; private AlbumDto? _album; private AlbumReferenceDto? _reference; + private List _playlists = []; + private string? _openTrackMenu; private bool _refreshingReference; private string? _refreshMessage; private string _refreshMessageStyle = "neutral"; private object? _refreshMessageToken; + /// Reuses CastGrid's "photo + name" card for the single credited artist, instead of + /// introducing a one-off component for what's visually the same layout as a TV/movie cast member. + private List _artistCard => _reference is null + ? [] + : [new CastMemberDto { Name = _reference.ArtistName ?? _album?.Artist ?? "", CharacterName = "", ProfileImageUrl = _reference.ArtistImageUrl }]; + protected override async Task OnParametersSetAsync() => await LoadAsync(); private async Task LoadAsync() @@ -105,9 +156,34 @@ else _loading = true; _album = await AlbumApi.GetOneAsync(Id); _reference = string.IsNullOrEmpty(_album?.ReferenceId) ? null : await ReferenceDataApi.GetAlbumAsync(_album.ReferenceId); + var playlists = await PlaylistApi.GetAsync("", 1, 5000); + _playlists = playlists.Items; _loading = false; } + private void ToggleTrackMenu(string position) + { + _openTrackMenu = _openTrackMenu == position ? null : position; + } + + /// + /// The shared "add a real track" operation () - + /// reuses the same if this exact track was already added to any playlist, + /// instead of creating a duplicate. + /// + private async Task AddTrackToPlaylistAsync(ReferenceTrackDto track, PlaylistDto playlist) + { + _openTrackMenu = null; + if (_album?.Id is null) return; + + var song = await SongApi.GetOrCreateForTrackAsync(_album.Id, track.Position, track.Title, track.Duration, _album.Artist); + if (song.Id is not null && !playlist.SongIds.Contains(song.Id)) + { + playlist.SongIds.Add(song.Id); + await PlaylistApi.UpdateAsync(playlist); + } + } + private async Task SetRatingAsync(float rating) { if (_album is null) return; diff --git a/src/BlazorApp/Components/Inventory/Pages/PlaylistDetail.razor b/src/BlazorApp/Components/Inventory/Pages/PlaylistDetail.razor new file mode 100644 index 0000000..db62e00 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/PlaylistDetail.razor @@ -0,0 +1,217 @@ +@page "/playlists/{Id}" +@rendermode InteractiveServer +@attribute [Authorize] +@using Keeptrack.BlazorApp.Components.ReferenceData + +@if (_loading) +{ +
+ + Loading… +
+} +else if (_playlist is null) +{ +
+
◈
+

Playlist not found.

+
+} +else +{ +
+
+ +
+
+ +

Songs

+ + @if (PlaylistSongs.Count == 0) + { +

No songs yet - add one from an album below.

+ } + else + { +
+ @foreach (var (song, index) in PlaylistSongs) + { +
+ @song.Title + @song.Artist + + @if (!string.IsNullOrEmpty(song.AlbumId) && _albumTitlesById.TryGetValue(song.AlbumId, out var albumTitle)) + { + @albumTitle + } + +
+ + + +
+
+ } +
+ } + +
+ + + + @if (!string.IsNullOrEmpty(_selectedAlbumId)) + { + @if (_selectedAlbumTracks.Count == 0) + { +

+ No tracklist available - link this album to Discogs first. +

+ } + else + { +
+ @foreach (var track in _selectedAlbumTracks) + { +
+ @track.Position @track.Title +
+ @track.Duration + +
+
+ } +
+ } + } +
+} + +@code { + [Parameter] public required string Id { get; set; } + + [Inject] private PlaylistApiClient PlaylistApi { get; set; } = null!; + + [Inject] private SongApiClient SongApi { get; set; } = null!; + + [Inject] private AlbumApiClient AlbumApi { get; set; } = null!; + + [Inject] private ReferenceDataApiClient ReferenceDataApi { get; set; } = null!; + + private bool _loading = true; + private PlaylistDto? _playlist; + private List _albums = []; + private Dictionary _songsById = []; + private Dictionary _albumTitlesById = []; + private string _selectedAlbumId = ""; + private List _selectedAlbumTracks = []; + + /// + /// Every song in the playlist paired with its position - a dangling SongId (the song was + /// deleted separately) is silently skipped rather than shown as a broken row, the same soft-reference + /// tolerance already used for a missing reference-link elsewhere in the app. + /// + private List<(SongDto Song, int Index)> PlaylistSongs => + _playlist is null + ? [] + : _playlist.SongIds + .Select((id, index) => (Song: _songsById.GetValueOrDefault(id), Index: index)) + .Where(x => x.Song is not null) + .Select(x => (x.Song!, x.Index)) + .ToList(); + + protected override async Task OnParametersSetAsync() => await LoadAsync(); + + private async Task LoadAsync() + { + _loading = true; + _playlist = await PlaylistApi.GetOneAsync(Id); + var songs = await SongApi.GetAsync("", 1, 5000); + _songsById = songs.Items.Where(s => s.Id is not null).ToDictionary(s => s.Id!, s => s); + var albums = await AlbumApi.GetAsync("", 1, 5000); + _albums = albums.Items; + _albumTitlesById = _albums.Where(a => a.Id is not null).ToDictionary(a => a.Id!, a => a.Title ?? ""); + _loading = false; + } + + private async Task SavePlaylistAsync() + { + if (_playlist is null) return; + await PlaylistApi.UpdateAsync(_playlist); + } + + private async Task SaveTitleAsync(ChangeEventArgs e) + { + if (_playlist is null) return; + var title = e.Value?.ToString(); + if (string.IsNullOrWhiteSpace(title)) return; + _playlist.Title = title; + await SavePlaylistAsync(); + } + + private async Task MoveUpAsync(int index) + { + if (_playlist is null || index <= 0) return; + (_playlist.SongIds[index - 1], _playlist.SongIds[index]) = (_playlist.SongIds[index], _playlist.SongIds[index - 1]); + await SavePlaylistAsync(); + } + + private async Task MoveDownAsync(int index) + { + if (_playlist is null || index >= _playlist.SongIds.Count - 1) return; + (_playlist.SongIds[index], _playlist.SongIds[index + 1]) = (_playlist.SongIds[index + 1], _playlist.SongIds[index]); + await SavePlaylistAsync(); + } + + private async Task RemoveSongAsync(int index) + { + if (_playlist is null) return; + _playlist.SongIds.RemoveAt(index); + await SavePlaylistAsync(); + } + + private async Task SelectAlbumAsync(ChangeEventArgs e) + { + _selectedAlbumId = e.Value?.ToString() ?? ""; + await LoadSelectedAlbumTracksAsync(); + } + + private async Task LoadSelectedAlbumTracksAsync() + { + _selectedAlbumTracks = []; + if (string.IsNullOrEmpty(_selectedAlbumId)) return; + + var album = _albums.FirstOrDefault(a => a.Id == _selectedAlbumId); + if (string.IsNullOrEmpty(album?.ReferenceId)) return; + + var reference = await ReferenceDataApi.GetAlbumAsync(album.ReferenceId); + _selectedAlbumTracks = reference?.Tracks ?? []; + } + + /// + /// The shared "add a real track" operation () - + /// reuses the same if this exact track was already added elsewhere, instead of + /// creating a duplicate. + /// + private async Task AddTrackAsync(ReferenceTrackDto track) + { + if (_playlist is null) return; + var album = _albums.FirstOrDefault(a => a.Id == _selectedAlbumId); + if (album?.Id is null) return; + + var song = await SongApi.GetOrCreateForTrackAsync(album.Id, track.Position, track.Title, track.Duration, album.Artist); + if (song.Id is null) return; + + _songsById[song.Id] = song; + if (!_playlist.SongIds.Contains(song.Id)) + { + _playlist.SongIds.Add(song.Id); + await SavePlaylistAsync(); + } + } +} diff --git a/src/BlazorApp/Components/Inventory/Pages/Playlists.razor b/src/BlazorApp/Components/Inventory/Pages/Playlists.razor new file mode 100644 index 0000000..790cb5f --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/Playlists.razor @@ -0,0 +1,51 @@ +@page "/playlists" +@inherits InventoryPageBase +@rendermode InteractiveServer +@attribute [Authorize] + + + + Title + Songs + + + + @playlist.Title + + @playlist.SongIds.Count + + + + + +
+ + +
+

Manage songs from the playlist's detail page.

+ + diff --git a/src/BlazorApp/Components/Inventory/Pages/Playlists.razor.cs b/src/BlazorApp/Components/Inventory/Pages/Playlists.razor.cs new file mode 100644 index 0000000..893e98c --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/Playlists.razor.cs @@ -0,0 +1,48 @@ +using Keeptrack.WebApi.Contracts.Dto; +using Microsoft.AspNetCore.Components; + +namespace Keeptrack.BlazorApp.Components.Inventory.Pages; + +public partial class Playlists : InventoryPageBase +{ + [Inject] private PlaylistApiClient PlaylistApi { get; set; } = null!; + + [Inject] private NavigationManager Nav { get; set; } = null!; + + protected override InventoryApiClientBase Api => PlaylistApi; + + /// + /// Creating a playlist only ever captures Title here (see FormTemplate) - songs are added on + /// the detail page, so a successful create navigates straight there instead of closing the form and + /// staying on the list. Same rationale as VideoGames.razor.cs's override. + /// + protected override async Task SaveAsync() + { + try + { + if (_form.Id is null) + { + var created = await PlaylistApi.AddAsync(_form); + _showForm = false; + Nav.NavigateTo($"/playlists/{created.Id}"); + } + else + { + await PlaylistApi.UpdateAsync(_form); + _showForm = false; + await LoadAsync(); + } + } + catch (Exception ex) + { + _error = ex.Message; + } + } + + protected override PlaylistDto CloneItem(PlaylistDto item) => new() + { + Id = item.Id, + Title = item.Title, + SongIds = [.. item.SongIds] + }; +} diff --git a/src/BlazorApp/Components/Layout/NavMenu.razor b/src/BlazorApp/Components/Layout/NavMenu.razor index a363dfd..314f145 100644 --- a/src/BlazorApp/Components/Layout/NavMenu.razor +++ b/src/BlazorApp/Components/Layout/NavMenu.razor @@ -39,6 +39,11 @@ ♪ Albums
+
+ + ♫ Playlists + +
▭ TV shows diff --git a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs index 221084f..54fe88b 100644 --- a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs +++ b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminApiClient.cs @@ -54,13 +54,22 @@ public async Task ImportAsync(Stream zipStream, st } /// - /// Forces an immediate re-check of every reference document against TMDB (see + /// Starts an immediate re-check of every reference document against its provider (see /// ReferenceDataAdminController.SyncNow), instead of waiting for the periodic background sync. + /// Runs in the background; poll with the returned job id for progress. /// - public async Task SyncNowAsync() + public async Task StartSyncAsync() { var response = await http.PostAsync("/api/reference-data/sync-now", null); response.EnsureSuccessStatusCode(); - return (await response.Content.ReadFromJsonAsync())!; + + var job = await response.Content.ReadFromJsonAsync(); + return job!.JobId; + } + + public async Task GetSyncStatusAsync(Guid jobId) + { + var status = await http.GetFromJsonAsync($"/api/reference-data/sync-now/{jobId}"); + return status ?? new ReferenceSyncJobStatusDto { Stage = ReferenceSyncStage.Failed, ErrorMessage = "Lost track of the sync job." }; } } diff --git a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor index ed79245..73cc898 100644 --- a/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor +++ b/src/BlazorApp/Components/ReferenceDataAdmin/ReferenceDataAdminPage.razor @@ -41,11 +41,14 @@

- @if (_syncing) - { - - }
+ @if (_syncing) + { +
+
+
+

@SyncStageLabel(_syncStage)

+ } @if (_syncResult is not null) {
@@ -204,17 +207,44 @@ private ReferenceDataImportResultDto? _importResult; private string? _importExportError; + private static readonly TimeSpan SyncPollInterval = TimeSpan.FromMilliseconds(600); + private bool _syncing; private ReferenceSyncResultDto? _syncResult; private string? _syncError; + private ReferenceSyncStage _syncStage; private async Task SyncNowAsync() { _syncing = true; _syncError = null; + _syncResult = null; + _syncStage = ReferenceSyncStage.SyncingTvShows; + try { - _syncResult = await Api.SyncNowAsync(); + var jobId = await Api.StartSyncAsync(); + + while (true) + { + var status = await Api.GetSyncStatusAsync(jobId); + _syncStage = status.Stage; + + if (status.Stage == ReferenceSyncStage.Completed) + { + _syncResult = status.Result; + break; + } + + if (status.Stage == ReferenceSyncStage.Failed) + { + _syncError = status.ErrorMessage ?? "The sync failed."; + break; + } + + StateHasChanged(); + await Task.Delay(SyncPollInterval); + } } catch (Exception ex) { @@ -226,6 +256,28 @@ } } + private static int SyncProgressPercent(ReferenceSyncStage stage) => stage switch + { + ReferenceSyncStage.SyncingTvShows => 15, + ReferenceSyncStage.SyncingMovies => 35, + ReferenceSyncStage.SyncingBooks => 55, + ReferenceSyncStage.SyncingVideoGames => 75, + ReferenceSyncStage.SyncingAlbums => 90, + ReferenceSyncStage.Completed => 100, + _ => 0 + }; + + private static string SyncStageLabel(ReferenceSyncStage stage) => stage switch + { + ReferenceSyncStage.SyncingTvShows => "Checking TV shows…", + ReferenceSyncStage.SyncingMovies => "Checking movies…", + ReferenceSyncStage.SyncingBooks => "Checking books…", + ReferenceSyncStage.SyncingVideoGames => "Checking video games…", + ReferenceSyncStage.SyncingAlbums => "Checking albums…", + ReferenceSyncStage.Completed => "Done", + _ => "" + }; + private async Task ExportAsync() { _exporting = true; diff --git a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index b837f3f..d42cf51 100644 --- a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -17,6 +17,10 @@ internal static void AddWebApiHttpClient(this IServiceCollection services, strin .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) diff --git a/src/BlazorApp/wwwroot/app.css b/src/BlazorApp/wwwroot/app.css index 00a4954..4c08bd3 100644 --- a/src/BlazorApp/wwwroot/app.css +++ b/src/BlazorApp/wwwroot/app.css @@ -474,6 +474,70 @@ button.nav-link:hover { color: var(--kt-danger) !important; background: rgba(199 .kt-inline-toast.danger { background: var(--kt-danger-bg); color: var(--kt-danger); } @keyframes kt-toast-in { from { opacity: 0; transform: translateY(-2px); } to { opacity: 1; transform: translateY(0); } } +/* small "more options" popup anchored under a kt-icon-btn (e.g. a track row's "⋮" menu) - the row it's + anchored to needs position:relative so this absolute box lands directly under the button, not the page. */ +.kt-menu { + position: absolute; + right: 0; + top: 100%; + z-index: 10; + background: var(--kt-surface); + border: 1px solid var(--kt-border); + border-radius: var(--kt-radius-lg); + box-shadow: var(--kt-shadow-lg); + padding: 0.4rem; + min-width: 180px; +} +.kt-menu-item { + display: block; + width: 100%; + text-align: left; + background: transparent; + border: none; + padding: 0.4rem 0.6rem; + border-radius: var(--kt-radius); + color: var(--kt-text); + font-size: 0.85rem; + cursor: pointer; +} +.kt-menu-item:hover { background: var(--kt-surface-3); } + +/* Album/Book/VideoGame detail hero: cover + fields side by side. A fixed grid (not flex-wrap) so the + layout never depends on how much horizontal space the field values happen to need - relying on + flex-wrap's intrinsic-sizing heuristics caused the cover to intermittently land alone on its own row + for some albums (long genre text, etc.) while others stayed side-by-side, with no clear pattern from + the markup alone. */ +.kt-album-hero { + display: grid; + grid-template-columns: 300px minmax(0, 480px); + gap: 1.5rem; + align-items: start; +} +.kt-album-hero.kt-album-hero-no-cover { grid-template-columns: minmax(0, 480px); } +.kt-album-cover { + width: 300px; + height: 300px; + object-fit: cover; + border-radius: var(--kt-radius-lg); +} +@media (max-width: 767px) { + .kt-album-hero, .kt-album-hero.kt-album-hero-no-cover { grid-template-columns: 1fr; } + .kt-album-cover { width: 200px; height: 200px; } +} + +/* compact aligned row for a list of tracks/songs inside a .kt-form-card (e.g. a playlist's song list) - + a CSS grid so title/artist/album line up in columns across rows without resorting to a full + .kt-table-wrap/, which reads as a top-level list page rather than a detail-page sub-section. */ +.kt-track-row { + display: grid; + grid-template-columns: 1fr 180px 180px auto; + align-items: center; + gap: 0.75rem; + padding: 0.55rem 0; + border-top: 1px solid var(--kt-border); +} +.kt-track-row:first-of-type { border-top: none; } + /* ── Form card ─────────────────────────────────────────────────────── */ .kt-form-card { position: relative; diff --git a/src/Domain/Models/AlbumReferenceModel.cs b/src/Domain/Models/AlbumReferenceModel.cs index fa611fc..f4e74ab 100644 --- a/src/Domain/Models/AlbumReferenceModel.cs +++ b/src/Domain/Models/AlbumReferenceModel.cs @@ -38,6 +38,8 @@ public class AlbumReferenceModel : IHasId public List Genres { get; set; } = []; + public List Tracks { get; set; } = []; + public string? ImageUrl { get; set; } public DateTime? LastEnrichedAt { get; set; } diff --git a/src/Domain/Models/PlaylistModel.cs b/src/Domain/Models/PlaylistModel.cs new file mode 100644 index 0000000..bdef6e8 --- /dev/null +++ b/src/Domain/Models/PlaylistModel.cs @@ -0,0 +1,19 @@ +using System.Collections.Generic; +using Keeptrack.Common.System; + +namespace Keeptrack.Domain.Models; + +public class PlaylistModel : IHasIdAndOwnerId +{ + public string? Id { get; set; } + + public required string OwnerId { get; set; } + + public required string Title { get; set; } + + /// + /// Ids of documents, in playback order - the list's own order is the + /// playlist order, there's no separate position field. + /// + public List SongIds { get; set; } = []; +} diff --git a/src/Domain/Models/ReferenceTrackModel.cs b/src/Domain/Models/ReferenceTrackModel.cs new file mode 100644 index 0000000..6c1995b --- /dev/null +++ b/src/Domain/Models/ReferenceTrackModel.cs @@ -0,0 +1,21 @@ +namespace Keeptrack.Domain.Models; + +/// +/// One track's reference metadata (position, title, duration), embedded within an +/// - same embedding rationale as +/// : bounded to one album's real tracklist and always fetched as a whole. +/// +public class ReferenceTrackModel +{ + /// + /// Discogs' own position label - not always numeric (vinyl releases use side+track like "A1"/"B2"). + /// + public required string Position { get; set; } + + public required string Title { get; set; } + + /// + /// Discogs' own "M:SS" text, often absent - carried through as display text, not parsed. + /// + public string? Duration { get; set; } +} diff --git a/src/Domain/Models/SongModel.cs b/src/Domain/Models/SongModel.cs new file mode 100644 index 0000000..9625e7c --- /dev/null +++ b/src/Domain/Models/SongModel.cs @@ -0,0 +1,35 @@ +using Keeptrack.Common.System; + +namespace Keeptrack.Domain.Models; + +public class SongModel : IHasIdAndOwnerId +{ + public string? Id { get; set; } + + public required string OwnerId { get; set; } + + public required string Title { get; set; } + + public string? Artist { get; set; } + + /// + /// Optional link to the tenant's own - a soft reference, like + /// ReferenceId elsewhere in the codebase: no cascade-delete or enforcement if the album is + /// later removed. + /// + public string? AlbumId { get; set; } + + /// + /// Discogs' own "M:SS" text, usually filled in by picking a track from the linked album's reference + /// tracklist (see ) rather than typed by hand. + /// + public string? Duration { get; set; } + + /// + /// The this song was created from - combined with + /// , this is a track-based song's real identity: picking the same track twice + /// must reuse the same , not create a duplicate (see + /// SongApiClient.GetOrCreateForTrackAsync). Null for a song not tied to a specific tracklist entry. + /// + public string? TrackPosition { get; set; } +} diff --git a/src/Domain/Repositories/IPlaylistRepository.cs b/src/Domain/Repositories/IPlaylistRepository.cs new file mode 100644 index 0000000..bc8b96e --- /dev/null +++ b/src/Domain/Repositories/IPlaylistRepository.cs @@ -0,0 +1,7 @@ +using Keeptrack.Domain.Models; + +namespace Keeptrack.Domain.Repositories; + +public interface IPlaylistRepository : IDataRepository +{ +} diff --git a/src/Domain/Repositories/ISongRepository.cs b/src/Domain/Repositories/ISongRepository.cs new file mode 100644 index 0000000..addb72e --- /dev/null +++ b/src/Domain/Repositories/ISongRepository.cs @@ -0,0 +1,7 @@ +using Keeptrack.Domain.Models; + +namespace Keeptrack.Domain.Repositories; + +public interface ISongRepository : IDataRepository +{ +} diff --git a/src/Infrastructure.MongoDb/Entities/AlbumReference.cs b/src/Infrastructure.MongoDb/Entities/AlbumReference.cs index a19ac83..40e8b69 100644 --- a/src/Infrastructure.MongoDb/Entities/AlbumReference.cs +++ b/src/Infrastructure.MongoDb/Entities/AlbumReference.cs @@ -35,6 +35,8 @@ public class AlbumReference public List Genres { get; set; } = []; + public List Tracks { get; set; } = []; + [BsonElement("image_url")] public string? ImageUrl { get; set; } diff --git a/src/Infrastructure.MongoDb/Entities/Playlist.cs b/src/Infrastructure.MongoDb/Entities/Playlist.cs new file mode 100644 index 0000000..d395c58 --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/Playlist.cs @@ -0,0 +1,21 @@ +using System.Collections.Generic; +using Keeptrack.Common.System; +using MongoDB.Bson; +using MongoDB.Bson.Serialization.Attributes; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +public class Playlist : IHasIdAndOwnerId +{ + [BsonId] + [BsonRepresentation(BsonType.ObjectId)] + public string? Id { get; set; } + + [BsonElement("owner_id")] + public required string OwnerId { get; set; } + + public required string Title { get; set; } + + [BsonElement("song_ids")] + public List SongIds { get; set; } = []; +} diff --git a/src/Infrastructure.MongoDb/Entities/ReferenceTrack.cs b/src/Infrastructure.MongoDb/Entities/ReferenceTrack.cs new file mode 100644 index 0000000..3dc2705 --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/ReferenceTrack.cs @@ -0,0 +1,13 @@ +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +/// +/// Embedded within - see that class for why embedding is the right call here. +/// +public class ReferenceTrack +{ + public required string Position { get; set; } + + public required string Title { get; set; } + + public string? Duration { get; set; } +} diff --git a/src/Infrastructure.MongoDb/Entities/Song.cs b/src/Infrastructure.MongoDb/Entities/Song.cs new file mode 100644 index 0000000..cf8c7fe --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/Song.cs @@ -0,0 +1,27 @@ +using Keeptrack.Common.System; +using MongoDB.Bson; +using MongoDB.Bson.Serialization.Attributes; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +public class Song : IHasIdAndOwnerId +{ + [BsonId] + [BsonRepresentation(BsonType.ObjectId)] + public string? Id { get; set; } + + [BsonElement("owner_id")] + public required string OwnerId { get; set; } + + public required string Title { get; set; } + + public string? Artist { get; set; } + + [BsonElement("album_id")] + public string? AlbumId { get; set; } + + public string? Duration { get; set; } + + [BsonElement("track_position")] + public string? TrackPosition { get; set; } +} diff --git a/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs b/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs new file mode 100644 index 0000000..3d22473 --- /dev/null +++ b/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs @@ -0,0 +1,22 @@ +using AutoMapper; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Microsoft.Extensions.Logging; +using MongoDB.Driver; + +namespace Keeptrack.Infrastructure.MongoDb.Repositories; + +public class PlaylistRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) + : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IPlaylistRepository +{ + protected override string CollectionName => "playlist"; + + protected override FilterDefinition GetFilter(string ownerId, string? search, PlaylistModel input) + { + var builder = Builders.Filter; + var filter = builder.Eq(f => f.OwnerId, ownerId); + if (!string.IsNullOrEmpty(search)) filter &= builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + return filter; + } +} diff --git a/src/Infrastructure.MongoDb/Repositories/SongRepository.cs b/src/Infrastructure.MongoDb/Repositories/SongRepository.cs new file mode 100644 index 0000000..0db21b4 --- /dev/null +++ b/src/Infrastructure.MongoDb/Repositories/SongRepository.cs @@ -0,0 +1,30 @@ +using AutoMapper; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Microsoft.Extensions.Logging; +using MongoDB.Driver; + +namespace Keeptrack.Infrastructure.MongoDb.Repositories; + +public class SongRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) + : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ISongRepository +{ + protected override string CollectionName => "song"; + + protected override FilterDefinition GetFilter(string ownerId, string? search, SongModel input) + { + var builder = Builders.Filter; + var filter = builder.Eq(f => f.OwnerId, ownerId); + if (!string.IsNullOrEmpty(search)) + { + filter &= builder.Where(f => f.Title.Contains(search, System.StringComparison.CurrentCultureIgnoreCase) + || (f.Artist != null && f.Artist.Contains(search, System.StringComparison.CurrentCultureIgnoreCase))); + } + + if (!string.IsNullOrEmpty(input.AlbumId)) filter &= builder.Eq(f => f.AlbumId, input.AlbumId); + if (!string.IsNullOrEmpty(input.TrackPosition)) filter &= builder.Eq(f => f.TrackPosition, input.TrackPosition); + + return filter; + } +} diff --git a/src/WebApi.Contracts/Dto/AlbumReferenceDto.cs b/src/WebApi.Contracts/Dto/AlbumReferenceDto.cs index a1d392e..71ab313 100644 --- a/src/WebApi.Contracts/Dto/AlbumReferenceDto.cs +++ b/src/WebApi.Contracts/Dto/AlbumReferenceDto.cs @@ -23,5 +23,7 @@ public class AlbumReferenceDto : IHasId public List Genres { get; set; } = []; + public List Tracks { get; set; } = []; + public string? ImageUrl { get; set; } } diff --git a/src/WebApi.Contracts/Dto/PlaylistDto.cs b/src/WebApi.Contracts/Dto/PlaylistDto.cs new file mode 100644 index 0000000..8e49b86 --- /dev/null +++ b/src/WebApi.Contracts/Dto/PlaylistDto.cs @@ -0,0 +1,25 @@ +using System.Collections.Generic; +using Keeptrack.Common.System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Playlist data transfer object. +/// +public class PlaylistDto : IHasId +{ + /// + /// Playlist ID. + /// + public string? Id { get; set; } + + /// + /// Playlist title. + /// + public string? Title { get; set; } + + /// + /// Ids of the songs in this playlist, in playback order. + /// + public List SongIds { get; set; } = []; +} diff --git a/src/WebApi.Contracts/Dto/ReferenceSyncJobDto.cs b/src/WebApi.Contracts/Dto/ReferenceSyncJobDto.cs new file mode 100644 index 0000000..b8b837d --- /dev/null +++ b/src/WebApi.Contracts/Dto/ReferenceSyncJobDto.cs @@ -0,0 +1,39 @@ +using System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Stage of an in-progress reference-data sync, reported back to the client so it can show real progress +/// instead of a single opaque "syncing..." spinner. +/// +public enum ReferenceSyncStage +{ + SyncingTvShows, + SyncingMovies, + SyncingBooks, + SyncingVideoGames, + SyncingAlbums, + Completed, + Failed +} + +/// +/// Returned immediately when a sync is started; poll at +/// GET /api/reference-data/sync-now/{JobId} for progress. +/// +public class ReferenceSyncJobDto +{ + public required Guid JobId { get; set; } +} + +/// +/// Current status of a reference-data sync job. +/// +public class ReferenceSyncJobStatusDto +{ + public required ReferenceSyncStage Stage { get; set; } + + public ReferenceSyncResultDto? Result { get; set; } + + public string? ErrorMessage { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/ReferenceTrackDto.cs b/src/WebApi.Contracts/Dto/ReferenceTrackDto.cs new file mode 100644 index 0000000..9dd5cd8 --- /dev/null +++ b/src/WebApi.Contracts/Dto/ReferenceTrackDto.cs @@ -0,0 +1,13 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// One track's reference metadata (position, title, duration) from the shared reference collection. +/// +public class ReferenceTrackDto +{ + public required string Position { get; set; } + + public required string Title { get; set; } + + public string? Duration { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/SongDto.cs b/src/WebApi.Contracts/Dto/SongDto.cs new file mode 100644 index 0000000..c4f5fd6 --- /dev/null +++ b/src/WebApi.Contracts/Dto/SongDto.cs @@ -0,0 +1,36 @@ +using Keeptrack.Common.System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Song data transfer object. +/// +public class SongDto : IHasId +{ + /// + /// Song ID. + /// + public string? Id { get; set; } + + /// + /// Song title. + /// + public string? Title { get; set; } + + public string? Artist { get; set; } + + /// + /// Id of the linked Album this song is from, if any - the tenant's own tracked album, not + /// external reference-data. + /// + public string? AlbumId { get; set; } + + public string? Duration { get; set; } + + /// + /// The reference tracklist position this song was created from - combined with , + /// lets the client look up (and reuse) the song already created for a given album track instead of + /// creating a duplicate. + /// + public string? TrackPosition { get; set; } +} diff --git a/src/WebApi/Controllers/PlaylistController.cs b/src/WebApi/Controllers/PlaylistController.cs new file mode 100644 index 0000000..71a0b90 --- /dev/null +++ b/src/WebApi/Controllers/PlaylistController.cs @@ -0,0 +1,12 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Controllers; + +[ApiController] +[Authorize] +[Route("api/playlists")] +public class PlaylistController(IMapper mapper, IPlaylistRepository dataRepository) + : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/Controllers/SongController.cs b/src/WebApi/Controllers/SongController.cs new file mode 100644 index 0000000..7d4978a --- /dev/null +++ b/src/WebApi/Controllers/SongController.cs @@ -0,0 +1,12 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Controllers; + +[ApiController] +[Authorize] +[Route("api/songs")] +public class SongController(IMapper mapper, ISongRepository dataRepository) + : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index 9a701de..8a9133e 100644 --- a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -26,6 +26,8 @@ internal static void AddMongoDbInfrastructure(this IServiceCollection services, sp.GetRequiredService().GetDatabase(configuration.DatabaseName)); services.TryAddScoped(); + services.TryAddScoped(); + services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); diff --git a/src/WebApi/Import/ImportJobStore.cs b/src/WebApi/Import/ImportJobStore.cs deleted file mode 100644 index 88ebfef..0000000 --- a/src/WebApi/Import/ImportJobStore.cs +++ /dev/null @@ -1,68 +0,0 @@ -using System; -using System.Collections.Concurrent; -using Keeptrack.WebApi.Contracts.Dto; - -namespace Keeptrack.WebApi.Import; - -/// -/// Tracks the progress of background import jobs so the client can poll for real status instead of -/// waiting on a single opaque request. In-memory only - fine for a personal, occasional import feature, -/// and means jobs don't survive an app restart, which is an acceptable trade-off here. -/// -public class ImportJobStore -{ - private readonly ConcurrentDictionary _jobs = new(); - - public Guid Create(string ownerId) - { - var jobId = Guid.NewGuid(); - _jobs[jobId] = new Job(ownerId); - return jobId; - } - - public void UpdateStage(Guid jobId, ImportStage stage) - { - if (_jobs.TryGetValue(jobId, out var job)) job.Stage = stage; - } - - public void Complete(Guid jobId, ImportResultDto result) - { - if (!_jobs.TryGetValue(jobId, out var job)) return; - job.Stage = ImportStage.Completed; - job.Result = result; - } - - public void Fail(Guid jobId, string errorMessage) - { - if (!_jobs.TryGetValue(jobId, out var job)) return; - job.Stage = ImportStage.Failed; - job.ErrorMessage = errorMessage; - } - - /// - /// Returns null if the job doesn't exist or wasn't created by this owner - a caller can never - /// observe another user's import job, even by guessing a job id. - /// - public ImportJobStatusDto? GetStatus(Guid jobId, string ownerId) - { - if (!_jobs.TryGetValue(jobId, out var job) || job.OwnerId != ownerId) return null; - - return new ImportJobStatusDto - { - Stage = job.Stage, - Result = job.Result, - ErrorMessage = job.ErrorMessage - }; - } - - private sealed class Job(string ownerId) - { - public string OwnerId { get; } = ownerId; - - public ImportStage Stage { get; set; } = ImportStage.Parsing; - - public ImportResultDto? Result { get; set; } - - public string? ErrorMessage { get; set; } - } -} diff --git a/src/WebApi/Import/TvTimeImportController.cs b/src/WebApi/Import/TvTimeImportController.cs index fd7cad5..fb882e3 100644 --- a/src/WebApi/Import/TvTimeImportController.cs +++ b/src/WebApi/Import/TvTimeImportController.cs @@ -3,6 +3,7 @@ using System.Threading.Tasks; using Keeptrack.WebApi.Contracts.Dto; using Keeptrack.WebApi.Controllers; +using Keeptrack.WebApi.Jobs; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; using Microsoft.Extensions.DependencyInjection; @@ -12,7 +13,7 @@ namespace Keeptrack.WebApi.Import; [ApiController] [Authorize] [Route("api/import")] -public class TvTimeImportController(ImportJobStore jobStore, IServiceScopeFactory scopeFactory) : ControllerBase +public class TvTimeImportController(JobStore jobStore, IServiceScopeFactory scopeFactory) : ControllerBase { /// /// Starts importing a TV Time GDPR export (the zip you get from TV Time's "Download my data" request) @@ -40,7 +41,7 @@ public async Task> ImportTvTime(IFormFile file) buffer.Position = 0; var ownerId = this.GetUserId(); - var jobId = jobStore.Create(ownerId); + var jobId = jobStore.Create(ownerId, ImportStage.Parsing); _ = RunImportJobAsync(jobId, buffer, ownerId); @@ -56,7 +57,9 @@ public async Task> ImportTvTime(IFormFile file) public ActionResult GetStatus(Guid jobId) { var status = jobStore.GetStatus(jobId, this.GetUserId()); - return status is null ? NotFound() : Ok(status); + if (status is null) return NotFound(); + + return Ok(new ImportJobStatusDto { Stage = status.Value.Stage, Result = status.Value.Result, ErrorMessage = status.Value.ErrorMessage }); } /// @@ -73,11 +76,11 @@ private async Task RunImportJobAsync(Guid jobId, MemoryStream buffer, string own try { var result = await importService.ImportAsync(buffer, ownerId, stage => jobStore.UpdateStage(jobId, stage)); - jobStore.Complete(jobId, result); + jobStore.Complete(jobId, ImportStage.Completed, result); } catch (Exception ex) { - jobStore.Fail(jobId, ex.Message); + jobStore.Fail(jobId, ImportStage.Failed, ex.Message); } } } diff --git a/src/WebApi/Jobs/JobStore.cs b/src/WebApi/Jobs/JobStore.cs new file mode 100644 index 0000000..3d60250 --- /dev/null +++ b/src/WebApi/Jobs/JobStore.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections.Concurrent; + +namespace Keeptrack.WebApi.Jobs; + +/// +/// Tracks the progress of a background job so the client can poll for real status instead of waiting on +/// a single opaque request - shared by every feature with a long-running admin/user-triggered action +/// (TV Time import, reference-data "sync now"), parameterized by that feature's own stage enum and result +/// DTO rather than duplicated per feature. In-memory only - fine for occasional, personal-scale actions; +/// jobs don't survive an app restart, an acceptable trade-off here. +/// +public class JobStore +{ + private readonly ConcurrentDictionary _jobs = new(); + + public Guid Create(string ownerId, TStage initialStage) + { + var jobId = Guid.NewGuid(); + _jobs[jobId] = new Job(ownerId, initialStage); + return jobId; + } + + public void UpdateStage(Guid jobId, TStage stage) + { + if (_jobs.TryGetValue(jobId, out var job)) job.Stage = stage; + } + + public void Complete(Guid jobId, TStage completedStage, TResult result) + { + if (!_jobs.TryGetValue(jobId, out var job)) return; + job.Stage = completedStage; + job.Result = result; + } + + public void Fail(Guid jobId, TStage failedStage, string errorMessage) + { + if (!_jobs.TryGetValue(jobId, out var job)) return; + job.Stage = failedStage; + job.ErrorMessage = errorMessage; + } + + /// + /// Returns null if the job doesn't exist or wasn't created by this owner - a caller can never observe + /// another user's job, even by guessing a job id. + /// + public (TStage Stage, TResult? Result, string? ErrorMessage)? GetStatus(Guid jobId, string ownerId) + { + if (!_jobs.TryGetValue(jobId, out var job) || job.OwnerId != ownerId) return null; + + return (job.Stage, job.Result, job.ErrorMessage); + } + + private sealed class Job(string ownerId, TStage stage) + { + public string OwnerId { get; } = ownerId; + + public TStage Stage { get; set; } = stage; + + public TResult? Result { get; set; } + + public string? ErrorMessage { get; set; } + } +} diff --git a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs index e7820fb..2df2541 100644 --- a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs +++ b/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs @@ -24,6 +24,12 @@ public DataStorageMappingProfile() CreateMap(); CreateMap(); + CreateMap(); + CreateMap(); + + CreateMap(); + CreateMap(); + CreateMap() .ForMember(x => x.Platform, opt => opt.Ignore()) .ForMember(x => x.State, opt => opt.Ignore()); @@ -38,6 +44,9 @@ public DataStorageMappingProfile() CreateMap(); CreateMap(); + CreateMap(); + CreateMap(); + CreateMap(); // Creator has no creator dimension for TV show/movie/video game (always null there) - overriding diff --git a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs index cc7efe9..d31feb1 100644 --- a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs +++ b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs @@ -37,6 +37,14 @@ public WebServiceMappingProfile() .ForMember(x => x.OwnerId, opt => opt.Ignore()); CreateMap(); + CreateMap() + .ForMember(x => x.OwnerId, opt => opt.Ignore()); + CreateMap(); + + CreateMap() + .ForMember(x => x.OwnerId, opt => opt.Ignore()); + CreateMap(); + CreateMap() .ForMember(x => x.OwnerId, opt => opt.Ignore()); CreateMap(); @@ -54,6 +62,7 @@ public WebServiceMappingProfile() // Reference-data reads are one-directional (Model -> Dto): admins submit a LinkReferenceRequestDto, // never a full TvShowReferenceDto/MovieReferenceDto, so there's no Dto -> Model direction to map. CreateMap(); + CreateMap(); // Cast is ignored here and hydrated manually by ReferenceDataController: CastMemberModel only // carries a PersonReferenceId, while CastMemberDto needs the person's name/photo joined in from diff --git a/src/WebApi/Program.cs b/src/WebApi/Program.cs index cc902aa..e56320a 100644 --- a/src/WebApi/Program.cs +++ b/src/WebApi/Program.cs @@ -21,12 +21,20 @@ opts.BackgroundServiceExceptionBehavior = Microsoft.Extensions.Hosting.BackgroundServiceExceptionBehavior.Ignore); builder.Services.AddSingleton(); builder.Services.AddSingleton(); -builder.Services.AddSingleton(); +builder.Services.AddSingleton>(); +builder.Services.AddSingleton>(); builder.Services.AddScoped(); builder.Services.AddSingleton(configuration.TmdbSettings); builder.Services.AddHttpClient(client => { client.BaseAddress = new Uri("https://api.themoviedb.org/3/"); + // AddStandardResilienceHandler's own TotalRequestTimeout (30s default) is meant to be the real bound + // on a call - but HttpClient's own Timeout (100s default, never otherwise touched here) wraps the + // whole pipeline including every retry, and silently wins whenever it's shorter than however long the + // resilience pipeline actually takes to give up. Disabling it lets the resilience handler's own + // timeout be authoritative instead of a stuck call hanging for a full 100s - see + // https://github.com/dotnet/extensions/issues/4770 (confirmed against this exact symptom on Discogs). + client.Timeout = Timeout.InfiniteTimeSpan; }).AddStandardResilienceHandler(); // which IBookReferenceClient implementation is registered is a deployment-time choice // (ReferenceData:BookProvider / ReferenceData__BookProvider) - add a case here for each new provider. @@ -37,6 +45,7 @@ { client.BaseAddress = new Uri("https://openlibrary.org/"); client.DefaultRequestHeaders.Add("User-Agent", "Keeptrack/1.0 (+https://github.com/devpro/keeptrack)"); + client.Timeout = Timeout.InfiniteTimeSpan; }).AddStandardResilienceHandler(); break; default: @@ -46,12 +55,14 @@ builder.Services.AddHttpClient(client => { client.BaseAddress = new Uri("https://api.rawg.io/api/"); + client.Timeout = Timeout.InfiniteTimeSpan; }).AddStandardResilienceHandler(); builder.Services.AddSingleton(configuration.DiscogsSettings); builder.Services.AddHttpClient(client => { client.BaseAddress = new Uri("https://api.discogs.com/"); client.DefaultRequestHeaders.Add("User-Agent", "Keeptrack/1.0 (+https://github.com/devpro/keeptrack)"); + client.Timeout = Timeout.InfiniteTimeSpan; }).AddStandardResilienceHandler(); builder.Services.AddScoped(); builder.Services.AddScoped(); diff --git a/src/WebApi/ReferenceData/DiscogsClient.cs b/src/WebApi/ReferenceData/DiscogsClient.cs index a676582..f1cdc36 100644 --- a/src/WebApi/ReferenceData/DiscogsClient.cs +++ b/src/WebApi/ReferenceData/DiscogsClient.cs @@ -56,10 +56,14 @@ private async Task> SearchAlbumsCoreAsync(str var genres = details.Genres.Concat(details.Styles).ToList(); var image = details.Images.FirstOrDefault()?.Uri; var primaryArtist = details.Artists.FirstOrDefault(); + var tracks = details.Tracklist + .Where(t => t.Type == "track") + .Select(t => new DiscogsTrack(t.Position ?? "", t.Title ?? "", t.Duration)) + .ToList(); return new DiscogsAlbumDetails( externalId, details.Title ?? string.Empty, details.Year, details.Notes, - primaryArtist?.Name, primaryArtist?.Id.ToString(System.Globalization.CultureInfo.InvariantCulture), genres, image); + primaryArtist?.Name, primaryArtist?.Id.ToString(System.Globalization.CultureInfo.InvariantCulture), genres, image, tracks); } private string Token => settings.Token; @@ -124,6 +128,28 @@ private sealed class DiscogsMasterResponse [JsonPropertyName("artists")] public List Artists { get; set; } = []; + + [JsonPropertyName("tracklist")] + public List Tracklist { get; set; } = []; + } + + /// + /// type_ distinguishes an actual track from a section heading some multi-part releases use + /// (e.g. "index") - only entries with type_ == "track" are real songs. + /// + private sealed class DiscogsTracklistItem + { + [JsonPropertyName("position")] + public string? Position { get; set; } + + [JsonPropertyName("type_")] + public string? Type { get; set; } + + [JsonPropertyName("title")] + public string? Title { get; set; } + + [JsonPropertyName("duration")] + public string? Duration { get; set; } } private sealed class DiscogsImage diff --git a/src/WebApi/ReferenceData/IDiscogsClient.cs b/src/WebApi/ReferenceData/IDiscogsClient.cs index 50b2bdf..9a473a4 100644 --- a/src/WebApi/ReferenceData/IDiscogsClient.cs +++ b/src/WebApi/ReferenceData/IDiscogsClient.cs @@ -10,7 +10,14 @@ namespace Keeptrack.WebApi.ReferenceData; /// public record DiscogsSearchResult(string ExternalId, string Title, int? Year, string? Artist, string? ImageUrl); -public record DiscogsAlbumDetails(string ExternalId, string Title, int? Year, string? Synopsis, string? Artist, string? ArtistExternalId, List Genres, string? ImageUrl); +public record DiscogsAlbumDetails(string ExternalId, string Title, int? Year, string? Synopsis, string? Artist, string? ArtistExternalId, List Genres, string? ImageUrl, List Tracks); + +/// +/// One tracklist entry from Discogs' /masters/{id} response - isn't +/// always numeric (vinyl releases use side+track like "A1"/"B2"), and is +/// Discogs' own "M:SS" text, often absent. +/// +public record DiscogsTrack(string Position, string Title, string? Duration); /// /// Thin wrapper over the Discogs REST API. Interface exists so tests use a fake - never call the real diff --git a/src/WebApi/ReferenceData/ReferenceDataAdminController.cs b/src/WebApi/ReferenceData/ReferenceDataAdminController.cs index ef0cfba..3860ba9 100644 --- a/src/WebApi/ReferenceData/ReferenceDataAdminController.cs +++ b/src/WebApi/ReferenceData/ReferenceDataAdminController.cs @@ -9,8 +9,11 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.Controllers; +using Keeptrack.WebApi.Jobs; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; +using Microsoft.Extensions.DependencyInjection; namespace Keeptrack.WebApi.ReferenceData; @@ -33,7 +36,8 @@ public class ReferenceDataAdminController( IRawgClient rawgClient, IDiscogsClient discogsClient, ReferenceEnrichmentService enrichmentService, - ReferenceSyncService syncService, + JobStore syncJobStore, + IServiceScopeFactory scopeFactory, ITvShowReferenceRepository tvShowReferenceRepository, IMovieReferenceRepository movieReferenceRepository, IPersonReferenceRepository personReferenceRepository, @@ -165,14 +169,57 @@ private static async Task> ReadJsonEntryAsync(ZipArchive archive, str } /// - /// Forces an immediate re-check of every reference document, regardless of how recently it was last + /// Starts an immediate re-check of every reference document, regardless of how recently it was last /// enriched - the same logic the periodic background sync runs on a schedule (see - /// ), just triggered on demand instead of waiting. + /// ), just triggered on demand instead of waiting. Runs in + /// the background; poll with the returned job id for progress - a full + /// re-check across five domains can easily exceed a single request/response's own timeout. /// [HttpPost("sync-now")] + [ProducesResponseType(202)] + public ActionResult SyncNow() + { + var jobId = syncJobStore.Create(this.GetUserId(), ReferenceSyncStage.SyncingTvShows); + + _ = RunSyncJobAsync(jobId); + + return Accepted(new ReferenceSyncJobDto { JobId = jobId }); + } + + /// + /// Current status of a previously started sync job. + /// + [HttpGet("sync-now/{jobId:guid}")] [ProducesResponseType(200)] - public async Task> SyncNow(CancellationToken cancellationToken) => - Ok(await syncService.SyncStaleReferencesAsync(TimeSpan.Zero, cancellationToken)); + [ProducesResponseType(404)] + public ActionResult GetSyncStatus(Guid jobId) + { + var status = syncJobStore.GetStatus(jobId, this.GetUserId()); + if (status is null) return NotFound(); + + return Ok(new ReferenceSyncJobStatusDto { Stage = status.Value.Stage, Result = status.Value.Result, ErrorMessage = status.Value.ErrorMessage }); + } + + /// + /// Runs the sync on a background task using its own DI scope - the request that started it has + /// already completed by the time this runs, so it can't reuse the request's scoped + /// instance. + /// + private async Task RunSyncJobAsync(Guid jobId) + { + using var scope = scopeFactory.CreateScope(); + var scopedSyncService = scope.ServiceProvider.GetRequiredService(); + + try + { + var result = await scopedSyncService.SyncStaleReferencesAsync(TimeSpan.Zero, stage => syncJobStore.UpdateStage(jobId, stage)); + syncJobStore.Complete(jobId, ReferenceSyncStage.Completed, result); + } + catch (Exception ex) + { + syncJobStore.Fail(jobId, ReferenceSyncStage.Failed, ex.Message); + } + } /// /// Distinct (title, year) pairs, across every tenant, still missing a reference-data link. diff --git a/src/WebApi/ReferenceData/ReferenceEnrichmentService.Albums.cs b/src/WebApi/ReferenceData/ReferenceEnrichmentService.Albums.cs index 1eb691f..4d40c58 100644 --- a/src/WebApi/ReferenceData/ReferenceEnrichmentService.Albums.cs +++ b/src/WebApi/ReferenceData/ReferenceEnrichmentService.Albums.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Linq; using System.Threading; using System.Threading.Tasks; using Keeptrack.Common.System; @@ -92,6 +93,7 @@ public async Task ResolveAlbumAsync(string title, int? year ExternalIds = externalIds, MatchedAliases = MergeMatchedAliases(existing?.MatchedAliases, (details.Title, details.Year ?? year, details.Artist), (title, year, details.Artist)), Genres = details.Genres, + Tracks = MapTracks(details.Tracks), ImageUrl = details.ImageUrl, LastEnrichedAt = DateTime.UtcNow }; @@ -123,10 +125,14 @@ public async Task ResolveAlbumAsync(string title, int? year reference.ArtistReferenceId = await ResolvePersonReferenceIdAsync("discogs", details.ArtistExternalId, details.Artist ?? "Unknown", null); } reference.Genres = details.Genres; + reference.Tracks = MapTracks(details.Tracks); reference.ImageUrl = details.ImageUrl ?? reference.ImageUrl; reference.MatchedAliases = MergeMatchedAliases(reference.MatchedAliases, (details.Title, reference.Year, details.Artist)); reference.LastEnrichedAt = DateTime.UtcNow; return (await albumReferenceRepository.UpsertAsync(reference), true); } + + private static List MapTracks(List tracks) => + tracks.Select(t => new ReferenceTrackModel { Position = t.Position, Title = t.Title, Duration = t.Duration }).ToList(); } diff --git a/src/WebApi/ReferenceData/ReferenceSyncBackgroundService.cs b/src/WebApi/ReferenceData/ReferenceSyncBackgroundService.cs index f9eb2fa..e87a7c2 100644 --- a/src/WebApi/ReferenceData/ReferenceSyncBackgroundService.cs +++ b/src/WebApi/ReferenceData/ReferenceSyncBackgroundService.cs @@ -36,7 +36,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken) { using var scope = scopeFactory.CreateScope(); var syncService = scope.ServiceProvider.GetRequiredService(); - var result = await syncService.SyncStaleReferencesAsync(StaleAfter, stoppingToken); + var result = await syncService.SyncStaleReferencesAsync(StaleAfter, cancellationToken: stoppingToken); logger.LogInformation( "Reference sync: {TvShowsChecked} TV show(s) checked ({TvShowsUpdated} updated), {MoviesChecked} movie(s) checked ({MoviesUpdated} updated).", result.TvShowsChecked, result.TvShowsUpdated, result.MoviesChecked, result.MoviesUpdated); diff --git a/src/WebApi/ReferenceData/ReferenceSyncService.cs b/src/WebApi/ReferenceData/ReferenceSyncService.cs index 5fcf9b0..d97fd5a 100644 --- a/src/WebApi/ReferenceData/ReferenceSyncService.cs +++ b/src/WebApi/ReferenceData/ReferenceSyncService.cs @@ -27,11 +27,12 @@ public class ReferenceSyncService( /// (or unset). A failure on one document is logged and skipped rather than aborting the whole run - one /// bad TMDB response shouldn't block every other show/movie from being checked. /// - public async Task SyncStaleReferencesAsync(TimeSpan staleAfter, CancellationToken cancellationToken = default) + public async Task SyncStaleReferencesAsync(TimeSpan staleAfter, Action? onStageChanged = null, CancellationToken cancellationToken = default) { var cutoff = DateTime.UtcNow - staleAfter; var result = new ReferenceSyncResultDto(); + onStageChanged?.Invoke(ReferenceSyncStage.SyncingTvShows); foreach (var reference in await tvShowReferenceRepository.FindAllAsync()) { if (reference.LastEnrichedAt is not null && reference.LastEnrichedAt > cutoff) continue; @@ -48,6 +49,7 @@ public async Task SyncStaleReferencesAsync(TimeSpan stal } } + onStageChanged?.Invoke(ReferenceSyncStage.SyncingMovies); foreach (var reference in await movieReferenceRepository.FindAllAsync()) { if (reference.LastEnrichedAt is not null && reference.LastEnrichedAt > cutoff) continue; @@ -64,6 +66,7 @@ public async Task SyncStaleReferencesAsync(TimeSpan stal } } + onStageChanged?.Invoke(ReferenceSyncStage.SyncingBooks); foreach (var reference in await bookReferenceRepository.FindAllAsync()) { if (reference.LastEnrichedAt is not null && reference.LastEnrichedAt > cutoff) continue; @@ -80,6 +83,7 @@ public async Task SyncStaleReferencesAsync(TimeSpan stal } } + onStageChanged?.Invoke(ReferenceSyncStage.SyncingVideoGames); foreach (var reference in await videoGameReferenceRepository.FindAllAsync()) { if (reference.LastEnrichedAt is not null && reference.LastEnrichedAt > cutoff) continue; @@ -96,6 +100,7 @@ public async Task SyncStaleReferencesAsync(TimeSpan stal } } + onStageChanged?.Invoke(ReferenceSyncStage.SyncingAlbums); foreach (var reference in await albumReferenceRepository.FindAllAsync()) { if (reference.LastEnrichedAt is not null && reference.LastEnrichedAt > cutoff) continue; diff --git a/test/WebApi.IntegrationTests/Resources/PlaylistResourceTest.cs b/test/WebApi.IntegrationTests/Resources/PlaylistResourceTest.cs new file mode 100644 index 0000000..e530d8e --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/PlaylistResourceTest.cs @@ -0,0 +1,85 @@ +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Bogus; +using Keeptrack.Common.System; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Basic full-cycle CRUD coverage for Playlist, same shape as , +/// plus a check that round-trips its order through a PUT - this is the +/// field that actually encodes playback order, so a bug here would silently scramble every playlist. +/// +public class PlaylistResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + private const string ResourceEndpoint = "api/playlists"; + + [Fact] + public async Task PlaylistResourceFullCycle_IsOk() + { + await GetAsync($"/{ResourceEndpoint}", HttpStatusCode.Unauthorized); + + await Authenticate(); + + var initialItems = await GetAsync>($"/{ResourceEndpoint}"); + + var input = new Faker() + .Rules((f, o) => { o.Title = f.Random.AlphaNumeric(14); }) + .Generate(); + var created = await PostAsync($"/{ResourceEndpoint}", input); + created.Id.Should().NotBeNullOrEmpty(); + + try + { + created.Title = "New shiny title"; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + updated.Should().BeEquivalentTo(created); + + var finalItems = await GetAsync>($"/{ResourceEndpoint}"); + finalItems.TotalCount.Should().BeGreaterThan(initialItems.TotalCount); + var firstItem = finalItems.Items.FirstOrDefault(x => x.Id == updated.Id); + firstItem.Should().NotBeNull(); + firstItem.Title.Should().Be(updated.Title); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + [Fact] + public async Task PlaylistResourceUpdate_PersistsSongIdsInOrder_IsOk() + { + await Authenticate(); + + var created = await PostAsync($"/{ResourceEndpoint}", new PlaylistDto { Title = "Order Test Playlist" }); + + try + { + created.SongIds = ["song-c", "song-a", "song-b"]; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + updated.SongIds.Should().ContainInOrder("song-c", "song-a", "song-b"); + + created.SongIds = ["song-a", "song-b"]; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var afterRemoval = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + afterRemoval.SongIds.Should().ContainInOrder("song-a", "song-b"); + afterRemoval.SongIds.Should().HaveCount(2); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } +} diff --git a/test/WebApi.IntegrationTests/Resources/ReferenceDataAdminResourceTest.cs b/test/WebApi.IntegrationTests/Resources/ReferenceDataAdminResourceTest.cs index 258d78f..3a91d01 100644 --- a/test/WebApi.IntegrationTests/Resources/ReferenceDataAdminResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/ReferenceDataAdminResourceTest.cs @@ -1,22 +1,67 @@ +using System; +using System.Collections.Generic; using System.Net; using System.Threading.Tasks; +using AwesomeAssertions; +using Keeptrack.WebApi.Contracts.Dto; using Keeptrack.WebApi.IntegrationTests.Hosting; using Xunit; namespace Keeptrack.WebApi.IntegrationTests.Resources; +/// +/// The standard test user carries the Firebase role: admin custom claim (see CONTRIBUTING.md's +/// "Admin role" section), so admin-gated endpoints can be exercised end-to-end over HTTP with the same +/// single test account - there's no separate non-admin account to prove the "AdminOnly" policy actually +/// rejects a non-admin caller. +/// public class ReferenceDataAdminResourceTest(KestrelWebAppFactory factory) : ResourceTestBase(factory) { + private static readonly TimeSpan PollTimeout = TimeSpan.FromMinutes(2); + private static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(500); + + [Fact] + public async Task GetUnresolved_WithAdminRole_IsOk() + { + await Authenticate(); + + await GetAsync>("/api/reference-data/unresolved?type=TvShow"); + } + /// - /// The standard test user has no "role" claim, so the "AdminOnly" policy must reject it - ASP.NET - /// Core returns 403 (not 401) for an authenticated caller that fails a policy check. + /// Exercises the full "sync now" background job lifecycle over HTTP: POST starts the job and returns + /// immediately (202 + job id) rather than blocking on every reference document, then polling GET + /// reaches a terminal stage with a result - the actual fix for the timeout reported against this + /// endpoint (see docs/code-quality-findings.md). /// [Fact] - public async Task GetUnresolved_WithoutAdminRole_IsForbidden() + public async Task SyncNow_StartsAJob_AndPollingReachesACompletedResult() + { + await Authenticate(); + + var job = await PostAsync("/api/reference-data/sync-now", null, HttpStatusCode.Accepted); + job.Should().NotBeNull(); + job!.JobId.Should().NotBeEmpty(); + + var deadline = DateTime.UtcNow + PollTimeout; + ReferenceSyncJobStatusDto status; + do + { + status = await GetAsync($"/api/reference-data/sync-now/{job.JobId}"); + if (status.Stage is ReferenceSyncStage.Completed or ReferenceSyncStage.Failed) break; + await Task.Delay(PollInterval, TestContext.Current.CancellationToken); + } while (DateTime.UtcNow < deadline); + + status.Stage.Should().Be(ReferenceSyncStage.Completed, status.ErrorMessage); + status.Result.Should().NotBeNull(); + } + + [Fact] + public async Task SyncNowStatus_ForAnUnknownJobId_IsNotFound() { await Authenticate(); - await GetAsync("/api/reference-data/unresolved?type=TvShow", HttpStatusCode.Forbidden); + await GetAsync($"/api/reference-data/sync-now/{Guid.NewGuid()}", HttpStatusCode.NotFound); } } diff --git a/test/WebApi.IntegrationTests/Resources/SongResourceTest.cs b/test/WebApi.IntegrationTests/Resources/SongResourceTest.cs new file mode 100644 index 0000000..699e868 --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/SongResourceTest.cs @@ -0,0 +1,103 @@ +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Bogus; +using Keeptrack.Common.System; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Basic full-cycle CRUD coverage for Song, same shape as . Song +/// has no dedicated list page in the UI - it's created/managed only from within a playlist - but still +/// gets full CRUD via the API so the same song can be created once and reused across playlists. +/// +public class SongResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + private const string ResourceEndpoint = "api/songs"; + + [Fact] + public async Task SongResourceFullCycle_IsOk() + { + await GetAsync($"/{ResourceEndpoint}", HttpStatusCode.Unauthorized); + + await Authenticate(); + + var initialItems = await GetAsync>($"/{ResourceEndpoint}"); + + var input = new Faker() + .Rules((f, o) => { o.Title = f.Random.AlphaNumeric(14); o.Artist = f.Random.AlphaNumeric(8); }) + .Generate(); + var created = await PostAsync($"/{ResourceEndpoint}", input); + created.Id.Should().NotBeNullOrEmpty(); + + try + { + created.Title = "New shiny title"; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + updated.Should().BeEquivalentTo(created); + + var finalItems = await GetAsync>($"/{ResourceEndpoint}"); + finalItems.TotalCount.Should().BeGreaterThan(initialItems.TotalCount); + var firstItem = finalItems.Items.FirstOrDefault(x => x.Id == updated.Id); + firstItem.Should().NotBeNull(); + firstItem.Title.Should().Be(updated.Title); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + [Fact] + public async Task SongResourceCreate_PersistsAlbumLink_IsOk() + { + await Authenticate(); + + var created = await PostAsync($"/{ResourceEndpoint}", new SongDto { Title = "Time Is Running Out", Artist = "Muse", AlbumId = "some-album-id" }); + + try + { + var fetched = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + fetched.AlbumId.Should().Be("some-album-id"); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + /// + /// Backs SongApiClient.GetOrCreateForTrackAsync's dedupe lookup - picking the same track twice + /// must find the one already-created song for it, not create a duplicate. Two songs share an + /// AlbumId here specifically to prove the filter matches on both fields together, not either alone. + /// + [Fact] + public async Task SongResourceSearch_FiltersToMatchingAlbumIdAndTrackPosition_IsOk() + { + await Authenticate(); + + const string albumId = "shared-album-id"; + var trackOne = await PostAsync($"/{ResourceEndpoint}", new SongDto { Title = "Apocalypse Please", AlbumId = albumId, TrackPosition = "2" }); + var trackTwo = await PostAsync($"/{ResourceEndpoint}", new SongDto { Title = "Time Is Running Out", AlbumId = albumId, TrackPosition = "3" }); + + try + { + var results = await GetAsync>($"/{ResourceEndpoint}?AlbumId={albumId}&TrackPosition=3"); + + results.Items.Should().ContainSingle(x => x.Id == trackTwo.Id); + results.Items.Should().NotContain(x => x.Id == trackOne.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{trackOne.Id}"); + await DeleteAsync($"/{ResourceEndpoint}/{trackTwo.Id}"); + } + } +} diff --git a/test/WebApi.UnitTests/Jobs/JobStoreTest.cs b/test/WebApi.UnitTests/Jobs/JobStoreTest.cs new file mode 100644 index 0000000..e18c5b2 --- /dev/null +++ b/test/WebApi.UnitTests/Jobs/JobStoreTest.cs @@ -0,0 +1,91 @@ +using System; +using AwesomeAssertions; +using Keeptrack.WebApi.Jobs; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Jobs; + +/// +/// Covers directly - the shared job-tracking logic behind both TV +/// Time import and reference-data "sync now", generalized out of the old TV-Time-only ImportJobStore +/// so the two features share one implementation instead of duplicating the same create/update/complete/ +/// fail/owner-scoping logic. +/// +[Trait("Category", "UnitTests")] +public class JobStoreTest +{ + private enum TestStage + { + Running, + Completed, + Failed + } + + [Fact] + public void Create_ThenGetStatus_ReflectsTheInitialStage() + { + var store = new JobStore(); + + var jobId = store.Create("owner-1", TestStage.Running); + var status = store.GetStatus(jobId, "owner-1"); + + status.Should().NotBeNull(); + status!.Value.Stage.Should().Be(TestStage.Running); + status.Value.Result.Should().BeNull(); + status.Value.ErrorMessage.Should().BeNull(); + } + + [Fact] + public void UpdateStage_IsReflectedOnTheNextGetStatus() + { + var store = new JobStore(); + var jobId = store.Create("owner-1", TestStage.Running); + + store.UpdateStage(jobId, TestStage.Completed); + + store.GetStatus(jobId, "owner-1")!.Value.Stage.Should().Be(TestStage.Completed); + } + + [Fact] + public void Complete_SetsTheTerminalStageAndResult() + { + var store = new JobStore(); + var jobId = store.Create("owner-1", TestStage.Running); + + store.Complete(jobId, TestStage.Completed, "all done"); + + var status = store.GetStatus(jobId, "owner-1"); + status!.Value.Stage.Should().Be(TestStage.Completed); + status.Value.Result.Should().Be("all done"); + } + + [Fact] + public void Fail_SetsTheTerminalStageAndErrorMessage() + { + var store = new JobStore(); + var jobId = store.Create("owner-1", TestStage.Running); + + store.Fail(jobId, TestStage.Failed, "boom"); + + var status = store.GetStatus(jobId, "owner-1"); + status!.Value.Stage.Should().Be(TestStage.Failed); + status.Value.ErrorMessage.Should().Be("boom"); + } + + [Fact] + public void GetStatus_ReturnsNull_ForAnUnknownJobId() + { + var store = new JobStore(); + + store.GetStatus(Guid.NewGuid(), "owner-1").Should().BeNull(); + } + + [Fact] + public void GetStatus_ReturnsNull_ForAJobBelongingToADifferentOwner() + { + var store = new JobStore(); + var jobId = store.Create("owner-1", TestStage.Running); + + store.GetStatus(jobId, "owner-2").Should().BeNull(); + } +} diff --git a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs index 81fa078..11730d1 100644 --- a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs +++ b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs @@ -764,7 +764,7 @@ public async Task TryAutoResolveAlbumAsync_DoesNothing_WhenSearchIsAmbiguous() public async Task TryAutoResolveAlbumAsync_ResolvesAndPropagates_WhenExactlyOneCandidate() { var discogsClient = FakeDiscogsClient.WithSearchResults(new DiscogsSearchResult("1", "Some Album", 2020, "Some Artist", null)); - discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album", 2020, "Synopsis", "Some Artist", "100", [], null); + discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album", 2020, "Synopsis", "Some Artist", "100", [], null, []); _albumReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((AlbumReferenceModel m) => { m.Id ??= "generated-id"; return m; }); _personReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((PersonReferenceModel m) => { m.Id ??= "person-1"; return m; }); var service = CreateService(FakeTmdbClient.WithTvShowSearchResults(), discogsClient: discogsClient); @@ -781,7 +781,7 @@ public async Task TryAutoResolveAlbumAsync_PassesTheArtistThroughToTheDiscogsSea // regression: a common album title without an artist hint returns many unrelated candidates - the // artist must reach IDiscogsClient.SearchAlbumsAsync, not just get dropped along the way. var discogsClient = FakeDiscogsClient.WithSearchResults(new DiscogsSearchResult("1", "Some Album", 2020, "Pink Floyd", null)); - discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album", 2020, "Synopsis", "Pink Floyd", "100", [], null); + discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album", 2020, "Synopsis", "Pink Floyd", "100", [], null, []); _albumReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((AlbumReferenceModel m) => { m.Id ??= "generated-id"; return m; }); _personReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((PersonReferenceModel m) => { m.Id ??= "person-1"; return m; }); var service = CreateService(FakeTmdbClient.WithTvShowSearchResults(), discogsClient: discogsClient); @@ -795,7 +795,7 @@ public async Task TryAutoResolveAlbumAsync_PassesTheArtistThroughToTheDiscogsSea public async Task ResolveAlbumAsync_PropagatesTheUpsertedReferenceId() { var discogsClient = FakeDiscogsClient.Empty(); - discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album", 2020, "Synopsis", "Some Artist", "100", [], null); + discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album", 2020, "Synopsis", "Some Artist", "100", [], null, []); _albumReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((AlbumReferenceModel m) => { m.Id = "reference-1"; return m; }); _personReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((PersonReferenceModel m) => { m.Id ??= "person-1"; return m; }); var service = CreateService(FakeTmdbClient.WithTvShowSearchResults(), discogsClient: discogsClient); @@ -891,7 +891,8 @@ public async Task RefreshAlbumReferenceAsync_AlwaysRefetches_RegardlessOfLastEnr // Discogs exposes no "changed since" endpoint (unlike TMDB) - every refresh call does a full // re-fetch, even when LastEnrichedAt is very recent. var discogsClient = FakeDiscogsClient.Empty(); - discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album - Updated", 2020, "New synopsis", "Some Artist", "100", ["Rock"], null); + discogsClient.Details["1"] = new DiscogsAlbumDetails("1", "Some Album - Updated", 2020, "New synopsis", "Some Artist", "100", ["Rock"], null, + [new DiscogsTrack("1", "Intro", "0:22"), new DiscogsTrack("2", "Apocalypse Please", "4:12")]); var reference = new AlbumReferenceModel { Id = "reference-1", Title = "Some Album", TitleNormalized = "some album", @@ -906,6 +907,9 @@ public async Task RefreshAlbumReferenceAsync_AlwaysRefetches_RegardlessOfLastEnr changed.Should().BeTrue(); result.Title.Should().Be("Some Album - Updated"); result.Genres.Should().Contain("Rock"); + result.Tracks.Should().SatisfyRespectively( + t => { t.Position.Should().Be("1"); t.Title.Should().Be("Intro"); t.Duration.Should().Be("0:22"); }, + t => { t.Position.Should().Be("2"); t.Title.Should().Be("Apocalypse Please"); t.Duration.Should().Be("4:12"); }); } private sealed class FakeTmdbClient : ITmdbClient diff --git a/test/WebApi.UnitTests/ReferenceData/ReferenceSyncServiceTest.cs b/test/WebApi.UnitTests/ReferenceData/ReferenceSyncServiceTest.cs index 81d82bc..55c7235 100644 --- a/test/WebApi.UnitTests/ReferenceData/ReferenceSyncServiceTest.cs +++ b/test/WebApi.UnitTests/ReferenceData/ReferenceSyncServiceTest.cs @@ -5,6 +5,7 @@ using AwesomeAssertions; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Contracts.Dto; using Keeptrack.WebApi.ReferenceData; using Microsoft.Extensions.Logging.Abstractions; using Moq; @@ -57,7 +58,7 @@ public async Task SyncStaleReferencesAsync_Skips_ReferenceEnrichedMoreRecentlyTh _movieReferenceRepository.Setup(r => r.FindAllAsync()).ReturnsAsync([]); var service = CreateService(FakeTmdbClient.Empty()); - var result = await service.SyncStaleReferencesAsync(TimeSpan.FromDays(3), TestContext.Current.CancellationToken); + var result = await service.SyncStaleReferencesAsync(TimeSpan.FromDays(3), cancellationToken: TestContext.Current.CancellationToken); result.TvShowsChecked.Should().Be(0); _tvShowReferenceRepository.Verify(r => r.UpsertAsync(It.IsAny()), Times.Never); @@ -79,7 +80,7 @@ public async Task SyncStaleReferencesAsync_Refreshes_ReferenceOlderThanStaleAfte _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); var service = CreateService(tmdbClient); - var result = await service.SyncStaleReferencesAsync(TimeSpan.FromDays(3), TestContext.Current.CancellationToken); + var result = await service.SyncStaleReferencesAsync(TimeSpan.FromDays(3), cancellationToken: TestContext.Current.CancellationToken); result.TvShowsChecked.Should().Be(1); result.TvShowsUpdated.Should().Be(1); @@ -107,12 +108,35 @@ public async Task SyncStaleReferencesAsync_ContinuesPastAFailedReference_AndStil _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); var service = CreateService(tmdbClient); - var result = await service.SyncStaleReferencesAsync(TimeSpan.FromDays(3), TestContext.Current.CancellationToken); + var result = await service.SyncStaleReferencesAsync(TimeSpan.FromDays(3), cancellationToken: TestContext.Current.CancellationToken); result.TvShowsChecked.Should().Be(2); result.TvShowsUpdated.Should().Be(1); } + /// + /// Backs the admin "sync now" progress bar (ReferenceDataAdminController.SyncNow/ + /// ReferenceDataAdminPage.razor's polling loop) - confirms the stage callback fires once per + /// domain, in the same order the UI's progress-percent mapping assumes. + /// + [Fact] + public async Task SyncStaleReferencesAsync_InvokesOnStageChanged_OncePerDomainInOrder() + { + _tvShowReferenceRepository.Setup(r => r.FindAllAsync()).ReturnsAsync([]); + _movieReferenceRepository.Setup(r => r.FindAllAsync()).ReturnsAsync([]); + var service = CreateService(FakeTmdbClient.Empty()); + var stages = new List(); + + await service.SyncStaleReferencesAsync(TimeSpan.FromDays(3), stages.Add, TestContext.Current.CancellationToken); + + stages.Should().ContainInOrder( + ReferenceSyncStage.SyncingTvShows, + ReferenceSyncStage.SyncingMovies, + ReferenceSyncStage.SyncingBooks, + ReferenceSyncStage.SyncingVideoGames, + ReferenceSyncStage.SyncingAlbums); + } + private sealed class FakeTmdbClient : ITmdbClient { public Dictionary TvShowDetails { get; } = new(); From 959fabe26c147c0d4bbfa1c1b733f01a7754e107 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Thu, 9 Jul 2026 16:20:16 +0200 Subject: [PATCH 26/44] Add car and car history --- CLAUDE.md | 8 +- CONTRIBUTING.md | 2 + docs/code-quality-findings.md | 44 +- scripts/mongodb-create-index.js | 19 +- .../Inventory/Clients/CarApiClient.cs | 15 + .../Inventory/Clients/CarHistoryApiClient.cs | 9 + .../Inventory/Pages/CarDetail.razor | 508 ++++++++++++++++++ .../Inventory/Pages/CarDetail.razor.css | 87 +++ .../Inventory/Pages/CarHistoryRow.razor | 86 +++ .../Components/Inventory/Pages/Cars.razor | 96 ++++ .../Components/Inventory/Pages/Cars.razor.cs | 52 ++ src/BlazorApp/Components/Layout/NavMenu.razor | 5 + ...frastructureServiceCollectionExtensions.cs | 4 + src/BlazorApp/wwwroot/app.css | 2 + src/Domain/Models/CarCostHistoryPointModel.cs | 18 + src/Domain/Models/CarEnergyType.cs | 8 + src/Domain/Models/CarHistoryModel.cs | 25 +- src/Domain/Models/CarHistoryType.cs | 8 + src/Domain/Models/CarMetricsModel.cs | 22 + src/Domain/Models/CarMileageWarningModel.cs | 13 + src/Domain/Models/CarModel.cs | 12 +- src/Domain/Models/ConsumptionPointModel.cs | 14 + src/Domain/Models/NextMaintenanceModel.cs | 16 + src/Domain/Services/CarMetricsService.cs | 170 ++++++ src/Infrastructure.MongoDb/Entities/Car.cs | 15 +- .../Entities/CarHistory.cs | 15 +- .../Entities/CarHistoryFuel.cs | 16 +- .../Entities/CarHistoryLocation.cs | 6 +- .../Repositories/CarHistoryRepository.cs | 8 +- .../Repositories/CarRepository.cs | 8 + .../Repositories/MongoDbRepositoryBase.cs | 13 +- .../Dto/CarCostHistoryPointDto.cs | 29 + src/WebApi.Contracts/Dto/CarDto.cs | 27 +- src/WebApi.Contracts/Dto/CarEnergyType.cs | 16 + src/WebApi.Contracts/Dto/CarHistoryDto.cs | 41 +- src/WebApi.Contracts/Dto/CarHistoryType.cs | 16 + src/WebApi.Contracts/Dto/CarMetricsDto.cs | 49 ++ .../Dto/CarMileageWarningDto.cs | 18 + .../Dto/ConsumptionPointDto.cs | 19 + .../Dto/NextMaintenanceDto.cs | 24 + src/WebApi/Controllers/CarController.cs | 38 ++ .../CarDataStorageMappingProfile.cs | 42 +- .../WebServiceMappingProfile.cs | 13 + src/WebApi/Program.cs | 1 + .../Resources/CarHistoryResourceTest.cs | 116 ++++ .../Resources/CarResourceTest.cs | 124 +++++ .../Services/CarMetricsServiceTest.cs | 189 +++++++ 47 files changed, 2002 insertions(+), 84 deletions(-) create mode 100644 src/BlazorApp/Components/Inventory/Clients/CarApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Clients/CarHistoryApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Pages/CarDetail.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css create mode 100644 src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/Cars.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/Cars.razor.cs create mode 100644 src/Domain/Models/CarCostHistoryPointModel.cs create mode 100644 src/Domain/Models/CarEnergyType.cs create mode 100644 src/Domain/Models/CarHistoryType.cs create mode 100644 src/Domain/Models/CarMetricsModel.cs create mode 100644 src/Domain/Models/CarMileageWarningModel.cs create mode 100644 src/Domain/Models/ConsumptionPointModel.cs create mode 100644 src/Domain/Models/NextMaintenanceModel.cs create mode 100644 src/Domain/Services/CarMetricsService.cs create mode 100644 src/WebApi.Contracts/Dto/CarCostHistoryPointDto.cs create mode 100644 src/WebApi.Contracts/Dto/CarEnergyType.cs create mode 100644 src/WebApi.Contracts/Dto/CarHistoryType.cs create mode 100644 src/WebApi.Contracts/Dto/CarMetricsDto.cs create mode 100644 src/WebApi.Contracts/Dto/CarMileageWarningDto.cs create mode 100644 src/WebApi.Contracts/Dto/ConsumptionPointDto.cs create mode 100644 src/WebApi.Contracts/Dto/NextMaintenanceDto.cs create mode 100644 src/WebApi/Controllers/CarController.cs create mode 100644 test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs create mode 100644 test/WebApi.IntegrationTests/Resources/CarResourceTest.cs create mode 100644 test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs diff --git a/CLAUDE.md b/CLAUDE.md index 3f6dd13..5afb4c2 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -84,9 +84,13 @@ Follow the existing types (`Book`, `Movie`, `Album`, `TvShow`, `VideoGame`, `Car 6. Add both AutoMapper maps (`DataStorageMappingProfile`, `WebServiceMappingProfile`). 7. `BlazorApp/Components/Inventory/Clients/ApiClient.cs` extending `InventoryApiClientBase`, plus a `Pages/.razor` / `.razor.cs` pair extending `InventoryPageBase`. +**Gotcha:** `Dto` can never have a `required` member if `Pages/.razor.cs` extends `InventoryPageBase` — that base class is constrained `where TDto : IHasId, new()`, and a type with *any* `required` member can't satisfy a bare `new()` constraint in C# (`CS9040`). This is why `BookDto.Title`, `CarDto.Name`, etc. are all nullable even though their Domain model counterpart (`BookModel.Title`, `CarModel.Name`) is `required` — it's a hard language limitation forced by the generic list-page base class, not a design inconsistency to "fix" by making the Dto match the model. A Dto with no `InventoryPageBase` usage (e.g. `CarHistoryDto`, owned-by-a-parent types managed from their parent's detail page rather than their own list page) has no such constraint and can mirror the Domain model's `required` members in full. + ### Child entities (1-to-many owned by another entity) -`CarHistory` (owned by `Car`) and `Episode` (owned by `TvShow`) are separate top-level collections referencing their parent by id (`car_id`, `tv_show_id`), not embedded arrays. This is deliberate MongoDB schema design, not an accident: these child collections can grow unbounded per parent over years of use, and features that need to query the child across *all* of a user's parents at once (e.g. Watch Next, below) need a plain indexed query rather than an `$unwind` aggregation. Embedding is the right call for genuinely small, always-together, never-queried-alone data; neither condition holds here. `EpisodeRepository.GetFilter` filters by `input.TvShowId` with `Eq` (not `Text` — see the `CarHistory` bug in `docs/code-quality-findings.md` for what happens when an exact-id filter uses `Text` instead). New multi-word BSON fields get an explicit `[BsonElement("snake_case_name")]`; don't rely on the `CamelCaseElementNameConvention` registered in `AddMongoDbInfrastructure` — every existing multi-word field already overrides it explicitly, so it's effectively dead configuration. Indexes for new collections are declared in `scripts/mongodb-create-index.js` (natural-key uniqueness, query-shape support, and partial indexes for sparse boolean flags like `is_favorite`/`want_to_watch`). +`CarHistory` (owned by `Car`) and `Episode` (owned by `TvShow`) are separate top-level collections referencing their parent by id (`car_id`, `tv_show_id`), not embedded arrays. This is deliberate MongoDB schema design, not an accident: these child collections can grow unbounded per parent over years of use, and features that need to query the child across *all* of a user's parents at once (e.g. Watch Next, below) need a plain indexed query rather than an `$unwind` aggregation. Embedding is the right call for genuinely small, always-together, never-queried-alone data; neither condition holds here. `EpisodeRepository.GetFilter`/`CarHistoryRepository.GetFilter` both filter their parent-id field (`TvShowId`/`CarId`) with `Eq`, not `Text` — an exact-id filter used `Text` in `CarHistory`'s first draft, throwing whenever a free-text `search` was also supplied (MongoDB allows only one `$text` expression per query), fixed and covered by `docs/code-quality-findings.md`. New multi-word BSON fields get an explicit `[BsonElement("snake_case_name")]`; don't rely on the `CamelCaseElementNameConvention` registered in `AddMongoDbInfrastructure` — every existing multi-word field already overrides it explicitly, so it's effectively dead configuration. Indexes for new collections are declared in `scripts/mongodb-create-index.js` (natural-key uniqueness, query-shape support, and partial indexes for sparse boolean flags like `is_favorite`/`want_to_watch`). + +`CarHistoryModel.EventType` (`CarHistoryType`: `Refuel`/`Maintenance`/`Other`) is a real discriminated enum, not free text — the same "never name a property/field bare `Type`" rule as any other discriminator in this codebase (see `TvShowModel.State`'s own rename history above): a bare `Type` reads ambiguously and collides in spirit with `object.GetType()`/`System.Type`. `Car.EnergyType` (`CarEnergyType`: `Combustion`/`Hybrid`/`Electric`) and `CarHistoryModel.EventType`/`CarId`/`HistoryDate` are all `required` on both the Domain model and the Mongo entity; `CarDto` itself can't mirror `Name`/`EnergyType` as `required`, because `Cars.razor` extends `InventoryPageBase`, which needs a bare `new()` constraint — a type with *any* `required` member can't satisfy `new()` in C#, so the Dto layer stays nullable there by hard language necessity, not by choice (`CarHistoryDto` has no such constraint, so it mirrors `required` in full). `CarHistoryModel.DeltaMileage` is real user-entered data (typically read off the car's own trip computer at refuel time), not a derived/computed field, kept specifically so `Domain/Services/CarMetricsService.cs` can cross-check it against consecutive `Mileage` readings and flag a likely typo or a skipped entry — the automated version of a manual spreadsheet cross-check, and the reason this field was kept rather than dropped as "unused" during review. `CarMetricsService` (consumption — only ever computed across a full refill/recharge, never a partial one — cost-of-ownership history, mileage warnings, next-maintenance-due) follows `WatchNextService`'s shape: a plain, `AddSingleton`-registered, unit-tested pure computation class with no persistence of its own, exposed via `CarController.GetMetrics` the same way `VideoGameController.RefreshReference` adds an extra per-item action to an entity's own CRUD controller instead of a separate cross-entity controller. ### Reference data (shared, owner-less) @@ -114,7 +118,7 @@ Reference data is meant to be portable across environments, not re-earned from T **Gotcha:** "does this tenant document have no reference link yet" cannot be a plain `Eq(x => x.ReferenceId, null)` filter. `AddAutoMapper` is configured with `AllowNullDestinationValues = false` (`WebApi/Program.cs`), so mapping a model whose string property is null stores an **empty string**, never an actual BSON null. `TvShowRepository`/`MovieRepository`'s `UnresolvedFilter()` matches null *or* empty string for exactly this reason - copy that helper's shape (not a bare null check) for any new "is this string field unset" query. This one is easy to get wrong silently: it doesn't throw, it just quietly matches zero documents. A real-MongoDB integration test (`TvShowReferenceLinkingTest`) is what caught it, not the unit tests (which mock the repository and never see the actual serialization behavior). -**Second instance of the same gotcha:** the same `AllowNullDestinationValues = false` setting also changes `mapper.Map(source)` when `source` itself (not just one of its properties) is `null` - instead of returning `null`, AutoMapper returns a new, all-default instance of `TDestination`. Every `Find*Async` method on `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository` does `var entity = await Collection.Find(...).FirstOrDefaultAsync();` where `entity` can legitimately be null (nothing matched) - mapping it directly would silently turn "not found" into a fake found-but-empty model, which `ReferenceDataController`'s `model is null` 404 check (and anything else checking `is null` on a Find result) would never trigger. Each of those methods now checks `entity is null` before calling `mapper.Map`, returning `null` directly instead. Copy this guard for any new Find method against these owner-less collections - the ordinary owner-scoped repositories don't need it only because `MongoDbRepositoryBase.FindOneAsync`/`FindAllAsync` happen to route through `IMapper.Map>`/other paths that don't hit this specific null-source case the same way. +**Second instance of the same gotcha:** the same `AllowNullDestinationValues = false` setting also changes `mapper.Map(source)` when `source` itself (not just one of its properties) is `null` - instead of returning `null`, AutoMapper returns a new, all-default instance of `TDestination`. Every `Find*Async` method on `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository` does `var entity = await Collection.Find(...).FirstOrDefaultAsync();` where `entity` can legitimately be null (nothing matched) - mapping it directly would silently turn "not found" into a fake found-but-empty model, which `ReferenceDataController`'s `model is null` 404 check (and anything else checking `is null` on a Find result) would never trigger. Each of those methods now checks `entity is null` before calling `mapper.Map`, returning `null` directly instead. **This turned out not to be limited to the owner-less reference repositories**: `MongoDbRepositoryBase.FindOneAsync` (the shared base every ordinary owner-scoped repository extends) had the exact same shape and hit the exact same bug - every entity's `GetById` 404 check was silently broken, returning 200 with a blank object for a nonexistent id, until this was found (2026-07-09, while building Car) and fixed with the same `entity is null` guard directly in the base method. Copy this guard for any new Find method that can legitimately return "nothing matched," anywhere in the codebase, not just the owner-less collections - a mocked-repository unit test cannot catch this, only a real MongoDB integration test can (a mock never exercises the real `AllowNullDestinationValues` behavior). The reference layer also now has `Genres`, `Cast` (embedded `CastMemberModel` list, pointing at a third owner-less collection, `person_reference` - actors are deduplicated across every show/movie that credits them, keyed by TMDB person id via `IPersonReferenceRepository.FindByExternalIdAsync`, not by name), and `PosterUrl`/`CastMemberDto.ProfileImageUrl`. Images are **hotlinked directly from TMDB's CDN** (`https://image.tmdb.org/t/p/{size}{path}`, built once in `TmdbClient` and stored as a plain URL) rather than downloaded and re-hosted - confirmed this is TMDB's own sanctioned, standard usage pattern (a separate, unauthenticated static-asset host, not the rate-limited API), so there's no local storage/volume/static-file-serving subsystem to operate. `CastMemberDto` is fully hydrated server-side (`ReferenceDataController` joins the embedded cast list against `person_reference`) specifically because that join needs repository access AutoMapper profiles don't have - `WebServiceMappingProfile` ignores `Cast` for exactly this reason; don't try to make it a plain `CreateMap` member. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index bbfb2c6..c7c8c0a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -229,6 +229,8 @@ Run a single test by fully qualified name (works for either project): dotnet test --filter-method "Keeptrack.WebApi.UnitTests.MappingProfiles.AutoMapperConfigurationTest.WebApiAutoMapperProfile_ShouldBeValid" ``` +`--filter-method` also accepts a wildcard, e.g. `--filter-method "*CarResourceTest*"` to run every test in a class - but it's a single glob pattern, not a real filter expression: it does not support `|`/`,` alternation to combine multiple patterns in one run (that just prints the CLI help instead of running anything), so run each pattern as its own `dotnet test` invocation. This project's test runner is `Microsoft.Testing.Platform` (`UseMicrosoftTestingPlatformRunner`, xunit v3), which does **not** understand the classic VSTest `--settings .runsettings` flag - passing it also just prints the help. `Local.runsettings` (below) is read automatically by Rider/Visual Studio for IDE-driven runs; for a CLI run, export the same values as environment variables instead (see "Integration tests" below). + ### Unit tests No configuration needed - `dotnet test test/WebApi.UnitTests/WebApi.UnitTests.csproj` works as soon as the solution restores. diff --git a/docs/code-quality-findings.md b/docs/code-quality-findings.md index 0dfe603..31306da 100644 --- a/docs/code-quality-findings.md +++ b/docs/code-quality-findings.md @@ -6,6 +6,23 @@ Update this file as items are fixed or as new reviews are performed. ## Fixed +### `mapper.Map(null)` returned a fake empty object instead of null - also affected the shared base repository, not just the reference-data ones + +Found again on 2026-07-09 while building the Car/CarHistory feature and its `CarResourceTest` integration coverage: `MongoDbRepositoryBase.FindOneAsync` (the base class every entity's repository extends) had the exact same shape as the bug described just below - `Mapper.Map(await entities.FirstOrDefaultAsync())` - and hit the exact same `AllowNullDestinationValues = false` gotcha, silently returning a blank default model instead of `null` for a nonexistent id. +This meant `DataCrudControllerBase.GetById`'s `model == null` 404 check was broken for **every** entity type in the app (Book, Movie, TvShow, VideoGame, Album, Song, Playlist, Episode - not just the newly-added Car), returning 200 with an empty object instead of 404. +A mocked-repository unit test can't catch this (a mock never exercises real AutoMapper config); confirmed via a real MongoDB integration test (`CarResourceTest.CarResourceMetrics_ReturnsNotFound_ForACarThatDoesNotExist`) and cross-checked against `Book` directly. +Fixed the same way as the reference repositories below: check `entity is null` before calling `mapper.Map`, in the one shared base method rather than per-repository. + +File: `src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs` + +### `AllowNullDestinationValues = false` also substitutes an empty collection for a null reference-type member, not just an empty string + +Found on 2026-07-09 while adding `CarHistoryResourceTest`: `CarHistoryModel -> CarHistory`'s `Coordinates` (`List`) `ForMember` mapped to `null` when `Longitude`/`Latitude` were unset, but `AllowNullDestinationValues = false` substituted a new **empty list** instead - the same class of bug as the `Creator`/empty-string gotchas already documented here and in CLAUDE.md, just for a `List` member instead of `string`. +The reverse mapping (`CarHistory -> CarHistoryModel`) read it back with `x.Coordinates != null ? x.Coordinates[0] : null`, which an empty-but-non-null list defeats - `x.Coordinates[0]` threw `IndexOutOfRangeException` on every `POST`/`PUT` of a `CarHistory` entry with no location set. +Fixed with `.AllowNull()` on that `ForMember`, same fix shape as the `Creator` case in CLAUDE.md. + +File: `src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs` + ### `mapper.Map(null)` returned a fake empty object instead of null Found on 2026-07-06 while adding the cast/actors integration test (`PersonReferenceRepositoryTest`), in `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository`'s `Find*Async` methods. @@ -59,20 +76,22 @@ Files: - `src/Infrastructure.MongoDb/Repositories/MovieRepository.cs` - `src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs` -## Confirmed bugs +### CarHistory treated a car ID as free text, and CarRepository's search never covered the field that actually exists on a Car document -These are true defects. They should be fixed. +Fixed on 2026-07-09 while building the full Car/CarHistory feature (controller, Blazor pages, metrics, tests). +Two related bugs, both in search: -### CarHistory treats a car ID as free text +1. `CarHistoryRepository.GetFilter` called `builder.Text(input.CarId)` - a car ID is an exact identifier, not a free-text search term, and MongoDB only allows one `$text` expression per query, so supplying both `CarId` and a free-text `search` at the same time threw ("only one $text expression allowed per query"). +2. `CarRepository` had no `GetFilter` override at all, so it fell back to `MongoDbRepositoryBase`'s default `builder.Text(search)`, which queried the `car_text` index (`{ title: "text" }`) - but `Car`'s BSON field is `commercial_name` (`[BsonElement("commercial_name")]` on `Name`), not `title`. The index never covered the field that exists on the document, so `Car` search had silently never worked at all, on top of (1) never being documented before this session. -`CarHistoryRepository.GetFilter` calls `builder.Text(input.CarId)`. -A car ID is an exact identifier, not a free-text search term, so this is the wrong filter type - the `car_history_text` index (see "Fixed" above) makes the collection searchable again, but doesn't fix this. -MongoDB also only allows one `$text` expression per query. -If both `input.CarId` and `search` are non-empty at the same time, the query throws ("only one $text expression allowed per query"). +Fixed by moving both repositories to the same `builder.Where(f => f.X.Contains(search, ...))` regex-search approach already used by Book/Movie/TvShow/VideoGame (`CarRepository` on `Name`, `CarHistoryRepository` on `Description`), filtering `CarId` with a plain `Eq`, and removing the now-unused `car_text`/`car_history_text` indexes from `scripts/mongodb-create-index.js` - closing out the last two exceptions that script's own comments used to call out. +Regression-tested against a real MongoDB instance: `CarHistoryResourceTest.CarHistoryResourceFilter_ByCarIdAndSearch_DoesNotThrow_IsOk` (the specific dual-filter case) and `CarResourceTest.CarResourceSearch_FiltersByName_IsOk`. -File: `src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs` +Files: -Fix: filter `CarId` with an equality filter (`builder.Eq(f => f.CarId, input.CarId)`), not `Text`. +- `src/Infrastructure.MongoDb/Repositories/CarRepository.cs` +- `src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs` +- `scripts/mongodb-create-index.js` ## Confirmed by design @@ -89,11 +108,6 @@ This is intentional: each entity type exposes the search behavior that fits its These are acknowledged as incomplete rather than deliberately permanent. Track and prioritize separately. -### `Car` has no controller or Blazor page - -`ICarRepository`, `CarRepository`, and their DI registration exist, but there is no `CarController` and no Blazor Inventory page for `Car`. -Only `CarHistoryController` exists, and it references a `CarId` that currently cannot be created through the app. - ### No `CancellationToken` propagation Controllers, `MongoDbRepositoryBase`, and `InventoryApiClientBase` (Blazor) do not accept or forward a `CancellationToken`. @@ -110,7 +124,7 @@ A very large `PageSize` forces an unbounded fetch. `Book` and `Movie` have integration tests (`BookResourceTest`, `MovieResourceTest`); `Movie`'s now also covers `?search=`. `Episode` and `TvShow` gained partial coverage as a side effect of `TvTimeImportResourceTest` (create/upsert/search paths, plus `Episode`'s `TvShowId` filter), but neither has a dedicated full CRUD test of its own yet. -`Album` and `VideoGame` gained full CRUD integration tests (`AlbumResourceTest`, `VideoGameResourceTest`) on 2026-07-07 while their controllers/repositories were touched anyway to add reference-data support - closing this finding for both. `CarHistory` still has none. +`Album` and `VideoGame` gained full CRUD integration tests (`AlbumResourceTest`, `VideoGameResourceTest`) on 2026-07-07 while their controllers/repositories were touched anyway to add reference-data support - closing this finding for both. `Car` and `CarHistory` gained full CRUD integration tests (`CarResourceTest`, `CarHistoryResourceTest`) plus dedicated unit coverage for `CarMetricsService` on 2026-07-09, when the whole Car/CarHistory feature was built out (controller, Blazor pages, metrics) - closing this finding for both as well. No test asserts ownership isolation (that user A cannot read, update, or delete user B's record). There is no test project for `BlazorApp` - `AuthenticationController`'s Firebase-custom-claim-to-cookie-claim copy (added for the admin role) has no automated coverage as a result, only manual verification. The reference-data admin endpoints have integration coverage for the non-admin-rejected (403) path and for the underlying Mongo queries directly (`TvShowReferenceLinkingTest`), but not for the admin-succeeds path over HTTP end-to-end, since that needs a second Firebase test user with the `role: admin` claim pre-set (see `CONTRIBUTING.md`). diff --git a/scripts/mongodb-create-index.js b/scripts/mongodb-create-index.js index 090db29..f32b9c4 100644 --- a/scripts/mongodb-create-index.js +++ b/scripts/mongodb-create-index.js @@ -28,18 +28,13 @@ ensureIndex(db.videogame, { owner_id: 1 }, { name: "videogame_owner" }); ensureIndex(db.song, { owner_id: 1 }, { name: "song_owner" }); ensureIndex(db.playlist, { owner_id: 1 }, { name: "playlist_owner" }); -// car / car_history: the only two repositories that actually issue a $text query (CarRepository has no -// GetFilter override, so it falls back to MongoDbRepositoryBase's builder.Text(search); CarHistoryRepository -// calls builder.Text(...) directly) - confirmed by grepping every repository for ".Text(" usage. Album, Book, -// Movie, TvShow, and VideoGame all search via builder.Where(f => f.Title.Contains(...)) (a -// regex filter), which a "text" index never accelerates - text indexes for those collections were removed -// here as dead weight, not carried forward. -// NOTE: CarHistoryRepository.GetFilter combines builder.Text(input.CarId) and builder.Text(search) with -// "&", and MongoDB only allows one $text expression per query - this index makes car_history searchable -// again, but a request supplying both CarId and a free-text search will still throw. That's a C# bug -// (already tracked in docs/code-quality-findings.md), not an indexing gap; fix it there, not here. -ensureIndex(db.car, { title: "text" }, { name: "car_text" }); -ensureIndex(db.car_history, { title: "text" }, { name: "car_history_text" }); +// car / car_history: both repositories now search via builder.Where(f => f.Name/Description.Contains(...)), +// the same regex-filter approach as Album/Book/Movie/TvShow/VideoGame, none of which use a text index either +// - a "text" index never accelerates a regex filter, so one isn't declared here. car/car_history previously +// had a car_text/car_history_text index (`{ title: "text" }`), but Car's/CarHistory's BSON documents have no +// `title` field at all (Car's searchable field is `commercial_name`; CarHistory's is `description`) - that +// index never covered anything and CarRepository/CarHistoryRepository no longer fall back to $text, so it +// was removed rather than repointed. // episode: enforces the (show, season, episode) natural key and makes re-imports idempotent at the database level ensureIndex( diff --git a/src/BlazorApp/Components/Inventory/Clients/CarApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/CarApiClient.cs new file mode 100644 index 0000000..429865b --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Clients/CarApiClient.cs @@ -0,0 +1,15 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Inventory.Clients; + +public class CarApiClient(HttpClient http) + : InventoryApiClientBase(http) +{ + protected override string ApiResourceName => "/api/cars"; + + public async Task GetMetricsAsync(string id) + { + var result = await Http.GetFromJsonAsync($"{ApiResourceName}/{id}/metrics"); + return result!; + } +} diff --git a/src/BlazorApp/Components/Inventory/Clients/CarHistoryApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/CarHistoryApiClient.cs new file mode 100644 index 0000000..8c82793 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Clients/CarHistoryApiClient.cs @@ -0,0 +1,9 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Inventory.Clients; + +public sealed class CarHistoryApiClient(HttpClient http) + : InventoryApiClientBase(http) +{ + protected override string ApiResourceName => "/api/car-history"; +} diff --git a/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor new file mode 100644 index 0000000..4b3fec0 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor @@ -0,0 +1,508 @@ +@page "/cars/{Id}" +@rendermode InteractiveServer +@attribute [Authorize] + +@if (_loading) +{ +
+ + Loading… +
+} +else if (_car is null) +{ +
+
◈
+

Car not found.

+
+} +else +{ +
+
+ +
+
+ +
+
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+
+ +
+ @foreach (var energyType in Enum.GetValues()) + { + + } +
+
+
+ + @if (HasMetricsToShow) + { + var metrics = _metrics!; +

Metrics

+
+ @if (metrics.NextMaintenance is { } next) + { +

+ @(next.MonthsRemaining < 0 + ? $"Maintenance overdue by {-next.MonthsRemaining} month(s) - last done {next.LastMaintenanceDate:yyyy-MM-dd}." + : $"Next maintenance due in {next.MonthsRemaining} month(s) ({next.DueDate:yyyy-MM-dd}).") +

+ } + + @if (metrics.MileageWarnings.Count > 0) + { +

+ ⚠ @metrics.MileageWarnings.Count mileage inconsistenc@(metrics.MileageWarnings.Count == 1 ? "y" : "ies") found - check the highlighted row(s) below. +

+ } + +
+ @if (ShowFuel && metrics.FuelConsumption.Count > 0) + { +
+

+ Fuel consumption (L/100km) - avg @metrics.AverageFuelConsumptionPer100Km?.ToString("F1") +

+ @RenderConsumptionChart(metrics.FuelConsumption, "var(--kt-accent)") +
+ } + @if (ShowElectric && metrics.ElectricConsumption.Count > 0) + { +
+

+ Electric consumption (kWh/100km) - avg @metrics.AverageElectricConsumptionPer100Km?.ToString("F1") +

+ @RenderConsumptionChart(metrics.ElectricConsumption, "var(--kt-chart-secondary)") +
+ } +
+ + @if (metrics.CostHistory.Count > 0) + { +

Cost history - total @metrics.TotalCost.ToString("F2")

+
+ Fuel + Maintenance +
+ @RenderCostHistoryChart(metrics.CostHistory) + } +
+ } + +
+

History

+ +
+
+
+
+ + + + + + + @if (ShowFuel) + { + + + } + @if (ShowElectric) + { + + + } + + + + + + + + + + + + + @if (_history.Count == 0) + { + + } + @foreach (var entry in _history) + { + + } + +
DateMileageΔ MileageEventFuel (L)Fuel (€/L)Electric (kWh)Electric (€/kWh)Full?CostStationCityLongitudeLatitudeDescription
No history yet - add the first entry above.
+
+
+ + @if (_showAddModal) + { +
+
+
+
Add history entry
+ +
+
+
+
+ + +
+
+ + +
+
+ + +
+
+ +
+ @foreach (var eventType in Enum.GetValues()) + { + + } +
+
+ @if (_newEntry.EventType == CarHistoryType.Refuel) + { + @if (ShowFuel) + { +
+ + +
+
+ + +
+ } + @if (ShowElectric) + { +
+ + +
+
+ + +
+ } +
+ + +
+
+
+ + +
+
+ } + +
+ + +
+
+ +
+ + +
+
+
+ + +
+
+ + +
+
+
+
+ + +
+
+
+ } +} + +@code { + [Parameter] public required string Id { get; set; } + + [Inject] private CarApiClient CarApi { get; set; } = null!; + + [Inject] private CarHistoryApiClient CarHistoryApi { get; set; } = null!; + + private bool _loading = true; + private CarDto? _car; + private List _history = []; + private CarMetricsDto? _metrics; + private CarHistoryDto _newEntry = NewEntry(""); + private bool _showAddModal; + private Dictionary _warningsByEntryId = []; + + private bool ShowFuel => _car?.EnergyType != CarEnergyType.Electric; + + private bool ShowElectric => _car?.EnergyType is CarEnergyType.Electric or CarEnergyType.Hybrid; + + /// `ComputeMetrics` always returns a non-null result, even for a brand-new car with no history + /// at all (empty lists, null averages/next-maintenance) - the metrics panel should only render once + /// there's actually something in it to show, not just because the object itself isn't null. + private bool HasMetricsToShow => _metrics is not null && ( + _metrics.FuelConsumption.Count > 0 || + _metrics.ElectricConsumption.Count > 0 || + _metrics.CostHistory.Count > 0 || + _metrics.MileageWarnings.Count > 0 || + _metrics.NextMaintenance is not null); + + protected override async Task OnParametersSetAsync() => await LoadAsync(); + + private static CarHistoryDto NewEntry(string carId) => new() + { + CarId = carId, + HistoryDate = DateOnly.FromDateTime(DateTime.Today), + EventType = CarHistoryType.Refuel + }; + + private async Task LoadAsync() + { + _loading = true; + _car = await CarApi.GetOneAsync(Id); + if (_car is not null) + { + var result = await CarHistoryApi.GetAsync("", 1, int.MaxValue, new Dictionary { ["CarId"] = Id }); + _history = result.Items.OrderBy(h => h.HistoryDate).ToList(); + _metrics = await CarApi.GetMetricsAsync(Id); + _warningsByEntryId = _metrics.MileageWarnings + .GroupBy(w => w.CarHistoryId) + .ToDictionary(g => g.Key, g => string.Join(" ", g.Select(w => w.Message))); + _newEntry = NewEntry(Id); + } + _loading = false; + } + + private async Task SaveCarAsync() + { + if (_car is null) return; + await CarApi.UpdateAsync(_car); + } + + private async Task SaveNameAsync(ChangeEventArgs e) + { + if (_car is null) return; + var name = e.Value?.ToString(); + if (string.IsNullOrWhiteSpace(name)) return; + _car.Name = name; + await SaveCarAsync(); + } + + private async Task SaveManufacturerAsync(ChangeEventArgs e) + { + if (_car is null) return; + _car.Manufacturer = e.Value?.ToString(); + await SaveCarAsync(); + } + + private async Task SaveModelAsync(ChangeEventArgs e) + { + if (_car is null) return; + _car.Model = e.Value?.ToString(); + await SaveCarAsync(); + } + + private async Task SaveYearAsync(ChangeEventArgs e) + { + if (_car is null) return; + _car.Year = int.TryParse(e.Value?.ToString(), out var year) ? year : null; + await SaveCarAsync(); + } + + private async Task SaveLicensePlateAsync(ChangeEventArgs e) + { + if (_car is null) return; + _car.LicensePlate = e.Value?.ToString(); + await SaveCarAsync(); + } + + private async Task SetEnergyTypeAsync(CarEnergyType energyType) + { + if (_car is null) return; + _car.EnergyType = energyType; + await SaveCarAsync(); + } + + /// + /// Every history mutation reloads the whole car (history + metrics) rather than patching local state - + /// an edit can change mileage-warning results and chronological order, so recomputing from the server is + /// simpler and safer than trying to keep local derived state in sync by hand. + /// + private async Task SaveEntryAsync(CarHistoryDto entry) + { + await CarHistoryApi.UpdateAsync(entry); + await LoadAsync(); + } + + private void ShowAddModal() + { + _newEntry = NewEntry(Id); + _showAddModal = true; + } + + private void CancelAddModal() => _showAddModal = false; + + private async Task SaveNewEntryAsync() + { + await CarHistoryApi.AddAsync(_newEntry); + _showAddModal = false; + await LoadAsync(); + } + + private async Task DeleteEntryAsync(string id) + { + await CarHistoryApi.DeleteAsync(id); + await LoadAsync(); + } + + /// Thin hand-rolled SVG line chart - this app has no charting dependency, and one isn't worth + /// adding for a couple of small, single-series trend lines. A single series needs no legend (the label + /// above the chart already names it); each point carries a native <title> tooltip. + private static RenderFragment RenderConsumptionChart(List points, string color) => builder => + { + const double width = 100; + const double height = 36; + const double padding = 4; + + var values = points.Select(p => p.ValuePer100Km).ToList(); + var min = values.Min(); + var max = values.Max(); + var range = max - min == 0 ? 1 : max - min; + var stepX = points.Count > 1 ? (width - 2 * padding) / (points.Count - 1) : 0; + + double X(int i) => padding + i * stepX; + double Y(double v) => height - padding - (v - min) / range * (height - 2 * padding); + + var linePoints = string.Join(" ", points.Select((p, i) => $"{X(i):F1},{Y(p.ValuePer100Km):F1}")); + + var seq = 0; + builder.OpenElement(seq++, "svg"); + builder.AddAttribute(seq++, "viewBox", $"0 0 {width} {height}"); + builder.AddAttribute(seq++, "preserveAspectRatio", "none"); + builder.AddAttribute(seq++, "class", "kt-consumption-chart"); + + builder.OpenElement(seq++, "polyline"); + builder.AddAttribute(seq++, "points", linePoints); + builder.AddAttribute(seq++, "fill", "none"); + builder.AddAttribute(seq++, "stroke", color); + builder.AddAttribute(seq++, "stroke-width", "2"); + builder.AddAttribute(seq++, "stroke-linecap", "round"); + builder.AddAttribute(seq++, "stroke-linejoin", "round"); + builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); + builder.CloseElement(); + + for (var i = 0; i < points.Count; i++) + { + builder.OpenElement(seq++, "circle"); + builder.AddAttribute(seq++, "cx", X(i).ToString("F1")); + builder.AddAttribute(seq++, "cy", Y(points[i].ValuePer100Km).ToString("F1")); + builder.AddAttribute(seq++, "r", "1.6"); + builder.AddAttribute(seq++, "fill", color); + builder.OpenElement(seq++, "title"); + builder.AddContent(seq++, $"{points[i].Date:yyyy-MM-dd}: {points[i].ValuePer100Km:F1}"); + builder.CloseElement(); + builder.CloseElement(); + } + + builder.CloseElement(); + }; + + /// Hand-rolled SVG stacked bar chart - fuel vs. maintenance cost per month, each bar segment + /// carrying a native <title> tooltip with the exact figure, and a 2px surface gap between the two + /// stacked segments so they read as distinct marks rather than one solid bar. + private static RenderFragment RenderCostHistoryChart(List points) => builder => + { + const double width = 100; + const double height = 36; + const double padding = 2; + + var maxTotal = points.Max(p => p.TotalCost); + if (maxTotal <= 0) maxTotal = 1; + + var barWidth = (width - 2 * padding) / points.Count * 0.7; + var gap = (width - 2 * padding) / points.Count * 0.3; + + double ScaleHeight(double value) => value / maxTotal * (height - 2 * padding); + + var seq = 0; + builder.OpenElement(seq++, "svg"); + builder.AddAttribute(seq++, "viewBox", $"0 0 {width} {height}"); + builder.AddAttribute(seq++, "preserveAspectRatio", "none"); + builder.AddAttribute(seq++, "class", "kt-cost-chart"); + + for (var i = 0; i < points.Count; i++) + { + var point = points[i]; + var x = padding + i * (barWidth + gap); + var fuelHeight = ScaleHeight(point.FuelCost); + var maintenanceHeight = ScaleHeight(point.MaintenanceCost); + var stackGap = point.FuelCost > 0 && point.MaintenanceCost > 0 ? 0.6 : 0; + + var maintenanceY = height - padding - maintenanceHeight; + builder.OpenElement(seq++, "rect"); + builder.AddAttribute(seq++, "x", x.ToString("F1")); + builder.AddAttribute(seq++, "y", maintenanceY.ToString("F1")); + builder.AddAttribute(seq++, "width", barWidth.ToString("F1")); + builder.AddAttribute(seq++, "height", maintenanceHeight.ToString("F1")); + builder.AddAttribute(seq++, "fill", "var(--kt-chart-secondary)"); + builder.OpenElement(seq++, "title"); + builder.AddContent(seq++, $"{point.Period:yyyy-MM}: maintenance {point.MaintenanceCost:F2}"); + builder.CloseElement(); + builder.CloseElement(); + + var fuelY = maintenanceY - stackGap - fuelHeight; + builder.OpenElement(seq++, "rect"); + builder.AddAttribute(seq++, "x", x.ToString("F1")); + builder.AddAttribute(seq++, "y", fuelY.ToString("F1")); + builder.AddAttribute(seq++, "width", barWidth.ToString("F1")); + builder.AddAttribute(seq++, "height", fuelHeight.ToString("F1")); + builder.AddAttribute(seq++, "fill", "var(--kt-accent)"); + builder.OpenElement(seq++, "title"); + builder.AddContent(seq++, $"{point.Period:yyyy-MM}: fuel {point.FuelCost:F2}"); + builder.CloseElement(); + builder.CloseElement(); + } + + builder.CloseElement(); + }; +} diff --git a/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css new file mode 100644 index 0000000..073f299 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css @@ -0,0 +1,87 @@ +/* Sheet-style history grid: compact, always-editable cells so it reads as a spreadsheet rather than the + app's usual click-to-open-a-modal pattern - the user explicitly asked for something close to the Excel + sheet they used to track this in. */ +.kt-car-sheet .kt-sheet-table { + font-size: 0.85rem; +} + +.kt-car-sheet .kt-sheet-table th { + white-space: nowrap; + color: var(--kt-text-muted); + font-weight: 600; +} + +/* Rows/cells below are rendered by the child CarHistoryRow component, not this file's own markup - CSS + isolation scopes stop at a component boundary, so these need ::deep to reach in. */ +.kt-car-sheet ::deep td { + padding: 0.25rem 0.4rem; + vertical-align: middle; +} + +.kt-car-sheet ::deep input:not([type="checkbox"]), +.kt-car-sheet ::deep select { + min-width: 5.5rem; +} + +/* Without this, the checkbox inherits Bootstrap's .form-check-input full-width block sizing inside a table + cell with no surrounding .form-check wrapper, stretching into a giant pill instead of a small square. */ +.kt-car-sheet ::deep input[type="checkbox"] { + width: 1rem; + height: 1rem; + min-width: 0; + margin: 0; +} + +.kt-car-sheet ::deep .kt-history-row-warning td { + background: var(--kt-warning-bg); +} + +.kt-car-sheet ::deep .kt-history-warning-icon { + color: var(--kt-warning); + cursor: help; +} + +.kt-callout { + background: var(--kt-surface-2); + border-radius: var(--kt-radius); + padding: 0.6rem 0.9rem; + margin: 0 0 0.75rem 0; + font-size: 0.9rem; +} + +.kt-callout-warning { + background: var(--kt-warning-bg); + color: var(--kt-warning); +} + +.kt-callout-danger { + background: var(--kt-danger-bg); + color: var(--kt-danger); +} + +/* Built via RenderTreeBuilder (RenderConsumptionChart/RenderCostHistoryChart), not literal markup in this + file, so these elements never receive this component's CSS-isolation scope attribute either - ::deep + again, for the same reason as the sheet rows above. */ +::deep .kt-consumption-chart, +::deep .kt-cost-chart { + width: 100%; + height: 100px; + display: block; +} + +.kt-chart-legend { + display: flex; + gap: 1rem; + font-size: 0.8rem; + color: var(--kt-text-muted); + margin-bottom: 0.4rem; +} + +.kt-legend-swatch { + display: inline-block; + width: 0.7rem; + height: 0.7rem; + border-radius: 2px; + margin-right: 0.3rem; + vertical-align: middle; +} diff --git a/src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor b/src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor new file mode 100644 index 0000000..c524efd --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor @@ -0,0 +1,86 @@ +@* One row of the car history sheet. New entries are added via a modal (CarDetail.razor), not an inline row + here, so every row rendered by this component is already persisted and edits commit immediately. *@ + + + + + + + + + @if (ShowFuel) + { + @if (Entry.EventType == CarHistoryType.Refuel) + { + + + } + else + { + + + } + } + @if (ShowElectric) + { + @if (Entry.EventType == CarHistoryType.Refuel) + { + + + } + else + { + + + } + } + + @if (Entry.EventType == CarHistoryType.Refuel) + { + + } + + + + @if (Entry.EventType == CarHistoryType.Refuel) + { + + } + + + + + + + @if (HasWarning) + { + ⚠ + } + + + + + + +@code { + [Parameter] public required CarHistoryDto Entry { get; set; } + + [Parameter] public required bool ShowFuel { get; set; } + + [Parameter] public required bool ShowElectric { get; set; } + + [Parameter] public bool HasWarning { get; set; } + + [Parameter] public string? WarningMessage { get; set; } + + [Parameter] public EventCallback OnSave { get; set; } + + [Parameter] public EventCallback OnDelete { get; set; } + + private async Task SaveAsync() => await OnSave.InvokeAsync(Entry); +} diff --git a/src/BlazorApp/Components/Inventory/Pages/Cars.razor b/src/BlazorApp/Components/Inventory/Pages/Cars.razor new file mode 100644 index 0000000..91d17f7 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/Cars.razor @@ -0,0 +1,96 @@ +@page "/cars" +@inherits InventoryPageBase +@rendermode InteractiveServer +@attribute [Authorize] + + + + Name + Manufacturer + Model + Year + License plate + Energy + + + + + @car.Name + + @car.Manufacturer + @car.Model + @car.Year + @car.LicensePlate + @car.EnergyType + + + +
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ + +
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+

Manage energy type and history from the car's detail page.

+ + diff --git a/src/BlazorApp/Components/Inventory/Pages/Cars.razor.cs b/src/BlazorApp/Components/Inventory/Pages/Cars.razor.cs new file mode 100644 index 0000000..72895cd --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/Cars.razor.cs @@ -0,0 +1,52 @@ +using Keeptrack.WebApi.Contracts.Dto; +using Microsoft.AspNetCore.Components; + +namespace Keeptrack.BlazorApp.Components.Inventory.Pages; + +public partial class Cars : InventoryPageBase +{ + [Inject] private CarApiClient CarApi { get; set; } = null!; + + [Inject] private NavigationManager Nav { get; set; } = null!; + + protected override InventoryApiClientBase Api => CarApi; + + /// + /// Creating a car only ever captures identity fields here (see FormTemplate) - energy type and + /// history are added on the detail page, so a successful create navigates straight there instead of + /// closing the form and staying on the list (same as VideoGames.razor.cs's SaveAsync). + /// + protected override async Task SaveAsync() + { + try + { + if (_form.Id is null) + { + var created = await CarApi.AddAsync(_form); + _showForm = false; + Nav.NavigateTo($"/cars/{created.Id}"); + } + else + { + await CarApi.UpdateAsync(_form); + _showForm = false; + await LoadAsync(); + } + } + catch (Exception ex) + { + _error = ex.Message; + } + } + + protected override CarDto CloneItem(CarDto item) => new() + { + Id = item.Id, + Name = item.Name, + Manufacturer = item.Manufacturer, + Model = item.Model, + Year = item.Year, + LicensePlate = item.LicensePlate, + EnergyType = item.EnergyType + }; +} diff --git a/src/BlazorApp/Components/Layout/NavMenu.razor b/src/BlazorApp/Components/Layout/NavMenu.razor index 314f145..f9b3399 100644 --- a/src/BlazorApp/Components/Layout/NavMenu.razor +++ b/src/BlazorApp/Components/Layout/NavMenu.razor @@ -54,6 +54,11 @@ ◆ Video games
+
+ + ◉ Cars + +
⬆ Import diff --git a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index d42cf51..989c1b2 100644 --- a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -9,6 +9,10 @@ internal static void AddWebApiHttpClient(this IServiceCollection services, strin .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) diff --git a/src/BlazorApp/wwwroot/app.css b/src/BlazorApp/wwwroot/app.css index 4c08bd3..8b3bbed 100644 --- a/src/BlazorApp/wwwroot/app.css +++ b/src/BlazorApp/wwwroot/app.css @@ -25,6 +25,7 @@ --kt-success-bg: #dcefe4; --kt-warning: #9a6b00; --kt-warning-bg: #f7ecd2; + --kt-chart-secondary: #8a5fd1; --kt-radius: 10px; --kt-radius-lg: 14px; --kt-shadow: 0 2px 10px rgba(15, 18, 25, 0.06); @@ -65,6 +66,7 @@ --kt-success-bg: rgba(76, 180, 137, 0.16); --kt-warning: #e0be5b; --kt-warning-bg: rgba(224, 190, 91, 0.16); + --kt-chart-secondary: #b39ce8; --kt-shadow: 0 4px 20px rgba(0, 0, 0, 0.35); --kt-shadow-lg: 0 16px 48px rgba(0, 0, 0, 0.5); diff --git a/src/Domain/Models/CarCostHistoryPointModel.cs b/src/Domain/Models/CarCostHistoryPointModel.cs new file mode 100644 index 0000000..6052c79 --- /dev/null +++ b/src/Domain/Models/CarCostHistoryPointModel.cs @@ -0,0 +1,18 @@ +using System; + +namespace Keeptrack.Domain.Models; + +/// +/// Total cost of ownership for one calendar month - fuel/electric spend and maintenance/other spend tracked +/// separately as well as combined, so the UI can show a breakdown, not just a total. +/// +public class CarCostHistoryPointModel +{ + public required DateOnly Period { get; set; } + + public required double FuelCost { get; set; } + + public required double MaintenanceCost { get; set; } + + public double TotalCost => FuelCost + MaintenanceCost; +} diff --git a/src/Domain/Models/CarEnergyType.cs b/src/Domain/Models/CarEnergyType.cs new file mode 100644 index 0000000..83150a5 --- /dev/null +++ b/src/Domain/Models/CarEnergyType.cs @@ -0,0 +1,8 @@ +namespace Keeptrack.Domain.Models; + +public enum CarEnergyType +{ + Combustion, + Hybrid, + Electric +} diff --git a/src/Domain/Models/CarHistoryModel.cs b/src/Domain/Models/CarHistoryModel.cs index 0af144f..be8042a 100644 --- a/src/Domain/Models/CarHistoryModel.cs +++ b/src/Domain/Models/CarHistoryModel.cs @@ -1,4 +1,4 @@ -using System; +using System; using Keeptrack.Common.System; namespace Keeptrack.Domain.Models; @@ -11,11 +11,15 @@ public class CarHistoryModel : IHasIdAndOwnerId public required string CarId { get; set; } - public DateOnly HistoryDate { get; set; } + public required DateOnly HistoryDate { get; set; } public int? Mileage { get; set; } - public required string Action { get; set; } + public required CarHistoryType EventType { get; set; } + + public string? Description { get; set; } + + public double? Cost { get; set; } public string? City { get; set; } @@ -29,13 +33,20 @@ public class CarHistoryModel : IHasIdAndOwnerId public double? FuelUnitPrice { get; set; } - public double? Amount { get; set; } + public double? ElectricVolume { get; set; } - public bool? IsFullTank { get; set; } + public double? ElectricUnitPrice { get; set; } - public double? DeltaMileage { get; set; } + public bool? IsFullRefill { get; set; } - public string? LastRefuelHistoryId { get; set; } + /// + /// Distance driven since the previous history entry, as recorded by the user directly (typically read off + /// the car's own trip computer at refuel time) - independent of the odometer reading in . + /// Kept deliberately as real input, not derived: cross-checks + /// it against consecutive readings to catch a mistyped entry or a refuel that was never + /// logged at all - the same manual check the user used to do by hand in a spreadsheet. + /// + public double? DeltaMileage { get; set; } public string? StationBrandName { get; set; } } diff --git a/src/Domain/Models/CarHistoryType.cs b/src/Domain/Models/CarHistoryType.cs new file mode 100644 index 0000000..f2d57b9 --- /dev/null +++ b/src/Domain/Models/CarHistoryType.cs @@ -0,0 +1,8 @@ +namespace Keeptrack.Domain.Models; + +public enum CarHistoryType +{ + Refuel, + Maintenance, + Other +} diff --git a/src/Domain/Models/CarMetricsModel.cs b/src/Domain/Models/CarMetricsModel.cs new file mode 100644 index 0000000..8d60705 --- /dev/null +++ b/src/Domain/Models/CarMetricsModel.cs @@ -0,0 +1,22 @@ +using System.Collections.Generic; + +namespace Keeptrack.Domain.Models; + +public class CarMetricsModel +{ + public required List FuelConsumption { get; set; } + + public double? AverageFuelConsumptionPer100Km { get; set; } + + public required List ElectricConsumption { get; set; } + + public double? AverageElectricConsumptionPer100Km { get; set; } + + public required List CostHistory { get; set; } + + public required double TotalCost { get; set; } + + public required List MileageWarnings { get; set; } + + public NextMaintenanceModel? NextMaintenance { get; set; } +} diff --git a/src/Domain/Models/CarMileageWarningModel.cs b/src/Domain/Models/CarMileageWarningModel.cs new file mode 100644 index 0000000..2f482c4 --- /dev/null +++ b/src/Domain/Models/CarMileageWarningModel.cs @@ -0,0 +1,13 @@ +namespace Keeptrack.Domain.Models; + +/// +/// Flags a CarHistory entry whose recorded mileage doesn't reconcile with its neighbors, so the user can fix +/// the underlying entry - see CarMetricsService. Advisory only: the flagged entry is never excluded from +/// metrics or corrected automatically. +/// +public class CarMileageWarningModel +{ + public required string CarHistoryId { get; set; } + + public required string Message { get; set; } +} diff --git a/src/Domain/Models/CarModel.cs b/src/Domain/Models/CarModel.cs index 71c133a..c445140 100644 --- a/src/Domain/Models/CarModel.cs +++ b/src/Domain/Models/CarModel.cs @@ -1,4 +1,4 @@ -using Keeptrack.Common.System; +using Keeptrack.Common.System; namespace Keeptrack.Domain.Models; @@ -9,4 +9,14 @@ public class CarModel : IHasIdAndOwnerId public required string OwnerId { get; set; } public required string Name { get; set; } + + public string? Manufacturer { get; set; } + + public string? Model { get; set; } + + public int? Year { get; set; } + + public string? LicensePlate { get; set; } + + public required CarEnergyType EnergyType { get; set; } } diff --git a/src/Domain/Models/ConsumptionPointModel.cs b/src/Domain/Models/ConsumptionPointModel.cs new file mode 100644 index 0000000..e3e9ada --- /dev/null +++ b/src/Domain/Models/ConsumptionPointModel.cs @@ -0,0 +1,14 @@ +using System; + +namespace Keeptrack.Domain.Models; + +/// +/// One consumption data point, always computed across a full refill/recharge (never a partial one) - see +/// CarMetricsService. +/// +public class ConsumptionPointModel +{ + public required DateOnly Date { get; set; } + + public required double ValuePer100Km { get; set; } +} diff --git a/src/Domain/Models/NextMaintenanceModel.cs b/src/Domain/Models/NextMaintenanceModel.cs new file mode 100644 index 0000000..774c9eb --- /dev/null +++ b/src/Domain/Models/NextMaintenanceModel.cs @@ -0,0 +1,16 @@ +using System; + +namespace Keeptrack.Domain.Models; + +/// +/// Estimated next maintenance due date, assuming a fixed 1-year cadence from the last recorded maintenance +/// event. Only ever produced when a maintenance history actually exists - see CarMetricsService. +/// +public class NextMaintenanceModel +{ + public required DateOnly LastMaintenanceDate { get; set; } + + public required DateOnly DueDate { get; set; } + + public required int MonthsRemaining { get; set; } +} diff --git a/src/Domain/Services/CarMetricsService.cs b/src/Domain/Services/CarMetricsService.cs new file mode 100644 index 0000000..943641c --- /dev/null +++ b/src/Domain/Services/CarMetricsService.cs @@ -0,0 +1,170 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Keeptrack.Domain.Models; + +namespace Keeptrack.Domain.Services; + +/// +/// Computes fuel/electric consumption, cost history, mileage-consistency warnings and a next-maintenance-due +/// estimate from a car's full intervention history. Pure computation over an in-memory list, same shape as +/// WatchNextService - nothing here is persisted, so a car's metrics are always derived fresh from its history. +/// +public class CarMetricsService +{ + private const double MileageToleranceKm = 1; + + public CarMetricsModel ComputeMetrics(IEnumerable history) + { + var historyList = history.ToList(); + + return new CarMetricsModel + { + FuelConsumption = ComputeConsumption(historyList, h => h.FuelVolume, out var averageFuel), + AverageFuelConsumptionPer100Km = averageFuel, + ElectricConsumption = ComputeConsumption(historyList, h => h.ElectricVolume, out var averageElectric), + AverageElectricConsumptionPer100Km = averageElectric, + CostHistory = ComputeCostHistory(historyList), + TotalCost = historyList.Sum(h => h.Cost ?? 0), + MileageWarnings = ComputeMileageWarnings(historyList), + NextMaintenance = ComputeNextMaintenanceDue(historyList) + }; + } + + /// + /// Shared trip-computer algorithm for both fuel (liters) and electric (kWh) consumption - a data point is + /// only ever emitted across a full refill/recharge (): the + /// quantity added by every refill since the last full one is accumulated, and once a full refill closes + /// that window, the accumulated quantity is divided by the mileage covered since the previous full refill. + /// A partial refill on its own never produces a data point. + /// + private static List ComputeConsumption( + IReadOnlyList history, Func quantitySelector, out double? average) + { + var refuels = history + .Where(h => h.EventType == CarHistoryType.Refuel && h.Mileage is not null && quantitySelector(h) is not null) + .OrderBy(h => h.Mileage) + .ToList(); + + var points = new List(); + var quantitySinceLastFullRefill = 0.0; + CarHistoryModel? lastFullRefill = null; + + foreach (var refuel in refuels) + { + quantitySinceLastFullRefill += quantitySelector(refuel)!.Value; + + if (refuel.IsFullRefill != true) continue; + + if (lastFullRefill is not null) + { + var distance = refuel.Mileage!.Value - lastFullRefill.Mileage!.Value; + if (distance > 0) + { + points.Add(new ConsumptionPointModel + { + Date = refuel.HistoryDate, + ValuePer100Km = quantitySinceLastFullRefill / distance * 100 + }); + } + } + + lastFullRefill = refuel; + quantitySinceLastFullRefill = 0; + } + + average = points.Count > 0 ? points.Average(p => p.ValuePer100Km) : null; + return points; + } + + private static List ComputeCostHistory(IReadOnlyList history) => + history + .Where(h => h.Cost is not null) + .GroupBy(h => new DateOnly(h.HistoryDate.Year, h.HistoryDate.Month, 1)) + .OrderBy(g => g.Key) + .Select(g => new CarCostHistoryPointModel + { + Period = g.Key, + FuelCost = g.Where(h => h.EventType == CarHistoryType.Refuel).Sum(h => h.Cost!.Value), + MaintenanceCost = g.Where(h => h.EventType != CarHistoryType.Refuel).Sum(h => h.Cost!.Value) + }) + .ToList(); + + /// + /// The automated version of the manual Excel cross-check the user used to do by hand: a regression check + /// (the odometer can never go backwards) plus a delta cross-check between the user-entered + /// (typically read off the car's trip computer at refuel time) + /// and the computed mileage difference between consecutive entries. A mismatch means either number was + /// mistyped, or - if the computed delta is larger than the entered one - an entry was never logged at all. + /// Advisory only: nothing here excludes an entry from the metrics above or corrects it automatically. + /// + private static List ComputeMileageWarnings(IReadOnlyList history) + { + var ordered = history + .Where(h => h.Mileage is not null) + .OrderBy(h => h.HistoryDate) + .ToList(); + + var warnings = new List(); + + for (var i = 1; i < ordered.Count; i++) + { + var previous = ordered[i - 1]; + var current = ordered[i]; + + if (current.Mileage < previous.Mileage) + { + warnings.Add(new CarMileageWarningModel + { + CarHistoryId = current.Id!, + Message = $"Mileage {current.Mileage} on {current.HistoryDate} is lower than {previous.Mileage} " + + $"recorded on {previous.HistoryDate}." + }); + continue; + } + + if (current.DeltaMileage is null) continue; + + var computedDelta = current.Mileage!.Value - previous.Mileage!.Value; + if (Math.Abs(computedDelta - current.DeltaMileage.Value) <= MileageToleranceKm) continue; + + var suggestsMissingEntry = computedDelta > current.DeltaMileage.Value; + warnings.Add(new CarMileageWarningModel + { + CarHistoryId = current.Id!, + Message = $"Entered delta mileage ({current.DeltaMileage}) doesn't match the {computedDelta} " + + $"difference between this entry's mileage ({current.Mileage}) and the previous entry's " + + $"({previous.Mileage} on {previous.HistoryDate})." + + (suggestsMissingEntry ? " An entry may be missing in between." : " Check both entries for a typo.") + }); + } + + return warnings; + } + + /// + /// Assumes a fixed 1-year maintenance cadence from the last recorded maintenance event. Returns null - never + /// a guess - when no maintenance history exists yet, same "don't guess without data" principle as + /// WatchNextService. + /// + private static NextMaintenanceModel? ComputeNextMaintenanceDue(IReadOnlyList history) + { + var lastMaintenance = history + .Where(h => h.EventType == CarHistoryType.Maintenance) + .OrderByDescending(h => h.HistoryDate) + .FirstOrDefault(); + + if (lastMaintenance is null) return null; + + var dueDate = lastMaintenance.HistoryDate.AddYears(1); + var today = DateOnly.FromDateTime(DateTime.Today); + var monthsRemaining = ((dueDate.Year - today.Year) * 12) + (dueDate.Month - today.Month); + + return new NextMaintenanceModel + { + LastMaintenanceDate = lastMaintenance.HistoryDate, + DueDate = dueDate, + MonthsRemaining = monthsRemaining + }; + } +} diff --git a/src/Infrastructure.MongoDb/Entities/Car.cs b/src/Infrastructure.MongoDb/Entities/Car.cs index fac6fe0..246bc6d 100644 --- a/src/Infrastructure.MongoDb/Entities/Car.cs +++ b/src/Infrastructure.MongoDb/Entities/Car.cs @@ -1,4 +1,5 @@ -using Keeptrack.Common.System; +using Keeptrack.Common.System; +using Keeptrack.Domain.Models; using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; @@ -15,4 +16,16 @@ public class Car : IHasIdAndOwnerId [BsonElement("commercial_name")] public required string Name { get; set; } + + public string? Manufacturer { get; set; } + + public string? Model { get; set; } + + public int? Year { get; set; } + + [BsonElement("license_plate")] + public string? LicensePlate { get; set; } + + [BsonElement("energy_type")] + public required CarEnergyType EnergyType { get; set; } } diff --git a/src/Infrastructure.MongoDb/Entities/CarHistory.cs b/src/Infrastructure.MongoDb/Entities/CarHistory.cs index 43fd919..bc7fd60 100644 --- a/src/Infrastructure.MongoDb/Entities/CarHistory.cs +++ b/src/Infrastructure.MongoDb/Entities/CarHistory.cs @@ -1,6 +1,6 @@ -using System; -using System.Collections.Generic; +using System; using Keeptrack.Common.System; +using Keeptrack.Domain.Models; using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; @@ -19,15 +19,18 @@ public class CarHistory : IHasIdAndOwnerId public required string CarId { get; set; } [BsonElement("history_date")] - public DateTime HistoryDate { get; set; } + public required DateTime HistoryDate { get; set; } public double? Mileage { get; set; } - public required string Action { get; set; } + [BsonElement("event_type")] + public required CarHistoryType EventType { get; set; } - public CarHistoryLocation? Location { get; set; } + public string? Description { get; set; } + + public double? Cost { get; set; } - public List? Coordinates { get; set; } + public CarHistoryLocation? Location { get; set; } public CarHistoryFuel? Fuel { get; set; } diff --git a/src/Infrastructure.MongoDb/Entities/CarHistoryFuel.cs b/src/Infrastructure.MongoDb/Entities/CarHistoryFuel.cs index 9fb1150..635032c 100644 --- a/src/Infrastructure.MongoDb/Entities/CarHistoryFuel.cs +++ b/src/Infrastructure.MongoDb/Entities/CarHistoryFuel.cs @@ -1,25 +1,25 @@ -using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; namespace Keeptrack.Infrastructure.MongoDb.Entities; public class CarHistoryFuel { - public required string Category { get; set; } + public string? Category { get; set; } public double? Volume { get; set; } [BsonElement("unit_price")] public double? UnitPrice { get; set; } - public double? Amount { get; set; } + [BsonElement("electric_volume")] + public double? ElectricVolume { get; set; } - [BsonElement("is_full_tank")] - public bool? IsFullTank { get; set; } + [BsonElement("electric_unit_price")] + public double? ElectricUnitPrice { get; set; } + + [BsonElement("is_full_refill")] + public bool? IsFullRefill { get; set; } [BsonElement("delta_mileage")] public double? DeltaMileage { get; set; } - - [BsonElement("last_refuel_history_id")] - public ObjectId? LastRefuelHistoryId { get; set; } } diff --git a/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs b/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs index 3f2f76b..ce9d28c 100644 --- a/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs +++ b/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs @@ -1,6 +1,10 @@ -namespace Keeptrack.Infrastructure.MongoDb.Entities; +using System.Collections.Generic; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; public class CarHistoryLocation { public required string City { get; set; } + + public List? Coordinates { get; set; } } diff --git a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs index f69adac..3b662e0 100644 --- a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs @@ -16,8 +16,12 @@ protected override FilterDefinition GetFilter(string ownerId, string { var builder = Builders.Filter; var filter = builder.Eq(f => f.OwnerId, ownerId); - if (!string.IsNullOrEmpty(input.CarId)) filter &= builder.Text(input.CarId); - if (!string.IsNullOrEmpty(search)) filter &= builder.Text(search); + if (!string.IsNullOrEmpty(input.CarId)) filter &= builder.Eq(f => f.CarId, input.CarId); + if (!string.IsNullOrEmpty(search)) + { + filter &= builder.Where(f => f.Description != null + && f.Description.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + } return filter; } } diff --git a/src/Infrastructure.MongoDb/Repositories/CarRepository.cs b/src/Infrastructure.MongoDb/Repositories/CarRepository.cs index 8cf4982..93d284d 100644 --- a/src/Infrastructure.MongoDb/Repositories/CarRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/CarRepository.cs @@ -11,4 +11,12 @@ public class CarRepository(IMongoDatabase mongoDatabase, ILogger(mongoDatabase, logger, mapper), ICarRepository { protected override string CollectionName => "car"; + + protected override FilterDefinition GetFilter(string ownerId, string? search, CarModel input) + { + var builder = Builders.Filter; + var filter = builder.Eq(f => f.OwnerId, ownerId); + if (!string.IsNullOrEmpty(search)) filter &= builder.Where(f => f.Name.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + return filter; + } } diff --git a/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs b/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs index 9afcdb2..3b11104 100644 --- a/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs +++ b/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs @@ -25,10 +25,19 @@ public abstract class MongoDbRepositoryBase( private IMapper Mapper { get; } = mapper; + /// + /// "Not found" must stay a real null, not a mapped default instance: AllowNullDestinationValues + /// = false (Program.cs) makes Mapper.Map<TModel>(entity) return a new, all-default + /// instead of null when itself is null - the same + /// gotcha already guarded against in the reference-data repositories' own Find* methods, just not here + /// yet. Without this guard, every controller's GetById "not found" check silently returned 200 + /// with a blank object instead of 404 for any entity type - caught via CarResourceTest, not a + /// mocked unit test, since a mocked repository never exercises the real mapping configuration. + /// public async Task FindOneAsync(string id, string ownerId) { - var entities = await GetCollection().FindAsync(x => x.Id == id && x.OwnerId == ownerId); - return Mapper.Map(await entities.FirstOrDefaultAsync()); + var entity = await GetCollection().Find(x => x.Id == id && x.OwnerId == ownerId).FirstOrDefaultAsync(); + return entity is null ? default : Mapper.Map(entity); } public async Task> FindAllAsync(string ownerId, int page, int pageSize, string? search, TModel input) diff --git a/src/WebApi.Contracts/Dto/CarCostHistoryPointDto.cs b/src/WebApi.Contracts/Dto/CarCostHistoryPointDto.cs new file mode 100644 index 0000000..f02d2a6 --- /dev/null +++ b/src/WebApi.Contracts/Dto/CarCostHistoryPointDto.cs @@ -0,0 +1,29 @@ +using System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Total cost of ownership for one calendar month. +/// +public class CarCostHistoryPointDto +{ + /// + /// First day of the month this point covers. + /// + public required DateOnly Period { get; set; } + + /// + /// Fuel/electric spend for the month. + /// + public required double FuelCost { get; set; } + + /// + /// Maintenance/other spend for the month. + /// + public required double MaintenanceCost { get; set; } + + /// + /// Combined spend for the month. + /// + public required double TotalCost { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/CarDto.cs b/src/WebApi.Contracts/Dto/CarDto.cs index a46a047..1d9fb71 100644 --- a/src/WebApi.Contracts/Dto/CarDto.cs +++ b/src/WebApi.Contracts/Dto/CarDto.cs @@ -1,4 +1,4 @@ -using Keeptrack.Common.System; +using Keeptrack.Common.System; namespace Keeptrack.WebApi.Contracts.Dto; @@ -16,4 +16,29 @@ public class CarDto : IHasId /// Car name. /// public string? Name { get; set; } + + /// + /// Manufacturer. + /// + public string? Manufacturer { get; set; } + + /// + /// Model. + /// + public string? Model { get; set; } + + /// + /// Year. + /// + public int? Year { get; set; } + + /// + /// License plate. + /// + public string? LicensePlate { get; set; } + + /// + /// Energy type (Combustion, Hybrid, Electric). + /// + public CarEnergyType? EnergyType { get; set; } } diff --git a/src/WebApi.Contracts/Dto/CarEnergyType.cs b/src/WebApi.Contracts/Dto/CarEnergyType.cs new file mode 100644 index 0000000..3389edf --- /dev/null +++ b/src/WebApi.Contracts/Dto/CarEnergyType.cs @@ -0,0 +1,16 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Car energy type. +/// +public enum CarEnergyType +{ + /// Combustion (petrol/diesel) engine. + Combustion, + + /// Hybrid (combustion + electric). + Hybrid, + + /// Fully electric. + Electric +} diff --git a/src/WebApi.Contracts/Dto/CarHistoryDto.cs b/src/WebApi.Contracts/Dto/CarHistoryDto.cs index b2c2685..9fc3a97 100644 --- a/src/WebApi.Contracts/Dto/CarHistoryDto.cs +++ b/src/WebApi.Contracts/Dto/CarHistoryDto.cs @@ -1,4 +1,4 @@ -using System; +using System; using Keeptrack.Common.System; namespace Keeptrack.WebApi.Contracts.Dto; @@ -21,7 +21,7 @@ public class CarHistoryDto : IHasId /// /// History date. /// - public DateOnly HistoryDate { get; set; } + public required DateOnly HistoryDate { get; set; } /// /// Mileage indicated on the car. @@ -29,9 +29,19 @@ public class CarHistoryDto : IHasId public int? Mileage { get; set; } /// - /// Action made on the car. + /// Event type (Refuel, Maintenance, Other). /// - public required string Action { get; set; } + public required CarHistoryType EventType { get; set; } + + /// + /// Free-text description of what was done - the main field for Maintenance/Other events. + /// + public string? Description { get; set; } + + /// + /// Total cost of this event (fuel/electric fill-up, invoice, ...). + /// + public double? Cost { get; set; } /// /// City. @@ -49,39 +59,40 @@ public class CarHistoryDto : IHasId public double? Latitude { get; set; } /// - /// Fuel category. + /// Fuel category (e.g. Diesel, SP95). /// public string? FuelCategory { get; set; } /// - /// Fuel volme (L). + /// Fuel volume (L). /// public double? FuelVolume { get; set; } /// - /// Fuel unit price. + /// Fuel unit price (per L). /// public double? FuelUnitPrice { get; set; } /// - /// Amount. + /// Electric energy added (kWh). /// - public double? Amount { get; set; } + public double? ElectricVolume { get; set; } /// - /// Is full tank? + /// Electric unit price (per kWh). /// - public bool? IsFullTank { get; set; } + public double? ElectricUnitPrice { get; set; } /// - /// Delta mileage since last refuel. + /// Is this a full tank / full charge refill? /// - public double? DeltaMileage { get; set; } + public bool? IsFullRefill { get; set; } /// - /// Last refuel history id. + /// Distance driven since the previous entry, as recorded by the user (e.g. from the car's trip computer) - + /// independent of the odometer reading in , used to cross-check it. /// - public string? LastRefuelHistoryId { get; set; } + public double? DeltaMileage { get; set; } /// /// Station brand name. diff --git a/src/WebApi.Contracts/Dto/CarHistoryType.cs b/src/WebApi.Contracts/Dto/CarHistoryType.cs new file mode 100644 index 0000000..0ec5f54 --- /dev/null +++ b/src/WebApi.Contracts/Dto/CarHistoryType.cs @@ -0,0 +1,16 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Car history event type. +/// +public enum CarHistoryType +{ + /// Fuel refill or electric recharge. + Refuel, + + /// Maintenance/service. + Maintenance, + + /// Anything else (insurance, inspection, tires, ...). + Other +} diff --git a/src/WebApi.Contracts/Dto/CarMetricsDto.cs b/src/WebApi.Contracts/Dto/CarMetricsDto.cs new file mode 100644 index 0000000..0509319 --- /dev/null +++ b/src/WebApi.Contracts/Dto/CarMetricsDto.cs @@ -0,0 +1,49 @@ +using System.Collections.Generic; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Computed metrics for one car: consumption, cost history, mileage warnings and next-maintenance estimate. +/// +public class CarMetricsDto +{ + /// + /// Fuel consumption over time (L/100km), computed only across full refills. + /// + public required List FuelConsumption { get; set; } + + /// + /// Average fuel consumption (L/100km), or null if there isn't enough data yet. + /// + public double? AverageFuelConsumptionPer100Km { get; set; } + + /// + /// Electric consumption over time (kWh/100km), computed only across full recharges. + /// + public required List ElectricConsumption { get; set; } + + /// + /// Average electric consumption (kWh/100km), or null if there isn't enough data yet. + /// + public double? AverageElectricConsumptionPer100Km { get; set; } + + /// + /// Total cost of ownership, by month. + /// + public required List CostHistory { get; set; } + + /// + /// Total cost across the whole history. + /// + public required double TotalCost { get; set; } + + /// + /// Entries whose recorded mileage doesn't reconcile with their neighbors. + /// + public required List MileageWarnings { get; set; } + + /// + /// Estimated next maintenance due, or null if no maintenance has been recorded yet. + /// + public NextMaintenanceDto? NextMaintenance { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/CarMileageWarningDto.cs b/src/WebApi.Contracts/Dto/CarMileageWarningDto.cs new file mode 100644 index 0000000..ff68f92 --- /dev/null +++ b/src/WebApi.Contracts/Dto/CarMileageWarningDto.cs @@ -0,0 +1,18 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Flags a car history entry whose recorded mileage doesn't reconcile with its neighbors. Advisory only - the +/// entry is never excluded from metrics or corrected automatically; the user reviews and fixes it themselves. +/// +public class CarMileageWarningDto +{ + /// + /// ID of the flagged car history entry. + /// + public required string CarHistoryId { get; set; } + + /// + /// Human-readable explanation of the mismatch. + /// + public required string Message { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/ConsumptionPointDto.cs b/src/WebApi.Contracts/Dto/ConsumptionPointDto.cs new file mode 100644 index 0000000..8d4cc90 --- /dev/null +++ b/src/WebApi.Contracts/Dto/ConsumptionPointDto.cs @@ -0,0 +1,19 @@ +using System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// One consumption data point, always computed across a full refill/recharge. +/// +public class ConsumptionPointDto +{ + /// + /// Date of the full refill/recharge that closed this data point. + /// + public required DateOnly Date { get; set; } + + /// + /// Consumption per 100 km (liters for fuel, kWh for electric). + /// + public required double ValuePer100Km { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/NextMaintenanceDto.cs b/src/WebApi.Contracts/Dto/NextMaintenanceDto.cs new file mode 100644 index 0000000..a5e7b13 --- /dev/null +++ b/src/WebApi.Contracts/Dto/NextMaintenanceDto.cs @@ -0,0 +1,24 @@ +using System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Estimated next maintenance due date, assuming a fixed 1-year cadence from the last recorded maintenance event. +/// +public class NextMaintenanceDto +{ + /// + /// Date of the last recorded maintenance event. + /// + public required DateOnly LastMaintenanceDate { get; set; } + + /// + /// Estimated due date for the next maintenance. + /// + public required DateOnly DueDate { get; set; } + + /// + /// Months remaining until the due date (negative if overdue). + /// + public required int MonthsRemaining { get; set; } +} diff --git a/src/WebApi/Controllers/CarController.cs b/src/WebApi/Controllers/CarController.cs new file mode 100644 index 0000000..bed8645 --- /dev/null +++ b/src/WebApi/Controllers/CarController.cs @@ -0,0 +1,38 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Domain.Services; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Controllers; + +[ApiController] +[Authorize] +[Route("api/cars")] +public class CarController( + IMapper mapper, + ICarRepository dataRepository, + ICarHistoryRepository carHistoryRepository, + CarMetricsService metricsService) + : DataCrudControllerBase(mapper, dataRepository) +{ + /// + /// Computed fuel/electric consumption, cost history, mileage warnings and next-maintenance estimate for + /// this car - see . + /// + [HttpGet("{id}/metrics")] + [ProducesResponseType(200)] + [ProducesResponseType(404)] + public async Task> GetMetrics(string id) + { + var ownerId = this.GetUserId(); + + var car = await dataRepository.FindOneAsync(id, ownerId); + if (car is null) return NotFound(); + + var history = await carHistoryRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, + new CarHistoryModel { OwnerId = ownerId, CarId = id, EventType = default, HistoryDate = default }); + + return Ok(Mapper.Map(metricsService.ComputeMetrics(history.Items))); + } +} diff --git a/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs index 3815dd5..2802f33 100644 --- a/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs +++ b/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs @@ -25,17 +25,25 @@ private void MapCarHistoryModel() .ForMember(x => x.City, opt => opt.MapFrom( x => x.Location != null ? x.Location.City : null)) .ForMember(x => x.Longitude, opt => opt.MapFrom( - x => x.Coordinates != null ? x.Coordinates[0] : (double?)null)) + x => x.Location != null && x.Location.Coordinates != null ? x.Location.Coordinates[0] : (double?)null)) .ForMember(x => x.Latitude, opt => opt.MapFrom( - x => x.Coordinates != null ? x.Coordinates[1] : (double?)null)) - .ForMember(x => x.Amount, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.Amount : null)) - .ForMember(x => x.IsFullTank, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.IsFullTank : null)) + x => x.Location != null && x.Location.Coordinates != null ? x.Location.Coordinates[1] : (double?)null)) + .ForMember(x => x.FuelCategory, opt => opt.MapFrom( + x => x.Fuel != null ? x.Fuel.Category : null)) + .ForMember(x => x.FuelVolume, opt => opt.MapFrom( + x => x.Fuel != null ? x.Fuel.Volume : null)) + .ForMember(x => x.FuelUnitPrice, opt => opt.MapFrom( + x => x.Fuel != null ? x.Fuel.UnitPrice : null)) + .ForMember(x => x.ElectricVolume, opt => opt.MapFrom( + x => x.Fuel != null ? x.Fuel.ElectricVolume : null)) + .ForMember(x => x.ElectricUnitPrice, opt => opt.MapFrom( + x => x.Fuel != null ? x.Fuel.ElectricUnitPrice : null)) + .ForMember(x => x.IsFullRefill, opt => opt.MapFrom( + x => x.Fuel != null ? x.Fuel.IsFullRefill : null)) .ForMember(x => x.DeltaMileage, opt => opt.MapFrom( x => x.Fuel != null ? x.Fuel.DeltaMileage : null)) - .ForMember(x => x.LastRefuelHistoryId, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.LastRefuelHistoryId : null)); + .ForMember(x => x.StationBrandName, opt => opt.MapFrom( + x => x.Station != null ? x.Station.BrandName : null)); } private void MapCarHistory() @@ -43,14 +51,26 @@ private void MapCarHistory() CreateMap() .ForMember(x => x.Location, opt => opt.MapFrom( x => x)) - .ForMember(x => x.Coordinates, opt => opt.MapFrom( - x => (x.Longitude.HasValue && x.Latitude.HasValue) ? new List { x.Longitude.Value, x.Latitude.Value } : null)) .ForMember(x => x.Fuel, opt => opt.MapFrom( x => x)) .ForMember(x => x.Station, opt => opt.MapFrom( x => x)); - CreateMap(); + // Coordinates lives inside CarHistoryLocation (alongside City) - both are location data, so both + // belong in the one sub-document instead of Coordinates sitting as a separate sibling field on + // CarHistory itself, which was the original (unreviewed) shape. + CreateMap() + .ForMember(x => x.Coordinates, opt => + { + // AllowNull() is required here: AllowNullDestinationValues = false (Program.cs) otherwise + // substitutes a new empty List for a null MapFrom result (same class of gotcha as + // ReferenceMatchModel.Creator, documented in CLAUDE.md) - MapCarHistoryModel's reverse mapping + // reads Coordinates[0]/[1] guarded by "!= null", which an empty (not null) list defeats, + // throwing IndexOutOfRange the moment Longitude/Latitude are unset. Caught by a real-MongoDB + // CarHistoryResourceTest create/read round-trip, not by a mocked unit test. + opt.MapFrom(x => (x.Longitude.HasValue && x.Latitude.HasValue) ? new List { x.Longitude.Value, x.Latitude.Value } : null); + opt.AllowNull(); + }); CreateMap() .ForMember(x => x.Category, opt => opt.MapFrom( diff --git a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs index d31feb1..c2de262 100644 --- a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs +++ b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs @@ -59,6 +59,19 @@ public WebServiceMappingProfile() // computation with no Dto dependency, so WatchNextController maps its result here. CreateMap(); + // Car metrics reads are one-directional (Model -> Dto), same reasoning as WatchNext above: + // CarMetricsService is a pure Domain-level computation with no Dto dependency. + // NextMaintenance needs AllowNull() for the same reason ReferenceMatchModel.Creator does (see + // Program.cs's AllowNullDestinationValues = false): without it, a null NextMaintenance model (no + // maintenance recorded yet) maps to a new, all-default NextMaintenanceDto instead of staying null - + // caught by CarResourceTest against a real car with no history, not by a mocked unit test. + CreateMap() + .ForMember(x => x.NextMaintenance, opt => opt.AllowNull()); + CreateMap(); + CreateMap(); + CreateMap(); + CreateMap(); + // Reference-data reads are one-directional (Model -> Dto): admins submit a LinkReferenceRequestDto, // never a full TvShowReferenceDto/MovieReferenceDto, so there's no Dto -> Model direction to map. CreateMap(); diff --git a/src/WebApi/Program.cs b/src/WebApi/Program.cs index e56320a..360afd7 100644 --- a/src/WebApi/Program.cs +++ b/src/WebApi/Program.cs @@ -21,6 +21,7 @@ opts.BackgroundServiceExceptionBehavior = Microsoft.Extensions.Hosting.BackgroundServiceExceptionBehavior.Ignore); builder.Services.AddSingleton(); builder.Services.AddSingleton(); +builder.Services.AddSingleton(); builder.Services.AddSingleton>(); builder.Services.AddSingleton>(); builder.Services.AddScoped(); diff --git a/test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs b/test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs new file mode 100644 index 0000000..3b7b9cd --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs @@ -0,0 +1,116 @@ +using System; +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Keeptrack.Common.System; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Basic full-cycle CRUD coverage for CarHistory, plus a regression test for the specific bug tracked +/// in docs/code-quality-findings.md: CarHistoryRepository.GetFilter used to combine two $text +/// expressions (one for CarId, one for the free-text search) in a single query, which MongoDB rejects +/// whenever both are supplied at once. +/// +public class CarHistoryResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + private const string ResourceEndpoint = "api/car-history"; + + private static CarHistoryDto NewEntry(string carId, CarHistoryType eventType = CarHistoryType.Refuel) => new() + { + CarId = carId, + HistoryDate = DateOnly.FromDateTime(DateTime.Today), + EventType = eventType, + Mileage = 1000, + Cost = 42.5, + Description = "Test entry" + }; + + [Fact] + public async Task CarHistoryResourceFullCycle_IsOk() + { + await GetAsync($"/{ResourceEndpoint}", HttpStatusCode.Unauthorized); + + await Authenticate(); + + // CarId is a required field on CarHistoryDto, so - same as Episode's required TvShowId - the list + // endpoint can only ever be called scoped to a car; a bare, unscoped list call isn't a real scenario + // this app has (CarDetail.razor always filters by CarId), and ASP.NET's automatic model validation + // rejects it with 400 ("The CarId field is required") before the request even reaches the repository. + var carId = Guid.NewGuid().ToString(); + var initialItems = await GetAsync>($"/{ResourceEndpoint}?CarId={carId}"); + + var created = await PostAsync($"/{ResourceEndpoint}", NewEntry(carId)); + created.Id.Should().NotBeNullOrEmpty(); + + try + { + created.Cost = 55.0; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + updated.Should().BeEquivalentTo(created); + + var finalItems = await GetAsync>($"/{ResourceEndpoint}?CarId={carId}"); + finalItems.TotalCount.Should().BeGreaterThan(initialItems.TotalCount); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + [Fact] + public async Task CarHistoryResourceFilter_ByCarId_OnlyReturnsThatCarsEntries_IsOk() + { + await Authenticate(); + + var carId = Guid.NewGuid().ToString(); + var otherCarId = Guid.NewGuid().ToString(); + var created = await PostAsync($"/{ResourceEndpoint}", NewEntry(carId)); + var otherCreated = await PostAsync($"/{ResourceEndpoint}", NewEntry(otherCarId)); + + try + { + var results = await GetAsync>($"/{ResourceEndpoint}?CarId={carId}"); + results.Items.Should().ContainSingle(x => x.Id == created.Id); + results.Items.Should().NotContain(x => x.Id == otherCreated.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + await DeleteAsync($"/{ResourceEndpoint}/{otherCreated.Id}"); + } + } + + /// + /// The actual regression case: supplying both a CarId filter and a free-text search at the same time used + /// to throw ("only one $text expression allowed per query") because both were built as $text clauses. + /// + [Fact] + public async Task CarHistoryResourceFilter_ByCarIdAndSearch_DoesNotThrow_IsOk() + { + await Authenticate(); + + var carId = Guid.NewGuid().ToString(); + var description = Guid.NewGuid().ToString(); + var entry = NewEntry(carId); + entry.Description = description; + var created = await PostAsync($"/{ResourceEndpoint}", entry); + + try + { + var results = await GetAsync>($"/{ResourceEndpoint}?CarId={carId}&search={description}"); + results.Items.Should().ContainSingle(x => x.Id == created.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } +} diff --git a/test/WebApi.IntegrationTests/Resources/CarResourceTest.cs b/test/WebApi.IntegrationTests/Resources/CarResourceTest.cs new file mode 100644 index 0000000..10e976a --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/CarResourceTest.cs @@ -0,0 +1,124 @@ +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Bogus; +using Keeptrack.Common.System; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Basic full-cycle CRUD coverage for Car - closes the "Car has no controller or Blazor page" / +/// "no CRUD integration test" findings tracked in docs/code-quality-findings.md, same shape as +/// . +/// +public class CarResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + private const string ResourceEndpoint = "api/cars"; + + [Fact] + public async Task CarResourceFullCycle_IsOk() + { + await GetAsync($"/{ResourceEndpoint}", HttpStatusCode.Unauthorized); + + await Authenticate(); + + var initialItems = await GetAsync>($"/{ResourceEndpoint}"); + + var input = new Faker() + .Rules((f, o) => + { + o.Name = f.Random.AlphaNumeric(14); + o.Manufacturer = f.Vehicle.Manufacturer(); + o.Model = f.Vehicle.Model(); + o.Year = f.Random.Int(1990, 2024); + o.LicensePlate = f.Random.AlphaNumeric(8); + o.EnergyType = CarEnergyType.Combustion; + }) + .Generate(); + var created = await PostAsync($"/{ResourceEndpoint}", input); + created.Id.Should().NotBeNullOrEmpty(); + + try + { + created.Name = "New shiny name"; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + updated.Should().BeEquivalentTo(created); + + var finalItems = await GetAsync>($"/{ResourceEndpoint}"); + finalItems.TotalCount.Should().BeGreaterThan(initialItems.TotalCount); + var firstItem = finalItems.Items.FirstOrDefault(x => x.Id == updated.Id); + firstItem.Should().NotBeNull(); + firstItem.Name.Should().Be(updated.Name); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + /// + /// CarRepository previously had no GetFilter override at all, so search silently fell back to the base + /// class's $text query against an index that didn't even cover Car's field name (see + /// docs/code-quality-findings.md) - this proves a name search now actually finds the car. + /// + [Fact] + public async Task CarResourceSearch_FiltersByName_IsOk() + { + await Authenticate(); + + var name = System.Guid.NewGuid().ToString(); + var created = await PostAsync($"/{ResourceEndpoint}", new CarDto { Name = name }); + + try + { + var results = await GetAsync>($"/{ResourceEndpoint}?search={name}"); + results.Items.Should().ContainSingle(x => x.Id == created.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + [Fact] + public async Task CarResourceMetrics_ReturnsNotFound_ForACarThatDoesNotExist() + { + await Authenticate(); + + // a freshly generated, syntactically valid ObjectId that can't collide with any real document - a + // malformed id (e.g. a GUID) throws a MongoDB BSON FormatException instead of a clean 404, a + // pre-existing gap in MongoDbRepositoryBase shared by every entity type, not something introduced by + // Car; out of scope to fix here. (A fixed all-zeros id was tried first and turned out to already + // exist as fixture data in the shared integration test database, masking the actual check.) + await GetAsync($"/{ResourceEndpoint}/{MongoDB.Bson.ObjectId.GenerateNewId()}/metrics", HttpStatusCode.NotFound); + } + + [Fact] + public async Task CarResourceMetrics_ReturnsEmptyMetrics_ForACarWithNoHistoryYet() + { + await Authenticate(); + + var created = await PostAsync($"/{ResourceEndpoint}", new CarDto { Name = System.Guid.NewGuid().ToString() }); + + try + { + var metrics = await GetAsync($"/{ResourceEndpoint}/{created.Id}/metrics"); + metrics.FuelConsumption.Should().BeEmpty(); + metrics.ElectricConsumption.Should().BeEmpty(); + metrics.CostHistory.Should().BeEmpty(); + metrics.MileageWarnings.Should().BeEmpty(); + metrics.NextMaintenance.Should().BeNull(); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } +} diff --git a/test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs b/test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs new file mode 100644 index 0000000..18557c5 --- /dev/null +++ b/test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs @@ -0,0 +1,189 @@ +using System; +using AwesomeAssertions; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Services; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Services; + +[Trait("Category", "UnitTests")] +public class CarMetricsServiceTest +{ + private readonly CarMetricsService _service = new(); + + private static CarHistoryModel Refuel( + string id, DateOnly date, int mileage, + double? fuelVolume = null, double? electricVolume = null, bool isFullRefill = true, + double? deltaMileage = null, double? cost = null) => + new() + { + Id = id, + OwnerId = "owner", + CarId = "car-1", + HistoryDate = date, + Mileage = mileage, + EventType = CarHistoryType.Refuel, + FuelVolume = fuelVolume, + ElectricVolume = electricVolume, + IsFullRefill = isFullRefill, + DeltaMileage = deltaMileage, + Cost = cost + }; + + private static CarHistoryModel Maintenance(string id, DateOnly date, int? mileage = null, double? cost = null) => + new() { Id = id, OwnerId = "owner", CarId = "car-1", HistoryDate = date, Mileage = mileage, EventType = CarHistoryType.Maintenance, Cost = cost }; + + [Fact] + public void ComputeMetrics_FuelConsumption_OnlyEmitsAPointAcrossAFullRefill() + { + var history = new[] + { + Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40, isFullRefill: true), + Refuel("h2", new DateOnly(2024, 1, 15), 1200, fuelVolume: 20, isFullRefill: false), + Refuel("h3", new DateOnly(2024, 2, 1), 1400, fuelVolume: 25, isFullRefill: true) + }; + + var result = _service.ComputeMetrics(history); + + result.FuelConsumption.Should().ContainSingle(); + result.FuelConsumption[0].ValuePer100Km.Should().BeApproximately(11.25, 0.001); + result.AverageFuelConsumptionPer100Km.Should().BeApproximately(11.25, 0.001); + } + + [Fact] + public void ComputeMetrics_FuelAndElectricConsumption_AreComputedIndependentlyForAHybrid() + { + var history = new[] + { + Refuel("f1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40, isFullRefill: true), + Refuel("f2", new DateOnly(2024, 2, 1), 1500, fuelVolume: 35, isFullRefill: true), + Refuel("e1", new DateOnly(2024, 1, 10), 1100, electricVolume: 15, isFullRefill: true), + Refuel("e2", new DateOnly(2024, 1, 20), 1300, electricVolume: 30, isFullRefill: true) + }; + + var result = _service.ComputeMetrics(history); + + result.FuelConsumption.Should().ContainSingle(); + result.FuelConsumption[0].ValuePer100Km.Should().BeApproximately(35.0 / 500 * 100, 0.001); + + result.ElectricConsumption.Should().ContainSingle(); + result.ElectricConsumption[0].ValuePer100Km.Should().BeApproximately(30.0 / 200 * 100, 0.001); + } + + [Fact] + public void ComputeMetrics_CostHistory_GroupsByMonthAndSplitsFuelFromMaintenance() + { + var history = new[] + { + Refuel("h1", new DateOnly(2024, 1, 5), 1000, fuelVolume: 40, cost: 60), + Maintenance("h2", new DateOnly(2024, 1, 20), 1050, cost: 150), + Refuel("h3", new DateOnly(2024, 2, 5), 1500, fuelVolume: 40, cost: 65) + }; + + var result = _service.ComputeMetrics(history); + + result.CostHistory.Should().HaveCount(2); + var january = result.CostHistory[0]; + january.Period.Should().Be(new DateOnly(2024, 1, 1)); + january.FuelCost.Should().Be(60); + january.MaintenanceCost.Should().Be(150); + january.TotalCost.Should().Be(210); + + result.TotalCost.Should().Be(275); + } + + [Fact] + public void ComputeMetrics_NextMaintenance_IsNullWhenNoMaintenanceHistoryExists() + { + var history = new[] { Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40) }; + + var result = _service.ComputeMetrics(history); + + result.NextMaintenance.Should().BeNull(); + } + + [Fact] + public void ComputeMetrics_NextMaintenance_IsOneYearAfterTheLastMaintenanceEvent() + { + var lastMaintenance = DateOnly.FromDateTime(DateTime.Today).AddMonths(-10); + var history = new[] { Maintenance("h1", lastMaintenance) }; + + var result = _service.ComputeMetrics(history); + + result.NextMaintenance.Should().NotBeNull(); + result.NextMaintenance!.LastMaintenanceDate.Should().Be(lastMaintenance); + result.NextMaintenance.DueDate.Should().Be(lastMaintenance.AddYears(1)); + result.NextMaintenance.MonthsRemaining.Should().Be(2); + } + + [Fact] + public void ComputeMetrics_NextMaintenance_ReportsNegativeMonthsWhenOverdue() + { + var lastMaintenance = DateOnly.FromDateTime(DateTime.Today).AddMonths(-14); + var history = new[] { Maintenance("h1", lastMaintenance) }; + + var result = _service.ComputeMetrics(history); + + result.NextMaintenance!.MonthsRemaining.Should().Be(-2); + } + + [Fact] + public void ComputeMetrics_MileageWarnings_FlagsAnOdometerRegression() + { + var history = new[] + { + Refuel("h1", new DateOnly(2024, 1, 1), 5000, fuelVolume: 40), + Refuel("h2", new DateOnly(2024, 2, 1), 4800, fuelVolume: 40) + }; + + var result = _service.ComputeMetrics(history); + + result.MileageWarnings.Should().ContainSingle(w => w.CarHistoryId == "h2"); + } + + [Fact] + public void ComputeMetrics_MileageWarnings_FlagsADeltaMismatchAndSuggestsAMissingEntry() + { + // the trip computer says 300 km since the last refuel, but the odometer jumped 900 km since the + // previous entry in the app - a refuel was very likely never logged in between + var history = new[] + { + Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40), + Refuel("h2", new DateOnly(2024, 2, 1), 1900, fuelVolume: 40, deltaMileage: 300) + }; + + var result = _service.ComputeMetrics(history); + + result.MileageWarnings.Should().ContainSingle(w => w.CarHistoryId == "h2"); + result.MileageWarnings[0].Message.Should().Contain("missing"); + } + + [Fact] + public void ComputeMetrics_MileageWarnings_FlagsADeltaMismatchWithoutSuggestingAMissingEntryWhenSmaller() + { + var history = new[] + { + Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40), + Refuel("h2", new DateOnly(2024, 2, 1), 1300, fuelVolume: 40, deltaMileage: 500) + }; + + var result = _service.ComputeMetrics(history); + + result.MileageWarnings.Should().ContainSingle(w => w.CarHistoryId == "h2"); + result.MileageWarnings[0].Message.Should().NotContain("missing"); + } + + [Fact] + public void ComputeMetrics_MileageWarnings_IsSilentWhenDeltaMileageMatchesWithinTolerance() + { + var history = new[] + { + Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40), + Refuel("h2", new DateOnly(2024, 2, 1), 1500, fuelVolume: 40, deltaMileage: 500.4) + }; + + var result = _service.ComputeMetrics(history); + + result.MileageWarnings.Should().BeEmpty(); + } +} From e18a7ced142f28abb5089721a69192038ad4e4de Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Thu, 9 Jul 2026 22:02:14 +0200 Subject: [PATCH 27/44] Car import, house feature, and chart/UI fixes --- CLAUDE.md | 4 + Directory.Packages.props | 1 + scripts/mongodb-create-index.js | 5 + .../Import/CarHistoryImportApiClient.cs | 20 + .../Components/Import/ImportPage.razor | 71 ++++ .../Inventory/Clients/HouseApiClient.cs | 15 + .../Clients/HouseHistoryApiClient.cs | 9 + .../Inventory/Pages/CarDetail.razor | 281 +++++++++----- .../Inventory/Pages/CarDetail.razor.css | 83 +--- .../Inventory/Pages/CarHistoryRow.razor | 77 +--- .../Inventory/Pages/HouseDetail.razor | 361 ++++++++++++++++++ .../Inventory/Pages/HouseHistoryRow.razor | 24 ++ .../Components/Inventory/Pages/Houses.razor | 92 +++++ .../Inventory/Pages/Houses.razor.cs | 52 +++ .../Inventory/Shared/InventoryList.razor | 19 +- src/BlazorApp/Components/Layout/NavMenu.razor | 5 + .../Components/Shared/ConfirmModal.razor | 41 ++ .../Components/Shared/SvgChartHelpers.cs | 150 ++++++++ src/BlazorApp/Components/_Imports.razor | 1 + ...frastructureServiceCollectionExtensions.cs | 6 + src/BlazorApp/wwwroot/app.css | 77 ++++ src/Domain/Models/CarHistoryModel.cs | 17 +- src/Domain/Models/HouseCategoryCostModel.cs | 8 + .../Models/HouseCostHistoryPointModel.cs | 16 + src/Domain/Models/HouseEventType.cs | 11 + src/Domain/Models/HouseHistoryModel.cs | 28 ++ src/Domain/Models/HouseMetricsModel.cs | 8 + src/Domain/Models/HouseModel.cs | 22 ++ .../Repositories/ICarHistoryRepository.cs | 9 +- .../Repositories/IHouseHistoryRepository.cs | 14 + src/Domain/Repositories/IHouseRepository.cs | 7 + src/Domain/Services/CarMetricsService.cs | 13 +- src/Domain/Services/HouseMetricsService.cs | 34 ++ .../Entities/CarHistory.cs | 2 + .../Entities/CarHistoryLocation.cs | 6 + src/Infrastructure.MongoDb/Entities/House.cs | 28 ++ .../Entities/HouseHistory.cs | 32 ++ .../Repositories/CarHistoryRepository.cs | 8 + .../Repositories/HouseHistoryRepository.cs | 35 ++ .../Repositories/HouseRepository.cs | 22 ++ src/WebApi.Contracts/Dto/CarHistoryDto.cs | 20 +- .../Dto/CarHistoryImportResultDto.cs | 20 + .../Dto/HouseCategoryCostDto.cs | 17 + .../Dto/HouseCostHistoryPointDto.cs | 24 ++ src/WebApi.Contracts/Dto/HouseDto.cs | 44 +++ src/WebApi.Contracts/Dto/HouseEventType.cs | 16 + src/WebApi.Contracts/Dto/HouseHistoryDto.cs | 45 +++ src/WebApi.Contracts/Dto/HouseMetricsDto.cs | 14 + src/WebApi/Controllers/CarController.cs | 7 + .../Controllers/DataCrudControllerBase.cs | 10 +- src/WebApi/Controllers/HouseController.cs | 44 +++ .../Controllers/HouseHistoryController.cs | 12 + ...frastructureServiceCollectionExtensions.cs | 2 + .../Import/CarHistoryImportController.cs | 36 ++ src/WebApi/Import/CarHistoryImportService.cs | 254 ++++++++++++ .../CarDataStorageMappingProfile.cs | 10 + .../HouseDataStorageMappingProfile.cs | 25 ++ .../WebServiceMappingProfile.cs | 14 + src/WebApi/Program.cs | 2 + src/WebApi/WebApi.csproj | 1 + .../Resources/CarHistoryResourceTest.cs | 2 +- .../Resources/HouseHistoryResourceTest.cs | 103 +++++ .../Resources/HouseResourceTest.cs | 130 +++++++ .../Services/CarMetricsServiceTest.cs | 46 +-- .../Services/HouseMetricsServiceTest.cs | 74 ++++ 65 files changed, 2412 insertions(+), 274 deletions(-) create mode 100644 src/BlazorApp/Components/Import/CarHistoryImportApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Clients/HouseApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Clients/HouseHistoryApiClient.cs create mode 100644 src/BlazorApp/Components/Inventory/Pages/HouseDetail.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/HouseHistoryRow.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/Houses.razor create mode 100644 src/BlazorApp/Components/Inventory/Pages/Houses.razor.cs create mode 100644 src/BlazorApp/Components/Shared/ConfirmModal.razor create mode 100644 src/BlazorApp/Components/Shared/SvgChartHelpers.cs create mode 100644 src/Domain/Models/HouseCategoryCostModel.cs create mode 100644 src/Domain/Models/HouseCostHistoryPointModel.cs create mode 100644 src/Domain/Models/HouseEventType.cs create mode 100644 src/Domain/Models/HouseHistoryModel.cs create mode 100644 src/Domain/Models/HouseMetricsModel.cs create mode 100644 src/Domain/Models/HouseModel.cs create mode 100644 src/Domain/Repositories/IHouseHistoryRepository.cs create mode 100644 src/Domain/Repositories/IHouseRepository.cs create mode 100644 src/Domain/Services/HouseMetricsService.cs create mode 100644 src/Infrastructure.MongoDb/Entities/House.cs create mode 100644 src/Infrastructure.MongoDb/Entities/HouseHistory.cs create mode 100644 src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs create mode 100644 src/Infrastructure.MongoDb/Repositories/HouseRepository.cs create mode 100644 src/WebApi.Contracts/Dto/CarHistoryImportResultDto.cs create mode 100644 src/WebApi.Contracts/Dto/HouseCategoryCostDto.cs create mode 100644 src/WebApi.Contracts/Dto/HouseCostHistoryPointDto.cs create mode 100644 src/WebApi.Contracts/Dto/HouseDto.cs create mode 100644 src/WebApi.Contracts/Dto/HouseEventType.cs create mode 100644 src/WebApi.Contracts/Dto/HouseHistoryDto.cs create mode 100644 src/WebApi.Contracts/Dto/HouseMetricsDto.cs create mode 100644 src/WebApi/Controllers/HouseController.cs create mode 100644 src/WebApi/Controllers/HouseHistoryController.cs create mode 100644 src/WebApi/Import/CarHistoryImportController.cs create mode 100644 src/WebApi/Import/CarHistoryImportService.cs create mode 100644 src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs create mode 100644 test/WebApi.IntegrationTests/Resources/HouseHistoryResourceTest.cs create mode 100644 test/WebApi.IntegrationTests/Resources/HouseResourceTest.cs create mode 100644 test/WebApi.UnitTests/Services/HouseMetricsServiceTest.cs diff --git a/CLAUDE.md b/CLAUDE.md index 5afb4c2..46b218c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -92,6 +92,10 @@ Follow the existing types (`Book`, `Movie`, `Album`, `TvShow`, `VideoGame`, `Car `CarHistoryModel.EventType` (`CarHistoryType`: `Refuel`/`Maintenance`/`Other`) is a real discriminated enum, not free text — the same "never name a property/field bare `Type`" rule as any other discriminator in this codebase (see `TvShowModel.State`'s own rename history above): a bare `Type` reads ambiguously and collides in spirit with `object.GetType()`/`System.Type`. `Car.EnergyType` (`CarEnergyType`: `Combustion`/`Hybrid`/`Electric`) and `CarHistoryModel.EventType`/`CarId`/`HistoryDate` are all `required` on both the Domain model and the Mongo entity; `CarDto` itself can't mirror `Name`/`EnergyType` as `required`, because `Cars.razor` extends `InventoryPageBase`, which needs a bare `new()` constraint — a type with *any* `required` member can't satisfy `new()` in C#, so the Dto layer stays nullable there by hard language necessity, not by choice (`CarHistoryDto` has no such constraint, so it mirrors `required` in full). `CarHistoryModel.DeltaMileage` is real user-entered data (typically read off the car's own trip computer at refuel time), not a derived/computed field, kept specifically so `Domain/Services/CarMetricsService.cs` can cross-check it against consecutive `Mileage` readings and flag a likely typo or a skipped entry — the automated version of a manual spreadsheet cross-check, and the reason this field was kept rather than dropped as "unused" during review. `CarMetricsService` (consumption — only ever computed across a full refill/recharge, never a partial one — cost-of-ownership history, mileage warnings, next-maintenance-due) follows `WatchNextService`'s shape: a plain, `AddSingleton`-registered, unit-tested pure computation class with no persistence of its own, exposed via `CarController.GetMetrics` the same way `VideoGameController.RefreshReference` adds an extra per-item action to an entity's own CRUD controller instead of a separate cross-entity controller. +`House`/`HouseHistory` (owned-by-a-parent, same shape as `Car`/`CarHistory` above) is a deliberately smaller sibling, not a second copy of Car's design: the priority (confirmed with the owner) is an exhaustive, browsable action log for insurance purposes plus a yearly cost review, not fuel/mileage tracking or reminders - the owner tracks recurring bills/maintenance schedules elsewhere and explicitly asked for reminders to stay out of scope ("keep it simple, not important, I manage it elsewhere"). Concretely: `HouseHistoryModel` has no `Mileage`/`DeltaMileage`/fuel fields, no location sub-fields (a house doesn't move, unlike a car's refuel stops), and `Domain/Services/HouseMetricsService.cs` has no `ComputeNextMaintenanceDue`-style due-date engine - it only computes `ComputeAnnualCostHistory` (cost per year, broken down by `HouseEventType`: `Maintenance`/`Installation`/`Rework`/`Purchase`/`Bill`/`Other`). `HouseHistoryModel.HistoryDate` stays `DateOnly` (not `DateTime` like `CarHistoryModel.HistoryDate`) - House has no Car-style same-day-multiple-entries ordering need (a road trip's several refuel stops), so it reuses the app's existing global `DateOnly<->DateTime` UTC-stamping AutoMapper converter for free instead of Car's bespoke `DateTime.SpecifyKind` `ForMember`/`ModalTimeText` "HH:mm" proxy machinery. `HouseHistoryModel.Provider` is a single field (contractor/technician/utility company/store name) covering every category, unlike Car's Refuel-only `StationBrandName` vs. Maintenance-only `Garage` split - House has no event type where "who was involved" doesn't apply, so one field suffices. + +`HouseDetail.razor`'s yearly cost chart is a single-series bar chart (total cost per year) plus a plain HTML breakdown table underneath (rows = years, columns = the 6 categories + total), not a 6-color stacked bar chart - a stacked chart with that many categories would be visually noisy and add real code, and the table already carries the actual per-category precision an insurance review needs at a glance. The chart's axis-drawing code (`ChartGeometry`, `RenderAxes`, `EvenlySpacedIndices`) was extracted from `CarDetail.razor` into `src/BlazorApp/Components/Shared/SvgChartHelpers.cs` specifically so House's chart wouldn't duplicate it - the CLAUDE.md "no duplicated algorithms" quality bar applies to Razor-hosted chart code the same as any other logic. Only the axis/geometry math moved; each page's own series-drawing loop (Car's stacked 2-series cost bars, Car's single-series consumption line, House's single-series year bars) stays local, since that part differs enough per chart that forcing one shared renderer would have been the over-generalization the quality bar warns against. The shared CSS these charts need (`.kt-callout*`, `.kt-chart-axis-text`/`-title`, `.kt-chart-svg`, `.kt-sheet-table`, `.kt-chart-legend`/`.kt-legend-swatch`) moved from `CarDetail.razor.css` into `app.css` as plain global rules for the same reason - and as a side benefit, no longer need `::deep` to reach into child `*Row` components' markup, since global (non-isolated) CSS was never scoped to begin with. + ### Reference data (shared, owner-less) `tvshow_reference` and `movie_reference` (`Domain/Models/TvShowReferenceModel.cs`/`MovieReferenceModel.cs`, `Infrastructure.MongoDb/Entities/TvShowReference.cs`/`MovieReference.cs`) hold metadata (synopsis, episode titles) fetched from TMDB. They are the one deliberate exception to "every collection has `owner_id`": this data is public facts about a real show/movie, not user content, so storing it once and pointing every tenant's `TvShowModel.ReferenceId`/`MovieModel.ReferenceId` at it avoids duplicating the same show across every user who tracks it. Matching key is normalized title + year (`TitleNormalizer.Normalize`, `Common.System/TitleNormalizer.cs` — shared with `TvTimeImportService` so the two never drift on what counts as "the same title"). The rest of this section walks through the mechanics using TV shows/movies/TMDB as the concrete example; `book_reference`/`videogame_reference`/`album_reference` (Open Library/RAWG/Discogs) follow the identical shape - see "Reference data now covers five domains" further down for what's shared versus what's provider-specific. diff --git a/Directory.Packages.props b/Directory.Packages.props index d3372e0..d85cff8 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -8,6 +8,7 @@ + diff --git a/scripts/mongodb-create-index.js b/scripts/mongodb-create-index.js index f32b9c4..aa1118e 100644 --- a/scripts/mongodb-create-index.js +++ b/scripts/mongodb-create-index.js @@ -22,6 +22,8 @@ ensureIndex(db.album, { owner_id: 1 }, { name: "album_owner" }); ensureIndex(db.book, { owner_id: 1 }, { name: "book_owner" }); ensureIndex(db.car, { owner_id: 1 }, { name: "car_owner" }); ensureIndex(db.car_history, { owner_id: 1 }, { name: "car_history_owner" }); +ensureIndex(db.house, { owner_id: 1 }, { name: "house_owner" }); +ensureIndex(db.house_history, { owner_id: 1 }, { name: "house_history_owner" }); ensureIndex(db.movie, { owner_id: 1 }, { name: "movie_owner" }); ensureIndex(db.tvshow, { owner_id: 1 }, { name: "tvshow_owner" }); ensureIndex(db.videogame, { owner_id: 1 }, { name: "videogame_owner" }); @@ -36,6 +38,9 @@ ensureIndex(db.playlist, { owner_id: 1 }, { name: "playlist_owner" }); // index never covered anything and CarRepository/CarHistoryRepository no longer fall back to $text, so it // was removed rather than repointed. +// house / house_history: same regex-filter search shape as car/car_history above - no text index needed here +// either, for the same reason. + // episode: enforces the (show, season, episode) natural key and makes re-imports idempotent at the database level ensureIndex( db.episode, diff --git a/src/BlazorApp/Components/Import/CarHistoryImportApiClient.cs b/src/BlazorApp/Components/Import/CarHistoryImportApiClient.cs new file mode 100644 index 0000000..7dd605f --- /dev/null +++ b/src/BlazorApp/Components/Import/CarHistoryImportApiClient.cs @@ -0,0 +1,20 @@ +using System.Net.Http.Headers; +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Import; + +public sealed class CarHistoryImportApiClient(HttpClient http) +{ + public async Task ImportAsync(Stream xlsxStream, string fileName) + { + using var content = new MultipartFormDataContent(); + using var fileContent = new StreamContent(xlsxStream); + fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"); + content.Add(fileContent, "file", fileName); + + var response = await http.PostAsync("/api/import/car-history", content); + response.EnsureSuccessStatusCode(); + + return (await response.Content.ReadFromJsonAsync())!; + } +} diff --git a/src/BlazorApp/Components/Import/ImportPage.razor b/src/BlazorApp/Components/Import/ImportPage.razor index dbb05ed..2d93acc 100644 --- a/src/BlazorApp/Components/Import/ImportPage.razor +++ b/src/BlazorApp/Components/Import/ImportPage.razor @@ -53,17 +53,67 @@ }
+
+

Import car history

+
+ +
+

+ Upload the personal "Voitures.xlsx" spreadsheet (fuel/maintenance history per car). + Only run this once per car - re-uploading the same file will duplicate the history entries. +

+ +
+ ⬆ + +
+ + @if (_carImporting) + { +

Importing…

+ } + + @if (_carError is not null) + { +
@_carError
+ } + + @if (_carResult is not null) + { +
+

Cars: @_carResult.CarsCreated created, @_carResult.CarsSkipped already existed

+

History entries created: @_carResult.HistoryEntriesCreated

+ @if (_carResult.Warnings.Count > 0) + { +
+

Good to know:

+
    + @foreach (var warning in _carResult.Warnings) + { +
  • @warning
    • + } +
+ } +
+ } +
+ @code { private const long MaxFileSize = 50_000_000; private static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(600); [Inject] private TvTimeImportApiClient ImportApi { get; set; } = null!; + [Inject] private CarHistoryImportApiClient CarImportApi { get; set; } = null!; private bool _importing; private string? _error; private ImportResultDto? _result; private ImportStage _stage; + private bool _carImporting; + private string? _carError; + private CarHistoryImportResultDto? _carResult; + private async Task OnFileSelectedAsync(InputFileChangeEventArgs e) { _importing = true; @@ -110,6 +160,27 @@ } } + private async Task OnCarFileSelectedAsync(InputFileChangeEventArgs e) + { + _carImporting = true; + _carError = null; + _carResult = null; + + try + { + await using var stream = e.File.OpenReadStream(MaxFileSize); + _carResult = await CarImportApi.ImportAsync(stream, e.File.Name); + } + catch (Exception ex) + { + _carError = ex.Message; + } + finally + { + _carImporting = false; + } + } + private static int ProgressPercent(ImportStage stage) => stage switch { ImportStage.Parsing => 10, diff --git a/src/BlazorApp/Components/Inventory/Clients/HouseApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/HouseApiClient.cs new file mode 100644 index 0000000..6024e8f --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Clients/HouseApiClient.cs @@ -0,0 +1,15 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Inventory.Clients; + +public class HouseApiClient(HttpClient http) + : InventoryApiClientBase(http) +{ + protected override string ApiResourceName => "/api/houses"; + + public async Task GetMetricsAsync(string id) + { + var result = await Http.GetFromJsonAsync($"{ApiResourceName}/{id}/metrics"); + return result!; + } +} diff --git a/src/BlazorApp/Components/Inventory/Clients/HouseHistoryApiClient.cs b/src/BlazorApp/Components/Inventory/Clients/HouseHistoryApiClient.cs new file mode 100644 index 0000000..62fc4e2 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Clients/HouseHistoryApiClient.cs @@ -0,0 +1,9 @@ +using Keeptrack.WebApi.Contracts.Dto; + +namespace Keeptrack.BlazorApp.Components.Inventory.Clients; + +public sealed class HouseHistoryApiClient(HttpClient http) + : InventoryApiClientBase(http) +{ + protected override string ApiResourceName => "/api/house-history"; +} diff --git a/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor index 4b3fec0..d896520 100644 --- a/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor +++ b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor @@ -1,6 +1,7 @@ @page "/cars/{Id}" @rendermode InteractiveServer @attribute [Authorize] +@using System.Globalization @if (_loading) { @@ -76,23 +77,33 @@ else

} + @{ + var showFuelChart = ShowFuel && metrics.FuelConsumption.Count > 0; + var showElectricChart = ShowElectric && metrics.ElectricConsumption.Count > 0; + // Side-by-side (half width each) only when both charts actually render, e.g. a hybrid - + // a combustion-only or electric-only car has just one chart, which should take the full row + // instead of leaving the other half empty. + var bothConsumptionCharts = showFuelChart && showElectricChart; + var consumptionColClass = bothConsumptionCharts ? "col-md-6" : "col-12"; + var consumptionGeometry = bothConsumptionCharts ? SvgChartHelpers.HalfWidthGeometry : SvgChartHelpers.FullWidthGeometry; + }
- @if (ShowFuel && metrics.FuelConsumption.Count > 0) + @if (showFuelChart) { -
+

Fuel consumption (L/100km) - avg @metrics.AverageFuelConsumptionPer100Km?.ToString("F1")

- @RenderConsumptionChart(metrics.FuelConsumption, "var(--kt-accent)") + @RenderConsumptionChart(metrics.FuelConsumption, "var(--kt-accent)", "L/100km", "fuel", consumptionGeometry)
} - @if (ShowElectric && metrics.ElectricConsumption.Count > 0) + @if (showElectricChart) { -
+

Electric consumption (kWh/100km) - avg @metrics.AverageElectricConsumptionPer100Km?.ToString("F1")

- @RenderConsumptionChart(metrics.ElectricConsumption, "var(--kt-chart-secondary)") + @RenderConsumptionChart(metrics.ElectricConsumption, "var(--kt-chart-secondary)", "kWh/100km", "electric", consumptionGeometry)
}
@@ -120,24 +131,9 @@ else Date Mileage - Δ Mileage Event - @if (ShowFuel) - { - Fuel (L) - Fuel (€/L) - } - @if (ShowElectric) - { - Electric (kWh) - Electric (€/kWh) - } - Full? Cost - Station City - Longitude - Latitude Description @@ -146,112 +142,132 @@ else @if (_history.Count == 0) { - No history yet - add the first entry above. + No history yet - add the first entry above. } @foreach (var entry in _history) { - + OnEdit="ShowEditModal" OnDelete="DeleteEntryAsync"/> }
- @if (_showAddModal) + @if (_showModal) { -
+
-
Add history entry
- +
@(IsEditMode ? "Edit" : "Add") history entry
+
-
+
- +
-
+
+ + +
+
- +
-
- - +
+ +
@foreach (var eventType in Enum.GetValues()) { - + }
- @if (_newEntry.EventType == CarHistoryType.Refuel) + @if (_modalEntry.EventType == CarHistoryType.Refuel) { @if (ShowFuel) {
- +
- +
} @if (ShowElectric) {
- +
- +
}
- +
- - + +
} + else + { +
+ + +
+ } -
+
- + +
+
+ + +
+
+ +
- - + +
- - + +
- +
- - + +
@@ -269,10 +285,39 @@ else private CarDto? _car; private List _history = []; private CarMetricsDto? _metrics; - private CarHistoryDto _newEntry = NewEntry(""); - private bool _showAddModal; + private CarHistoryDto _modalEntry = NewEntry(""); + private bool _showModal; private Dictionary _warningsByEntryId = []; + private bool IsEditMode => !string.IsNullOrEmpty(_modalEntry.Id); + + /// Separate Date/Time proxies over the single _modalEntry.HistoryDate, so editing one doesn't + /// reset the other back to midnight - a plain @bind straight to HistoryDate would lose the time + /// whenever the date input fires (its built-in converter always parses a bare yyyy-MM-dd). + private DateOnly ModalDate + { + get => DateOnly.FromDateTime(_modalEntry.HistoryDate); + set => _modalEntry.HistoryDate = value.ToDateTime(TimeOnly.FromDateTime(_modalEntry.HistoryDate)); + } + + /// + /// A plain text "HH:mm" field rather than <input type="time"> - the native time picker's 12h/24h + /// display is decided by the browser from the OS region format, not anything this page controls (Chrome + /// and Firefox both ignore the page's own language/culture for it), so it can't be forced to 24h that + /// way. A free-text field sidesteps the native widget entirely and always reads/writes 24h. + /// + private string ModalTimeText + { + get => TimeOnly.FromDateTime(_modalEntry.HistoryDate).ToString("HH:mm"); + set + { + if (TimeOnly.TryParseExact(value, "HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out var time)) + { + _modalEntry.HistoryDate = DateOnly.FromDateTime(_modalEntry.HistoryDate).ToDateTime(time); + } + } + } + private bool ShowFuel => _car?.EnergyType != CarEnergyType.Electric; private bool ShowElectric => _car?.EnergyType is CarEnergyType.Electric or CarEnergyType.Hybrid; @@ -292,7 +337,7 @@ else private static CarHistoryDto NewEntry(string carId) => new() { CarId = carId, - HistoryDate = DateOnly.FromDateTime(DateTime.Today), + HistoryDate = DateTime.Now, EventType = CarHistoryType.Refuel }; @@ -308,7 +353,6 @@ else _warningsByEntryId = _metrics.MileageWarnings .GroupBy(w => w.CarHistoryId) .ToDictionary(g => g.Key, g => string.Join(" ", g.Select(w => w.Message))); - _newEntry = NewEntry(Id); } _loading = false; } @@ -363,32 +407,61 @@ else await SaveCarAsync(); } - /// - /// Every history mutation reloads the whole car (history + metrics) rather than patching local state - - /// an edit can change mileage-warning results and chronological order, so recomputing from the server is - /// simpler and safer than trying to keep local derived state in sync by hand. - /// - private async Task SaveEntryAsync(CarHistoryDto entry) + private void ShowAddModal() { - await CarHistoryApi.UpdateAsync(entry); - await LoadAsync(); + _modalEntry = NewEntry(Id); + _showModal = true; } - private void ShowAddModal() + /// Edits a copy, not the row's own object, so Cancel discards changes instead of leaving the + /// table showing edits that were never saved. + private void ShowEditModal(CarHistoryDto entry) { - _newEntry = NewEntry(Id); - _showAddModal = true; + _modalEntry = CloneEntry(entry); + _showModal = true; } - private void CancelAddModal() => _showAddModal = false; + private void CancelModal() => _showModal = false; - private async Task SaveNewEntryAsync() + /// + /// Every history mutation reloads the whole car (history + metrics) rather than patching local state - + /// an edit can change mileage-warning results and chronological order, so recomputing from the server is + /// simpler and safer than trying to keep local derived state in sync by hand. + /// + private async Task SaveModalEntryAsync() { - await CarHistoryApi.AddAsync(_newEntry); - _showAddModal = false; + if (IsEditMode) await CarHistoryApi.UpdateAsync(_modalEntry); + else await CarHistoryApi.AddAsync(_modalEntry); + + _showModal = false; await LoadAsync(); } + private static CarHistoryDto CloneEntry(CarHistoryDto entry) => new() + { + Id = entry.Id, + CarId = entry.CarId, + HistoryDate = entry.HistoryDate, + Mileage = entry.Mileage, + EventType = entry.EventType, + Description = entry.Description, + Cost = entry.Cost, + City = entry.City, + PostalCode = entry.PostalCode, + Country = entry.Country, + Longitude = entry.Longitude, + Latitude = entry.Latitude, + FuelCategory = entry.FuelCategory, + FuelVolume = entry.FuelVolume, + FuelUnitPrice = entry.FuelUnitPrice, + ElectricVolume = entry.ElectricVolume, + ElectricUnitPrice = entry.ElectricUnitPrice, + IsFullRefill = entry.IsFullRefill, + DeltaMileage = entry.DeltaMileage, + StationBrandName = entry.StationBrandName, + Garage = entry.Garage + }; + private async Task DeleteEntryAsync(string id) { await CarHistoryApi.DeleteAsync(id); @@ -397,29 +470,38 @@ else /// Thin hand-rolled SVG line chart - this app has no charting dependency, and one isn't worth /// adding for a couple of small, single-series trend lines. A single series needs no legend (the label - /// above the chart already names it); each point carries a native <title> tooltip. - private static RenderFragment RenderConsumptionChart(List points, string color) => builder => + /// above the chart already names it); each point carries a native <title> tooltip. Axis drawing + /// (arrowheads, ticks, titles) lives in , shared with HouseDetail.razor's + /// own chart. + private static RenderFragment RenderConsumptionChart(List points, string color, string yLabel, string chartId, SvgChartHelpers.ChartGeometry geometry) => builder => { - const double width = 100; - const double height = 36; - const double padding = 4; + var (viewWidth, viewHeight, plotLeft, plotRight, plotTop, plotBottom) = geometry; var values = points.Select(p => p.ValuePer100Km).ToList(); var min = values.Min(); var max = values.Max(); var range = max - min == 0 ? 1 : max - min; - var stepX = points.Count > 1 ? (width - 2 * padding) / (points.Count - 1) : 0; + var stepX = points.Count > 1 ? (plotRight - plotLeft) / (points.Count - 1) : 0; - double X(int i) => padding + i * stepX; - double Y(double v) => height - padding - (v - min) / range * (height - 2 * padding); + double X(int i) => plotLeft + i * stepX; + double Y(double v) => plotBottom - (v - min) / range * (plotBottom - plotTop); var linePoints = string.Join(" ", points.Select((p, i) => $"{X(i):F1},{Y(p.ValuePer100Km):F1}")); + var yTicks = Enumerable.Range(0, 4) + .Select(i => min + range * i / 3.0) + .Select(v => (Y(v), v.ToString("F1"))) + .ToList(); + var xTicks = SvgChartHelpers.EvenlySpacedIndices(points.Count, 4) + .Select(i => (X(i), points[i].Date.ToString("MMM yy"))) + .ToList(); + var seq = 0; builder.OpenElement(seq++, "svg"); - builder.AddAttribute(seq++, "viewBox", $"0 0 {width} {height}"); - builder.AddAttribute(seq++, "preserveAspectRatio", "none"); - builder.AddAttribute(seq++, "class", "kt-consumption-chart"); + builder.AddAttribute(seq++, "viewBox", $"0 0 {viewWidth} {viewHeight}"); + builder.AddAttribute(seq++, "class", "kt-chart-svg"); + + SvgChartHelpers.RenderAxes(builder, ref seq, geometry, $"kt-chart-arrow-{chartId}", "Date", yLabel, yTicks, xTicks); builder.OpenElement(seq++, "polyline"); builder.AddAttribute(seq++, "points", linePoints); @@ -452,33 +534,42 @@ else /// stacked segments so they read as distinct marks rather than one solid bar. private static RenderFragment RenderCostHistoryChart(List points) => builder => { - const double width = 100; - const double height = 36; - const double padding = 2; + var geometry = SvgChartHelpers.FullWidthGeometry; + var (viewWidth, viewHeight, plotLeft, plotRight, plotTop, plotBottom) = geometry; var maxTotal = points.Max(p => p.TotalCost); if (maxTotal <= 0) maxTotal = 1; - var barWidth = (width - 2 * padding) / points.Count * 0.7; - var gap = (width - 2 * padding) / points.Count * 0.3; + var plotWidth = plotRight - plotLeft; + var barWidth = plotWidth / points.Count * 0.7; + var gap = plotWidth / points.Count * 0.3; + + double ScaleHeight(double value) => value / maxTotal * (plotBottom - plotTop); - double ScaleHeight(double value) => value / maxTotal * (height - 2 * padding); + var yTicks = Enumerable.Range(0, 4) + .Select(i => maxTotal * i / 3.0) + .Select(v => (plotBottom - ScaleHeight(v), v.ToString("F0"))) + .ToList(); + var xTicks = SvgChartHelpers.EvenlySpacedIndices(points.Count, 5) + .Select(i => (plotLeft + i * (barWidth + gap) + barWidth / 2, points[i].Period.ToString("MMM yy"))) + .ToList(); var seq = 0; builder.OpenElement(seq++, "svg"); - builder.AddAttribute(seq++, "viewBox", $"0 0 {width} {height}"); - builder.AddAttribute(seq++, "preserveAspectRatio", "none"); - builder.AddAttribute(seq++, "class", "kt-cost-chart"); + builder.AddAttribute(seq++, "viewBox", $"0 0 {viewWidth} {viewHeight}"); + builder.AddAttribute(seq++, "class", "kt-chart-svg"); + + SvgChartHelpers.RenderAxes(builder, ref seq, geometry, "kt-chart-arrow-cost", "Month", "€", yTicks, xTicks); for (var i = 0; i < points.Count; i++) { var point = points[i]; - var x = padding + i * (barWidth + gap); + var x = plotLeft + i * (barWidth + gap); var fuelHeight = ScaleHeight(point.FuelCost); var maintenanceHeight = ScaleHeight(point.MaintenanceCost); var stackGap = point.FuelCost > 0 && point.MaintenanceCost > 0 ? 0.6 : 0; - var maintenanceY = height - padding - maintenanceHeight; + var maintenanceY = plotBottom - maintenanceHeight; builder.OpenElement(seq++, "rect"); builder.AddAttribute(seq++, "x", x.ToString("F1")); builder.AddAttribute(seq++, "y", maintenanceY.ToString("F1")); diff --git a/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css index 073f299..9307b29 100644 --- a/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css +++ b/src/BlazorApp/Components/Inventory/Pages/CarDetail.razor.css @@ -1,37 +1,7 @@ -/* Sheet-style history grid: compact, always-editable cells so it reads as a spreadsheet rather than the - app's usual click-to-open-a-modal pattern - the user explicitly asked for something close to the Excel - sheet they used to track this in. */ -.kt-car-sheet .kt-sheet-table { - font-size: 0.85rem; -} - -.kt-car-sheet .kt-sheet-table th { - white-space: nowrap; - color: var(--kt-text-muted); - font-weight: 600; -} - -/* Rows/cells below are rendered by the child CarHistoryRow component, not this file's own markup - CSS - isolation scopes stop at a component boundary, so these need ::deep to reach in. */ -.kt-car-sheet ::deep td { - padding: 0.25rem 0.4rem; - vertical-align: middle; -} - -.kt-car-sheet ::deep input:not([type="checkbox"]), -.kt-car-sheet ::deep select { - min-width: 5.5rem; -} - -/* Without this, the checkbox inherits Bootstrap's .form-check-input full-width block sizing inside a table - cell with no surrounding .form-check wrapper, stretching into a giant pill instead of a small square. */ -.kt-car-sheet ::deep input[type="checkbox"] { - width: 1rem; - height: 1rem; - min-width: 0; - margin: 0; -} - +/* Mileage-inconsistency row highlighting - Car-specific (CarMetricsService.ComputeMileageWarnings has no + House equivalent), so this stays here rather than in the shared rules in app.css. Rows/cells are rendered + by the child CarHistoryRow component, not this file's own markup - CSS isolation scopes stop at a + component boundary, so this needs ::deep to reach in. */ .kt-car-sheet ::deep .kt-history-row-warning td { background: var(--kt-warning-bg); } @@ -40,48 +10,3 @@ color: var(--kt-warning); cursor: help; } - -.kt-callout { - background: var(--kt-surface-2); - border-radius: var(--kt-radius); - padding: 0.6rem 0.9rem; - margin: 0 0 0.75rem 0; - font-size: 0.9rem; -} - -.kt-callout-warning { - background: var(--kt-warning-bg); - color: var(--kt-warning); -} - -.kt-callout-danger { - background: var(--kt-danger-bg); - color: var(--kt-danger); -} - -/* Built via RenderTreeBuilder (RenderConsumptionChart/RenderCostHistoryChart), not literal markup in this - file, so these elements never receive this component's CSS-isolation scope attribute either - ::deep - again, for the same reason as the sheet rows above. */ -::deep .kt-consumption-chart, -::deep .kt-cost-chart { - width: 100%; - height: 100px; - display: block; -} - -.kt-chart-legend { - display: flex; - gap: 1rem; - font-size: 0.8rem; - color: var(--kt-text-muted); - margin-bottom: 0.4rem; -} - -.kt-legend-swatch { - display: inline-block; - width: 0.7rem; - height: 0.7rem; - border-radius: 2px; - margin-right: 0.3rem; - vertical-align: middle; -} diff --git a/src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor b/src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor index c524efd..112c9c8 100644 --- a/src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor +++ b/src/BlazorApp/Components/Inventory/Pages/CarHistoryRow.razor @@ -1,61 +1,13 @@ -@* One row of the car history sheet. New entries are added via a modal (CarDetail.razor), not an inline row - here, so every row rendered by this component is already persisted and edits commit immediately. *@ +@* One row of the car history sheet - a compact summary of the most important fields. Editing happens + through the same modal used to add a new entry (CarDetail.razor), opened via the Edit button below. *@ - - - - - - - @if (ShowFuel) - { - @if (Entry.EventType == CarHistoryType.Refuel) - { - - - } - else - { - - - } - } - @if (ShowElectric) - { - @if (Entry.EventType == CarHistoryType.Refuel) - { - - - } - else - { - - - } - } - - @if (Entry.EventType == CarHistoryType.Refuel) - { - - } - - - - @if (Entry.EventType == CarHistoryType.Refuel) - { - - } - - - - - + @Entry.HistoryDate.ToString(Entry.HistoryDate.TimeOfDay == TimeSpan.Zero ? "yyyy-MM-dd" : "yyyy-MM-dd HH:mm") + @Entry.Mileage + @Entry.EventType + @Entry.Cost?.ToString("F2") + @Entry.City + @Entry.Description @if (HasWarning) { @@ -63,24 +15,21 @@ } - +
+ + +
@code { [Parameter] public required CarHistoryDto Entry { get; set; } - [Parameter] public required bool ShowFuel { get; set; } - - [Parameter] public required bool ShowElectric { get; set; } - [Parameter] public bool HasWarning { get; set; } [Parameter] public string? WarningMessage { get; set; } - [Parameter] public EventCallback OnSave { get; set; } + [Parameter] public EventCallback OnEdit { get; set; } [Parameter] public EventCallback OnDelete { get; set; } - - private async Task SaveAsync() => await OnSave.InvokeAsync(Entry); } diff --git a/src/BlazorApp/Components/Inventory/Pages/HouseDetail.razor b/src/BlazorApp/Components/Inventory/Pages/HouseDetail.razor new file mode 100644 index 0000000..311f338 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/HouseDetail.razor @@ -0,0 +1,361 @@ +@page "/houses/{Id}" +@rendermode InteractiveServer +@attribute [Authorize] + +@if (_loading) +{ +
+ + Loading… +
+} +else if (_house is null) +{ +
+
◈
+

House not found.

+
+} +else +{ +
+
+ +
+
+ +
+
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+
+ + @if (HasMetricsToShow) + { + var metrics = _metrics!; +

Yearly cost review

+
+

Total cost by year - @metrics.CostHistory.Sum(p => p.TotalCost).ToString("F2") across the whole history

+ @RenderYearlyCostChart(metrics.CostHistory) + +
+ + + + + @foreach (var eventType in Enum.GetValues()) + { + + } + + + + + @foreach (var point in metrics.CostHistory) + { + + + @foreach (var eventType in Enum.GetValues()) + { + + } + + + } + +
Year@eventTypeTotal
@point.Year@(point.CostByCategory.FirstOrDefault(c => c.EventType == eventType)?.Cost.ToString("F2") ?? "-")@point.TotalCost.ToString("F2")
+
+
+ } + +
+

History

+ +
+
+
+ + + + + + + + + + + + + @if (_history.Count == 0) + { + + } + @foreach (var entry in _history) + { + + } + +
DateEventCostProviderDescription
No history yet - add the first entry above.
+
+
+ + @if (_showModal) + { +
+
+
+
@(IsEditMode ? "Edit" : "Add") history entry
+ +
+
+
+
+ + +
+
+ + +
+
+ +
+ @foreach (var eventType in Enum.GetValues()) + { + + } +
+
+
+ + +
+
+ + +
+
+
+
+ + +
+
+
+ } +} + +@code { + [Parameter] public required string Id { get; set; } + + [Inject] private HouseApiClient HouseApi { get; set; } = null!; + + [Inject] private HouseHistoryApiClient HouseHistoryApi { get; set; } = null!; + + private bool _loading = true; + private HouseDto? _house; + private List _history = []; + private HouseMetricsDto? _metrics; + private HouseHistoryDto _modalEntry = NewEntry(""); + private bool _showModal; + + private bool IsEditMode => !string.IsNullOrEmpty(_modalEntry.Id); + + /// `ComputeMetrics` always returns a non-null result, even for a brand-new house with no history + /// at all (an empty list) - the metrics panel should only render once there's actually something in it + /// to show, not just because the object itself isn't null. + private bool HasMetricsToShow => _metrics is { CostHistory.Count: > 0 }; + + protected override async Task OnParametersSetAsync() => await LoadAsync(); + + private static HouseHistoryDto NewEntry(string houseId) => new() + { + HouseId = houseId, + HistoryDate = DateOnly.FromDateTime(DateTime.Now), + EventType = HouseEventType.Maintenance + }; + + private async Task LoadAsync() + { + _loading = true; + _house = await HouseApi.GetOneAsync(Id); + if (_house is not null) + { + var result = await HouseHistoryApi.GetAsync("", 1, int.MaxValue, new Dictionary { ["HouseId"] = Id }); + // Most recent first - unlike CarDetail's chronological (ascending) order, House has no mileage-style + // ordering dependency, and a browsable insurance/maintenance log reads better with the newest entry on top. + _history = result.Items.OrderByDescending(h => h.HistoryDate).ToList(); + _metrics = await HouseApi.GetMetricsAsync(Id); + } + _loading = false; + } + + private async Task SaveHouseAsync() + { + if (_house is null) return; + await HouseApi.UpdateAsync(_house); + } + + private async Task SaveNameAsync(ChangeEventArgs e) + { + if (_house is null) return; + var name = e.Value?.ToString(); + if (string.IsNullOrWhiteSpace(name)) return; + _house.Name = name; + await SaveHouseAsync(); + } + + private async Task SaveAddressAsync(ChangeEventArgs e) + { + if (_house is null) return; + _house.Address = e.Value?.ToString(); + await SaveHouseAsync(); + } + + private async Task SaveCityAsync(ChangeEventArgs e) + { + if (_house is null) return; + _house.City = e.Value?.ToString(); + await SaveHouseAsync(); + } + + private async Task SavePostalCodeAsync(ChangeEventArgs e) + { + if (_house is null) return; + _house.PostalCode = e.Value?.ToString(); + await SaveHouseAsync(); + } + + private async Task SaveCountryAsync(ChangeEventArgs e) + { + if (_house is null) return; + _house.Country = e.Value?.ToString(); + await SaveHouseAsync(); + } + + private async Task SaveNotesAsync(ChangeEventArgs e) + { + if (_house is null) return; + _house.Notes = e.Value?.ToString(); + await SaveHouseAsync(); + } + + private void ShowAddModal() + { + _modalEntry = NewEntry(Id); + _showModal = true; + } + + /// Edits a copy, not the row's own object, so Cancel discards changes instead of leaving the + /// table showing edits that were never saved. + private void ShowEditModal(HouseHistoryDto entry) + { + _modalEntry = CloneEntry(entry); + _showModal = true; + } + + private void CancelModal() => _showModal = false; + + /// Every history mutation reloads the whole house (history + metrics) rather than patching local + /// state - an edit can change the yearly cost breakdown, so recomputing from the server is simpler and + /// safer than trying to keep local derived state in sync by hand. + private async Task SaveModalEntryAsync() + { + if (IsEditMode) await HouseHistoryApi.UpdateAsync(_modalEntry); + else await HouseHistoryApi.AddAsync(_modalEntry); + + _showModal = false; + await LoadAsync(); + } + + private static HouseHistoryDto CloneEntry(HouseHistoryDto entry) => new() + { + Id = entry.Id, + HouseId = entry.HouseId, + HistoryDate = entry.HistoryDate, + EventType = entry.EventType, + Description = entry.Description, + Cost = entry.Cost, + Provider = entry.Provider + }; + + private async Task DeleteEntryAsync(string id) + { + await HouseHistoryApi.DeleteAsync(id); + await LoadAsync(); + } + + /// Hand-rolled SVG bar chart - total cost per year, one bar each. Simpler than a stacked chart + /// (which would need 6 colors for House's event categories): the breakdown table right below already + /// carries the per-category precision an insurance review actually needs, so the chart only needs to + /// answer "what did this cost, year by year" at a glance. Axis drawing lives in , + /// shared with CarDetail.razor's own charts. + private static RenderFragment RenderYearlyCostChart(List points) => builder => + { + var geometry = SvgChartHelpers.FullWidthGeometry; + var (viewWidth, viewHeight, plotLeft, plotRight, plotTop, plotBottom) = geometry; + + var maxTotal = points.Max(p => p.TotalCost); + if (maxTotal <= 0) maxTotal = 1; + + var plotWidth = plotRight - plotLeft; + var barWidth = plotWidth / points.Count * 0.6; + var gap = plotWidth / points.Count * 0.4; + + double ScaleHeight(double value) => value / maxTotal * (plotBottom - plotTop); + + var yTicks = Enumerable.Range(0, 4) + .Select(i => maxTotal * i / 3.0) + .Select(v => (plotBottom - ScaleHeight(v), v.ToString("F0"))) + .ToList(); + var xTicks = points.Select((p, i) => (plotLeft + i * (barWidth + gap) + barWidth / 2, p.Year.ToString())).ToList(); + + var seq = 0; + builder.OpenElement(seq++, "svg"); + builder.AddAttribute(seq++, "viewBox", $"0 0 {viewWidth} {viewHeight}"); + builder.AddAttribute(seq++, "class", "kt-chart-svg"); + + SvgChartHelpers.RenderAxes(builder, ref seq, geometry, "kt-chart-arrow-house-cost", "Year", "€", yTicks, xTicks); + + for (var i = 0; i < points.Count; i++) + { + var point = points[i]; + var x = plotLeft + i * (barWidth + gap); + var height = ScaleHeight(point.TotalCost); + var y = plotBottom - height; + + builder.OpenElement(seq++, "rect"); + builder.AddAttribute(seq++, "x", x.ToString("F1")); + builder.AddAttribute(seq++, "y", y.ToString("F1")); + builder.AddAttribute(seq++, "width", barWidth.ToString("F1")); + builder.AddAttribute(seq++, "height", height.ToString("F1")); + builder.AddAttribute(seq++, "fill", "var(--kt-accent)"); + builder.OpenElement(seq++, "title"); + builder.AddContent(seq++, $"{point.Year}: {point.TotalCost:F2}"); + builder.CloseElement(); + builder.CloseElement(); + } + + builder.CloseElement(); + }; +} diff --git a/src/BlazorApp/Components/Inventory/Pages/HouseHistoryRow.razor b/src/BlazorApp/Components/Inventory/Pages/HouseHistoryRow.razor new file mode 100644 index 0000000..7e2809c --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/HouseHistoryRow.razor @@ -0,0 +1,24 @@ +@* One row of the house history sheet - a compact summary of the most important fields. Editing happens + through the same modal used to add a new entry (HouseDetail.razor), opened via the Edit button below. *@ + + + @Entry.HistoryDate.ToString("yyyy-MM-dd") + @Entry.EventType + @Entry.Cost?.ToString("F2") + @Entry.Provider + @Entry.Description + +
+ + +
+ + + +@code { + [Parameter] public required HouseHistoryDto Entry { get; set; } + + [Parameter] public EventCallback OnEdit { get; set; } + + [Parameter] public EventCallback OnDelete { get; set; } +} diff --git a/src/BlazorApp/Components/Inventory/Pages/Houses.razor b/src/BlazorApp/Components/Inventory/Pages/Houses.razor new file mode 100644 index 0000000..bd44e31 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/Houses.razor @@ -0,0 +1,92 @@ +@page "/houses" +@inherits InventoryPageBase +@rendermode InteractiveServer +@attribute [Authorize] + + + + Name + Address + City + Country + + + + + @house.Name + + @house.Address + @house.City + @house.Country + + + +
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ + +
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+

Manage notes and history from the house's detail page.

+ + diff --git a/src/BlazorApp/Components/Inventory/Pages/Houses.razor.cs b/src/BlazorApp/Components/Inventory/Pages/Houses.razor.cs new file mode 100644 index 0000000..14e3309 --- /dev/null +++ b/src/BlazorApp/Components/Inventory/Pages/Houses.razor.cs @@ -0,0 +1,52 @@ +using Keeptrack.WebApi.Contracts.Dto; +using Microsoft.AspNetCore.Components; + +namespace Keeptrack.BlazorApp.Components.Inventory.Pages; + +public partial class Houses : InventoryPageBase +{ + [Inject] private HouseApiClient HouseApi { get; set; } = null!; + + [Inject] private NavigationManager Nav { get; set; } = null!; + + protected override InventoryApiClientBase Api => HouseApi; + + /// + /// Creating a house only ever captures identity fields here (see FormTemplate) - notes and history + /// are added on the detail page, so a successful create navigates straight there instead of closing the + /// form and staying on the list (same as Cars.razor.cs's SaveAsync). + /// + protected override async Task SaveAsync() + { + try + { + if (_form.Id is null) + { + var created = await HouseApi.AddAsync(_form); + _showForm = false; + Nav.NavigateTo($"/houses/{created.Id}"); + } + else + { + await HouseApi.UpdateAsync(_form); + _showForm = false; + await LoadAsync(); + } + } + catch (Exception ex) + { + _error = ex.Message; + } + } + + protected override HouseDto CloneItem(HouseDto item) => new() + { + Id = item.Id, + Name = item.Name, + Address = item.Address, + City = item.City, + PostalCode = item.PostalCode, + Country = item.Country, + Notes = item.Notes + }; +} diff --git a/src/BlazorApp/Components/Inventory/Shared/InventoryList.razor b/src/BlazorApp/Components/Inventory/Shared/InventoryList.razor index 9eb29ab..ef216ae 100644 --- a/src/BlazorApp/Components/Inventory/Shared/InventoryList.razor +++ b/src/BlazorApp/Components/Inventory/Shared/InventoryList.razor @@ -26,6 +26,11 @@
} + + @if (ShowForm) {
@@ -90,7 +95,7 @@ else
- +
@@ -158,6 +163,7 @@ else @code { private bool _initialized; + private string? _pendingDeleteId; private string _localSearch = ""; private bool _showModal; private bool _mouseDownOnBackdrop; @@ -182,6 +188,17 @@ else await OnClearSearch.InvokeAsync(); } + private void RequestDelete(TDto item) => _pendingDeleteId = item.Id; + + private void CancelDelete() => _pendingDeleteId = null; + + private async Task ConfirmDeleteAsync() + { + var id = _pendingDeleteId; + _pendingDeleteId = null; + if (id is not null) await OnDelete.InvokeAsync(id); + } + private async Task OpenEditModal(TDto item) { await OnStartInlineEdit.InvokeAsync(item); diff --git a/src/BlazorApp/Components/Layout/NavMenu.razor b/src/BlazorApp/Components/Layout/NavMenu.razor index f9b3399..81bf3e5 100644 --- a/src/BlazorApp/Components/Layout/NavMenu.razor +++ b/src/BlazorApp/Components/Layout/NavMenu.razor @@ -59,6 +59,11 @@ ◉ Cars
+
+ + ▲ Houses + +
⬆ Import diff --git a/src/BlazorApp/Components/Shared/ConfirmModal.razor b/src/BlazorApp/Components/Shared/ConfirmModal.razor new file mode 100644 index 0000000..fbcdfb7 --- /dev/null +++ b/src/BlazorApp/Components/Shared/ConfirmModal.razor @@ -0,0 +1,41 @@ +@if (Show) +{ +
+
+
+
@Title
+ +
+
+

@Message

+
+
+ + +
+
+
+} + +@code { + private bool _mouseDownOnBackdrop; + + [Parameter] public required bool Show { get; set; } + [Parameter] public required string Title { get; set; } + [Parameter] public required string Message { get; set; } + [Parameter] public string ConfirmLabel { get; set; } = "Delete"; + [Parameter] public required EventCallback OnConfirm { get; set; } + [Parameter] public required EventCallback OnCancel { get; set; } + + private void HandleBackdropMouseDown() => _mouseDownOnBackdrop = true; + + private async Task HandleBackdropClick() + { + if (_mouseDownOnBackdrop) + { + _mouseDownOnBackdrop = false; + await OnCancel.InvokeAsync(); + } + _mouseDownOnBackdrop = false; + } +} diff --git a/src/BlazorApp/Components/Shared/SvgChartHelpers.cs b/src/BlazorApp/Components/Shared/SvgChartHelpers.cs new file mode 100644 index 0000000..ce33fe4 --- /dev/null +++ b/src/BlazorApp/Components/Shared/SvgChartHelpers.cs @@ -0,0 +1,150 @@ +using Microsoft.AspNetCore.Components.Rendering; + +namespace Keeptrack.BlazorApp.Components.Shared; + +/// +/// Shared SVG axis-drawing primitives for the app's hand-rolled charts (no charting library dependency for a +/// handful of small trend/bar charts). Extracted from CarDetail.razor so HouseDetail.razor's own +/// yearly cost chart doesn't duplicate the same axis geometry/arrow-marker/tick-label algorithm. Deliberately +/// limited to just axis/geometry, not the per-chart series-drawing code (line vs. bar, single vs. stacked +/// series) - that part differs enough between consumers that it stays with each page rather than being forced +/// into one over-generalized shared renderer. +/// +public static class SvgChartHelpers +{ + /// + /// Plot geometry for one chart. Not every chart shares a single fixed viewBox: a chart rendered at full + /// row width needs a proportionally wider viewBox than a half-width one - matching ViewWidth to actual + /// on-screen width keeps the rendered scale (and therefore axis text/arrow/tick size) the same across + /// every chart instead of the wider ones blowing up. + /// + public readonly record struct ChartGeometry(double ViewWidth, double ViewHeight, double PlotLeft, double PlotRight, double PlotTop, double PlotBottom); + + public static readonly ChartGeometry HalfWidthGeometry = new(ViewWidth: 300, ViewHeight: 170, PlotLeft: 40, PlotRight: 288, PlotTop: 14, PlotBottom: 132); + public static readonly ChartGeometry FullWidthGeometry = new(ViewWidth: 600, ViewHeight: 170, PlotLeft: 40, PlotRight: 588, PlotTop: 14, PlotBottom: 132); + + /// Draws a graduated X/Y axis pair (arrowhead, tick marks, tick labels, axis title). Ticks are + /// computed by the caller, since what counts as an evenly-spaced value differs between a continuous line + /// chart and a per-bar categorical one. The Y-axis title is a plain horizontal caption above the axis + /// rather than rotated sideways along it - fine for a multi-word label like "L/100km", but a rotated + /// single glyph like "€" reads as a completely different, garbled character, not a sideways euro sign. + public static void RenderAxes( + RenderTreeBuilder builder, ref int seq, ChartGeometry geometry, string markerId, string xAxisLabel, string yAxisLabel, + IReadOnlyList<(double Y, string Label)> yTicks, IReadOnlyList<(double X, string Label)> xTicks) + { + const string axisColor = "var(--kt-text-muted)"; + var (_, viewHeight, plotLeft, plotRight, plotTop, plotBottom) = geometry; + + builder.OpenElement(seq++, "defs"); + builder.OpenElement(seq++, "marker"); + builder.AddAttribute(seq++, "id", markerId); + builder.AddAttribute(seq++, "viewBox", "0 0 8 8"); + builder.AddAttribute(seq++, "refX", "6"); + builder.AddAttribute(seq++, "refY", "4"); + builder.AddAttribute(seq++, "markerWidth", "6"); + builder.AddAttribute(seq++, "markerHeight", "6"); + builder.AddAttribute(seq++, "orient", "auto-start-reverse"); + builder.OpenElement(seq++, "path"); + builder.AddAttribute(seq++, "d", "M0,0 L8,4 L0,8 Z"); + builder.AddAttribute(seq++, "fill", axisColor); + builder.CloseElement(); + builder.CloseElement(); + builder.CloseElement(); + + // Y axis: drawn bottom-to-top so the arrowhead (marker-end) points up. + builder.OpenElement(seq++, "line"); + builder.AddAttribute(seq++, "x1", plotLeft.ToString("F1")); + builder.AddAttribute(seq++, "y1", plotBottom.ToString("F1")); + builder.AddAttribute(seq++, "x2", plotLeft.ToString("F1")); + builder.AddAttribute(seq++, "y2", plotTop.ToString("F1")); + builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke-width", "1"); + builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); + builder.AddAttribute(seq++, "marker-end", $"url(#{markerId})"); + builder.CloseElement(); + + // X axis: drawn left-to-right so the arrowhead points right. + builder.OpenElement(seq++, "line"); + builder.AddAttribute(seq++, "x1", plotLeft.ToString("F1")); + builder.AddAttribute(seq++, "y1", plotBottom.ToString("F1")); + builder.AddAttribute(seq++, "x2", plotRight.ToString("F1")); + builder.AddAttribute(seq++, "y2", plotBottom.ToString("F1")); + builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke-width", "1"); + builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); + builder.AddAttribute(seq++, "marker-end", $"url(#{markerId})"); + builder.CloseElement(); + + foreach (var (y, label) in yTicks) + { + builder.OpenElement(seq++, "line"); + builder.AddAttribute(seq++, "x1", (plotLeft - 3).ToString("F1")); + builder.AddAttribute(seq++, "y1", y.ToString("F1")); + builder.AddAttribute(seq++, "x2", plotLeft.ToString("F1")); + builder.AddAttribute(seq++, "y2", y.ToString("F1")); + builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke-width", "1"); + builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); + builder.CloseElement(); + + builder.OpenElement(seq++, "text"); + builder.AddAttribute(seq++, "x", (plotLeft - 5).ToString("F1")); + builder.AddAttribute(seq++, "y", (y + 2.5).ToString("F1")); + builder.AddAttribute(seq++, "text-anchor", "end"); + builder.AddAttribute(seq++, "class", "kt-chart-axis-text"); + builder.AddContent(seq++, label); + builder.CloseElement(); + } + + foreach (var (x, label) in xTicks) + { + builder.OpenElement(seq++, "line"); + builder.AddAttribute(seq++, "x1", x.ToString("F1")); + builder.AddAttribute(seq++, "y1", plotBottom.ToString("F1")); + builder.AddAttribute(seq++, "x2", x.ToString("F1")); + builder.AddAttribute(seq++, "y2", (plotBottom + 3).ToString("F1")); + builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke-width", "1"); + builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); + builder.CloseElement(); + + builder.OpenElement(seq++, "text"); + builder.AddAttribute(seq++, "x", x.ToString("F1")); + builder.AddAttribute(seq++, "y", (plotBottom + 12).ToString("F1")); + builder.AddAttribute(seq++, "text-anchor", "middle"); + builder.AddAttribute(seq++, "class", "kt-chart-axis-text"); + builder.AddContent(seq++, label); + builder.CloseElement(); + } + + // Y-axis title: a plain horizontal caption in the top-left corner, naming the axis unit. + builder.OpenElement(seq++, "text"); + builder.AddAttribute(seq++, "x", "2"); + builder.AddAttribute(seq++, "y", (plotTop - 4).ToString("F1")); + builder.AddAttribute(seq++, "text-anchor", "start"); + builder.AddAttribute(seq++, "class", "kt-chart-axis-title"); + builder.AddContent(seq++, yAxisLabel); + builder.CloseElement(); + + var xTitleCenter = (plotLeft + plotRight) / 2; + builder.OpenElement(seq++, "text"); + builder.AddAttribute(seq++, "x", xTitleCenter.ToString("F1")); + builder.AddAttribute(seq++, "y", (viewHeight - 4).ToString("F1")); + builder.AddAttribute(seq++, "text-anchor", "middle"); + builder.AddAttribute(seq++, "class", "kt-chart-axis-title"); + builder.AddContent(seq++, xAxisLabel); + builder.CloseElement(); + } + + /// Picks up to evenly-spaced indices from a 0-based range, always + /// including the first and last - shared by every chart's X-axis tick placement. + public static List EvenlySpacedIndices(int total, int count) + { + if (total <= 1 || count <= 1) return [0]; + count = Math.Min(count, total); + return Enumerable.Range(0, count) + .Select(i => i * (total - 1) / (count - 1)) + .Distinct() + .ToList(); + } +} diff --git a/src/BlazorApp/Components/_Imports.razor b/src/BlazorApp/Components/_Imports.razor index 7c58a76..03a2303 100644 --- a/src/BlazorApp/Components/_Imports.razor +++ b/src/BlazorApp/Components/_Imports.razor @@ -7,6 +7,7 @@ @using Keeptrack.BlazorApp.Components.Inventory.Clients @using Keeptrack.BlazorApp.Components.Inventory.Shared @using Keeptrack.BlazorApp.Components.Layout +@using Keeptrack.BlazorApp.Components.Shared @using Keeptrack.Common.System @using Keeptrack.WebApi.Contracts.Dto @using Microsoft.AspNetCore.Authorization diff --git a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index 989c1b2..524da38 100644 --- a/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/BlazorApp/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -13,6 +13,10 @@ internal static void AddWebApiHttpClient(this IServiceCollection services, strin .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) @@ -31,6 +35,8 @@ internal static void AddWebApiHttpClient(this IServiceCollection services, strin .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); + services.AddHttpClient(client => client.BaseAddress = webApiUri) + .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) .AddHttpMessageHandler(); services.AddHttpClient(client => client.BaseAddress = webApiUri) diff --git a/src/BlazorApp/wwwroot/app.css b/src/BlazorApp/wwwroot/app.css index 8b3bbed..2bbca4b 100644 --- a/src/BlazorApp/wwwroot/app.css +++ b/src/BlazorApp/wwwroot/app.css @@ -1022,6 +1022,83 @@ button.nav-link:hover { color: var(--kt-danger) !important; background: rgba(199 } .kt-section-title:first-child { margin-top: 0; } +/* ── Callouts, sheet tables and hand-rolled SVG charts (shared by CarDetail.razor/HouseDetail.razor) ── + Global (not component-scoped) on purpose: a per-item history table/chart is built from a RenderFragment via + RenderTreeBuilder or a child *Row component, so its markup never receives the page's own CSS-isolation + scope attribute - putting these rules here avoids every consumer having to redeclare them with ::deep. */ +.kt-callout { + background: var(--kt-surface-2); + border-radius: var(--kt-radius); + padding: 0.6rem 0.9rem; + margin: 0 0 0.75rem 0; + font-size: 0.9rem; +} + +.kt-callout-warning { + background: var(--kt-warning-bg); + color: var(--kt-warning); +} + +.kt-callout-danger { + background: var(--kt-danger-bg); + color: var(--kt-danger); +} + +/* Compact history table: a handful of summary columns per row, with the full field set only shown in the + add/edit modal - too many always-visible editable columns read as a spreadsheet dump rather than a + browsable history. */ +.kt-sheet-table { + font-size: 0.85rem; +} + +.kt-sheet-table th { + white-space: nowrap; + color: var(--kt-text-muted); + font-weight: 600; +} + +.kt-sheet-table td { + padding: 0.4rem 0.6rem; + vertical-align: middle; +} + +/* width: 100%, height: auto (not a fixed px height) lets each SVG's own viewBox aspect ratio drive the + rendered height - required since the charts have real axis text, and preserveAspectRatio="none" would + stretch that text unreadably. */ +.kt-chart-svg { + width: 100%; + height: auto; + display: block; +} + +.kt-chart-axis-text { + font-size: 8px; + fill: var(--kt-text-muted); +} + +.kt-chart-axis-title { + font-size: 9px; + font-weight: 600; + fill: var(--kt-text-muted); +} + +.kt-chart-legend { + display: flex; + gap: 1rem; + font-size: 0.8rem; + color: var(--kt-text-muted); + margin-bottom: 0.4rem; +} + +.kt-legend-swatch { + display: inline-block; + width: 0.7rem; + height: 0.7rem; + border-radius: 2px; + margin-right: 0.3rem; + vertical-align: middle; +} + /* ── Tabs (page-level section switcher, e.g. Watch Next / Wishlist by type) ── */ .kt-tabs { display: flex; diff --git a/src/Domain/Models/CarHistoryModel.cs b/src/Domain/Models/CarHistoryModel.cs index be8042a..4c303a1 100644 --- a/src/Domain/Models/CarHistoryModel.cs +++ b/src/Domain/Models/CarHistoryModel.cs @@ -11,7 +11,12 @@ public class CarHistoryModel : IHasIdAndOwnerId public required string CarId { get; set; } - public required DateOnly HistoryDate { get; set; } + /// + /// When this event happened. Carries a real time-of-day, not just a calendar day - several entries + /// (e.g. multiple refuels on a long road trip) can share the same date, and only the time lets them + /// sort in the order they actually happened. Defaults to midnight when the time isn't known. + /// + public required DateTime HistoryDate { get; set; } public int? Mileage { get; set; } @@ -23,6 +28,10 @@ public class CarHistoryModel : IHasIdAndOwnerId public string? City { get; set; } + public string? PostalCode { get; set; } + + public string? Country { get; set; } + public double? Longitude { get; set; } public double? Latitude { get; set; } @@ -49,4 +58,10 @@ public class CarHistoryModel : IHasIdAndOwnerId public double? DeltaMileage { get; set; } public string? StationBrandName { get; set; } + + /// + /// Garage/auto shop name - the Maintenance/Other-event counterpart of + /// (which only applies to Refuel events). + /// + public string? Garage { get; set; } } diff --git a/src/Domain/Models/HouseCategoryCostModel.cs b/src/Domain/Models/HouseCategoryCostModel.cs new file mode 100644 index 0000000..7d53343 --- /dev/null +++ b/src/Domain/Models/HouseCategoryCostModel.cs @@ -0,0 +1,8 @@ +namespace Keeptrack.Domain.Models; + +public class HouseCategoryCostModel +{ + public required HouseEventType EventType { get; set; } + + public required double Cost { get; set; } +} diff --git a/src/Domain/Models/HouseCostHistoryPointModel.cs b/src/Domain/Models/HouseCostHistoryPointModel.cs new file mode 100644 index 0000000..c3ac202 --- /dev/null +++ b/src/Domain/Models/HouseCostHistoryPointModel.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; + +namespace Keeptrack.Domain.Models; + +/// +/// Total cost of ownership for one calendar year, both as a single total and broken down by event category - +/// see . +/// +public class HouseCostHistoryPointModel +{ + public required int Year { get; set; } + + public required double TotalCost { get; set; } + + public required List CostByCategory { get; set; } +} diff --git a/src/Domain/Models/HouseEventType.cs b/src/Domain/Models/HouseEventType.cs new file mode 100644 index 0000000..0b32cb2 --- /dev/null +++ b/src/Domain/Models/HouseEventType.cs @@ -0,0 +1,11 @@ +namespace Keeptrack.Domain.Models; + +public enum HouseEventType +{ + Maintenance, + Installation, + Rework, + Purchase, + Bill, + Other +} diff --git a/src/Domain/Models/HouseHistoryModel.cs b/src/Domain/Models/HouseHistoryModel.cs new file mode 100644 index 0000000..dece298 --- /dev/null +++ b/src/Domain/Models/HouseHistoryModel.cs @@ -0,0 +1,28 @@ +using System; +using Keeptrack.Common.System; + +namespace Keeptrack.Domain.Models; + +public class HouseHistoryModel : IHasIdAndOwnerId +{ + public string? Id { get; set; } + + public required string OwnerId { get; set; } + + public required string HouseId { get; set; } + + public required DateOnly HistoryDate { get; set; } + + public required HouseEventType EventType { get; set; } + + public string? Description { get; set; } + + public double? Cost { get; set; } + + /// + /// Contractor/technician/utility company/store name - a single field covering every category, unlike + /// Car's Refuel-only StationBrandName vs Maintenance-only Garage split, since House has no event type + /// where "who was involved" doesn't apply. + /// + public string? Provider { get; set; } +} diff --git a/src/Domain/Models/HouseMetricsModel.cs b/src/Domain/Models/HouseMetricsModel.cs new file mode 100644 index 0000000..e9e7f3b --- /dev/null +++ b/src/Domain/Models/HouseMetricsModel.cs @@ -0,0 +1,8 @@ +using System.Collections.Generic; + +namespace Keeptrack.Domain.Models; + +public class HouseMetricsModel +{ + public required List CostHistory { get; set; } +} diff --git a/src/Domain/Models/HouseModel.cs b/src/Domain/Models/HouseModel.cs new file mode 100644 index 0000000..3b20f0f --- /dev/null +++ b/src/Domain/Models/HouseModel.cs @@ -0,0 +1,22 @@ +using Keeptrack.Common.System; + +namespace Keeptrack.Domain.Models; + +public class HouseModel : IHasIdAndOwnerId +{ + public string? Id { get; set; } + + public required string OwnerId { get; set; } + + public required string Name { get; set; } + + public string? Address { get; set; } + + public string? City { get; set; } + + public string? PostalCode { get; set; } + + public string? Country { get; set; } + + public string? Notes { get; set; } +} diff --git a/src/Domain/Repositories/ICarHistoryRepository.cs b/src/Domain/Repositories/ICarHistoryRepository.cs index beb7921..2486151 100644 --- a/src/Domain/Repositories/ICarHistoryRepository.cs +++ b/src/Domain/Repositories/ICarHistoryRepository.cs @@ -1,7 +1,14 @@ -using Keeptrack.Domain.Models; +using System.Threading.Tasks; +using Keeptrack.Domain.Models; namespace Keeptrack.Domain.Repositories; public interface ICarHistoryRepository : IDataRepository { + /// + /// Deletes every history entry owned by for the given car - used to cascade + /// a car deletion, since CarHistory is a separate top-level collection referencing its parent by id + /// rather than an embedded array (see CLAUDE.md's "Child entities" section). + /// + Task DeleteAllForCarAsync(string carId, string ownerId); } diff --git a/src/Domain/Repositories/IHouseHistoryRepository.cs b/src/Domain/Repositories/IHouseHistoryRepository.cs new file mode 100644 index 0000000..529c335 --- /dev/null +++ b/src/Domain/Repositories/IHouseHistoryRepository.cs @@ -0,0 +1,14 @@ +using System.Threading.Tasks; +using Keeptrack.Domain.Models; + +namespace Keeptrack.Domain.Repositories; + +public interface IHouseHistoryRepository : IDataRepository +{ + /// + /// Deletes every history entry owned by for the given house - used to cascade + /// a house deletion, since HouseHistory is a separate top-level collection referencing its parent by id + /// rather than an embedded array (see CLAUDE.md's "Child entities" section). + /// + Task DeleteAllForHouseAsync(string houseId, string ownerId); +} diff --git a/src/Domain/Repositories/IHouseRepository.cs b/src/Domain/Repositories/IHouseRepository.cs new file mode 100644 index 0000000..0c9c57e --- /dev/null +++ b/src/Domain/Repositories/IHouseRepository.cs @@ -0,0 +1,7 @@ +using Keeptrack.Domain.Models; + +namespace Keeptrack.Domain.Repositories; + +public interface IHouseRepository : IDataRepository +{ +} diff --git a/src/Domain/Services/CarMetricsService.cs b/src/Domain/Services/CarMetricsService.cs index 943641c..b8a27c3 100644 --- a/src/Domain/Services/CarMetricsService.cs +++ b/src/Domain/Services/CarMetricsService.cs @@ -63,7 +63,7 @@ private static List ComputeConsumption( { points.Add(new ConsumptionPointModel { - Date = refuel.HistoryDate, + Date = DateOnly.FromDateTime(refuel.HistoryDate), ValuePer100Km = quantitySinceLastFullRefill / distance * 100 }); } @@ -117,8 +117,8 @@ private static List ComputeMileageWarnings(IReadOnlyList warnings.Add(new CarMileageWarningModel { CarHistoryId = current.Id!, - Message = $"Mileage {current.Mileage} on {current.HistoryDate} is lower than {previous.Mileage} " + - $"recorded on {previous.HistoryDate}." + Message = $"Mileage {current.Mileage} on {current.HistoryDate:yyyy-MM-dd} is lower than {previous.Mileage} " + + $"recorded on {previous.HistoryDate:yyyy-MM-dd}." }); continue; } @@ -134,7 +134,7 @@ private static List ComputeMileageWarnings(IReadOnlyList CarHistoryId = current.Id!, Message = $"Entered delta mileage ({current.DeltaMileage}) doesn't match the {computedDelta} " + $"difference between this entry's mileage ({current.Mileage}) and the previous entry's " + - $"({previous.Mileage} on {previous.HistoryDate})." + + $"({previous.Mileage} on {previous.HistoryDate:yyyy-MM-dd})." + (suggestsMissingEntry ? " An entry may be missing in between." : " Check both entries for a typo.") }); } @@ -156,13 +156,14 @@ private static List ComputeMileageWarnings(IReadOnlyList if (lastMaintenance is null) return null; - var dueDate = lastMaintenance.HistoryDate.AddYears(1); + var lastMaintenanceDate = DateOnly.FromDateTime(lastMaintenance.HistoryDate); + var dueDate = lastMaintenanceDate.AddYears(1); var today = DateOnly.FromDateTime(DateTime.Today); var monthsRemaining = ((dueDate.Year - today.Year) * 12) + (dueDate.Month - today.Month); return new NextMaintenanceModel { - LastMaintenanceDate = lastMaintenance.HistoryDate, + LastMaintenanceDate = lastMaintenanceDate, DueDate = dueDate, MonthsRemaining = monthsRemaining }; diff --git a/src/Domain/Services/HouseMetricsService.cs b/src/Domain/Services/HouseMetricsService.cs new file mode 100644 index 0000000..70f87d8 --- /dev/null +++ b/src/Domain/Services/HouseMetricsService.cs @@ -0,0 +1,34 @@ +using System.Collections.Generic; +using System.Linq; +using Keeptrack.Domain.Models; + +namespace Keeptrack.Domain.Services; + +/// +/// Pure, stateless computation over a house's history - no persistence of its own, same shape as +/// /. Deliberately limited to a yearly cost +/// breakdown: House has no reminders/due-date engine (unlike Car's ComputeNextMaintenanceDue) by design - +/// the owner tracks recurring bills/maintenance elsewhere and only wants an exhaustive record plus a yearly +/// cost review here. +/// +public class HouseMetricsService +{ + public HouseMetricsModel ComputeMetrics(IEnumerable history) => + new() { CostHistory = ComputeAnnualCostHistory(history) }; + + private static List ComputeAnnualCostHistory(IEnumerable history) => + history + .Where(h => h.Cost is not null) + .GroupBy(h => h.HistoryDate.Year) + .OrderBy(g => g.Key) + .Select(g => new HouseCostHistoryPointModel + { + Year = g.Key, + TotalCost = g.Sum(h => h.Cost!.Value), + CostByCategory = g.GroupBy(h => h.EventType) + .Select(cg => new HouseCategoryCostModel { EventType = cg.Key, Cost = cg.Sum(h => h.Cost!.Value) }) + .OrderBy(c => c.EventType) + .ToList() + }) + .ToList(); +} diff --git a/src/Infrastructure.MongoDb/Entities/CarHistory.cs b/src/Infrastructure.MongoDb/Entities/CarHistory.cs index bc7fd60..f0808d6 100644 --- a/src/Infrastructure.MongoDb/Entities/CarHistory.cs +++ b/src/Infrastructure.MongoDb/Entities/CarHistory.cs @@ -35,4 +35,6 @@ public class CarHistory : IHasIdAndOwnerId public CarHistoryFuel? Fuel { get; set; } public CarHistoryStation? Station { get; set; } + + public string? Garage { get; set; } } diff --git a/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs b/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs index ce9d28c..ac19566 100644 --- a/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs +++ b/src/Infrastructure.MongoDb/Entities/CarHistoryLocation.cs @@ -1,4 +1,5 @@ using System.Collections.Generic; +using MongoDB.Bson.Serialization.Attributes; namespace Keeptrack.Infrastructure.MongoDb.Entities; @@ -6,5 +7,10 @@ public class CarHistoryLocation { public required string City { get; set; } + [BsonElement("postal_code")] + public string? PostalCode { get; set; } + + public string? Country { get; set; } + public List? Coordinates { get; set; } } diff --git a/src/Infrastructure.MongoDb/Entities/House.cs b/src/Infrastructure.MongoDb/Entities/House.cs new file mode 100644 index 0000000..0bc6e1d --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/House.cs @@ -0,0 +1,28 @@ +using Keeptrack.Common.System; +using MongoDB.Bson; +using MongoDB.Bson.Serialization.Attributes; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +public class House : IHasIdAndOwnerId +{ + [BsonId] + [BsonRepresentation(BsonType.ObjectId)] + public string? Id { get; set; } + + [BsonElement("owner_id")] + public required string OwnerId { get; set; } + + public required string Name { get; set; } + + public string? Address { get; set; } + + public string? City { get; set; } + + [BsonElement("postal_code")] + public string? PostalCode { get; set; } + + public string? Country { get; set; } + + public string? Notes { get; set; } +} diff --git a/src/Infrastructure.MongoDb/Entities/HouseHistory.cs b/src/Infrastructure.MongoDb/Entities/HouseHistory.cs new file mode 100644 index 0000000..44c0286 --- /dev/null +++ b/src/Infrastructure.MongoDb/Entities/HouseHistory.cs @@ -0,0 +1,32 @@ +using System; +using Keeptrack.Common.System; +using Keeptrack.Domain.Models; +using MongoDB.Bson; +using MongoDB.Bson.Serialization.Attributes; + +namespace Keeptrack.Infrastructure.MongoDb.Entities; + +public class HouseHistory : IHasIdAndOwnerId +{ + [BsonId] + [BsonRepresentation(BsonType.ObjectId)] + public string? Id { get; set; } + + [BsonElement("owner_id")] + public required string OwnerId { get; set; } + + [BsonElement("house_id")] + public required string HouseId { get; set; } + + [BsonElement("history_date")] + public required DateTime HistoryDate { get; set; } + + [BsonElement("event_type")] + public required HouseEventType EventType { get; set; } + + public string? Description { get; set; } + + public double? Cost { get; set; } + + public string? Provider { get; set; } +} diff --git a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs index 3b662e0..d8d634e 100644 --- a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs @@ -1,3 +1,4 @@ +using System.Threading.Tasks; using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; @@ -12,6 +13,13 @@ public class CarHistoryRepository(IMongoDatabase mongoDatabase, ILogger "car_history"; + public async Task DeleteAllForCarAsync(string carId, string ownerId) + { + var filter = Builders.Filter.Eq(f => f.OwnerId, ownerId) & Builders.Filter.Eq(f => f.CarId, carId); + var result = await GetCollection().DeleteManyAsync(filter); + return result.DeletedCount; + } + protected override FilterDefinition GetFilter(string ownerId, string? search, CarHistoryModel input) { var builder = Builders.Filter; diff --git a/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs b/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs new file mode 100644 index 0000000..afd09bd --- /dev/null +++ b/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs @@ -0,0 +1,35 @@ +using System.Threading.Tasks; +using AutoMapper; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Microsoft.Extensions.Logging; +using MongoDB.Driver; + +namespace Keeptrack.Infrastructure.MongoDb.Repositories; + +public class HouseHistoryRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) + : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IHouseHistoryRepository +{ + protected override string CollectionName => "house_history"; + + public async Task DeleteAllForHouseAsync(string houseId, string ownerId) + { + var filter = Builders.Filter.Eq(f => f.OwnerId, ownerId) & Builders.Filter.Eq(f => f.HouseId, houseId); + var result = await GetCollection().DeleteManyAsync(filter); + return result.DeletedCount; + } + + protected override FilterDefinition GetFilter(string ownerId, string? search, HouseHistoryModel input) + { + var builder = Builders.Filter; + var filter = builder.Eq(f => f.OwnerId, ownerId); + if (!string.IsNullOrEmpty(input.HouseId)) filter &= builder.Eq(f => f.HouseId, input.HouseId); + if (!string.IsNullOrEmpty(search)) + { + filter &= builder.Where(f => f.Description != null + && f.Description.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + } + return filter; + } +} diff --git a/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs b/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs new file mode 100644 index 0000000..cf44183 --- /dev/null +++ b/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs @@ -0,0 +1,22 @@ +using AutoMapper; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Microsoft.Extensions.Logging; +using MongoDB.Driver; + +namespace Keeptrack.Infrastructure.MongoDb.Repositories; + +public class HouseRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) + : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IHouseRepository +{ + protected override string CollectionName => "house"; + + protected override FilterDefinition GetFilter(string ownerId, string? search, HouseModel input) + { + var builder = Builders.Filter; + var filter = builder.Eq(f => f.OwnerId, ownerId); + if (!string.IsNullOrEmpty(search)) filter &= builder.Where(f => f.Name.Contains(search, System.StringComparison.CurrentCultureIgnoreCase)); + return filter; + } +} diff --git a/src/WebApi.Contracts/Dto/CarHistoryDto.cs b/src/WebApi.Contracts/Dto/CarHistoryDto.cs index 9fc3a97..6964082 100644 --- a/src/WebApi.Contracts/Dto/CarHistoryDto.cs +++ b/src/WebApi.Contracts/Dto/CarHistoryDto.cs @@ -19,9 +19,10 @@ public class CarHistoryDto : IHasId public required string CarId { get; set; } /// - /// History date. + /// History date and time. Several entries can share the same date (e.g. multiple refuels on a road + /// trip); the time is what lets them sort correctly. Defaults to midnight when the time isn't known. /// - public required DateOnly HistoryDate { get; set; } + public required DateTime HistoryDate { get; set; } /// /// Mileage indicated on the car. @@ -48,6 +49,16 @@ public class CarHistoryDto : IHasId /// public string? City { get; set; } + /// + /// Postal code. + /// + public string? PostalCode { get; set; } + + /// + /// Country. + /// + public string? Country { get; set; } + /// /// Longitude. /// @@ -98,4 +109,9 @@ public class CarHistoryDto : IHasId /// Station brand name. /// public string? StationBrandName { get; set; } + + /// + /// Garage/auto shop name - the Maintenance/Other-event counterpart of . + /// + public string? Garage { get; set; } } diff --git a/src/WebApi.Contracts/Dto/CarHistoryImportResultDto.cs b/src/WebApi.Contracts/Dto/CarHistoryImportResultDto.cs new file mode 100644 index 0000000..f6e1a02 --- /dev/null +++ b/src/WebApi.Contracts/Dto/CarHistoryImportResultDto.cs @@ -0,0 +1,20 @@ +using System.Collections.Generic; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Result of importing the personal "Voitures.xlsx" spreadsheet (fuel/maintenance history per car). +/// +public class CarHistoryImportResultDto +{ + public int CarsCreated { get; set; } + + public int CarsSkipped { get; set; } + + public int HistoryEntriesCreated { get; set; } + + /// + /// Rows that couldn't be parsed (e.g. an unreadable date) and were skipped rather than guessed at. + /// + public List Warnings { get; set; } = []; +} diff --git a/src/WebApi.Contracts/Dto/HouseCategoryCostDto.cs b/src/WebApi.Contracts/Dto/HouseCategoryCostDto.cs new file mode 100644 index 0000000..dc124b3 --- /dev/null +++ b/src/WebApi.Contracts/Dto/HouseCategoryCostDto.cs @@ -0,0 +1,17 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Total cost for one house history event category within a . +/// +public class HouseCategoryCostDto +{ + /// + /// Event category. + /// + public required HouseEventType EventType { get; set; } + + /// + /// Total cost for this category. + /// + public required double Cost { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/HouseCostHistoryPointDto.cs b/src/WebApi.Contracts/Dto/HouseCostHistoryPointDto.cs new file mode 100644 index 0000000..eb601af --- /dev/null +++ b/src/WebApi.Contracts/Dto/HouseCostHistoryPointDto.cs @@ -0,0 +1,24 @@ +using System.Collections.Generic; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Total cost of ownership for one calendar year, both as a single total and broken down by event category. +/// +public class HouseCostHistoryPointDto +{ + /// + /// Calendar year this point covers. + /// + public required int Year { get; set; } + + /// + /// Combined spend for the year. + /// + public required double TotalCost { get; set; } + + /// + /// Spend broken down by event category. + /// + public required List CostByCategory { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/HouseDto.cs b/src/WebApi.Contracts/Dto/HouseDto.cs new file mode 100644 index 0000000..4da05df --- /dev/null +++ b/src/WebApi.Contracts/Dto/HouseDto.cs @@ -0,0 +1,44 @@ +using Keeptrack.Common.System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// House data transfer object. +/// +public class HouseDto : IHasId +{ + /// + /// House ID. + /// + public string? Id { get; set; } + + /// + /// House name (e.g. "Main house", "Beach apartment"). + /// + public string? Name { get; set; } + + /// + /// Street address. + /// + public string? Address { get; set; } + + /// + /// City. + /// + public string? City { get; set; } + + /// + /// Postal code. + /// + public string? PostalCode { get; set; } + + /// + /// Country. + /// + public string? Country { get; set; } + + /// + /// Free-text notes. + /// + public string? Notes { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/HouseEventType.cs b/src/WebApi.Contracts/Dto/HouseEventType.cs new file mode 100644 index 0000000..6147390 --- /dev/null +++ b/src/WebApi.Contracts/Dto/HouseEventType.cs @@ -0,0 +1,16 @@ +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// House history event type. Kept as a separate definition from Keeptrack.Domain.Models.HouseEventType +/// since WebApi.Contracts doesn't depend on Domain - member names must stay identical so AutoMapper can map +/// enum-to-enum by name. +/// +public enum HouseEventType +{ + Maintenance, + Installation, + Rework, + Purchase, + Bill, + Other +} diff --git a/src/WebApi.Contracts/Dto/HouseHistoryDto.cs b/src/WebApi.Contracts/Dto/HouseHistoryDto.cs new file mode 100644 index 0000000..128dadb --- /dev/null +++ b/src/WebApi.Contracts/Dto/HouseHistoryDto.cs @@ -0,0 +1,45 @@ +using System; +using Keeptrack.Common.System; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// House history data transfer object. +/// +public class HouseHistoryDto : IHasId +{ + /// + /// History ID. + /// + public string? Id { get; set; } + + /// + /// House ID. + /// + public required string HouseId { get; set; } + + /// + /// History date. + /// + public required DateOnly HistoryDate { get; set; } + + /// + /// Event type (Maintenance, Installation, Rework, Purchase, Bill, Other). + /// + public required HouseEventType EventType { get; set; } + + /// + /// Free-text description of what was done. + /// + public string? Description { get; set; } + + /// + /// Total cost of this event. + /// + public double? Cost { get; set; } + + /// + /// Contractor/technician/utility company/store name. + /// + public string? Provider { get; set; } +} diff --git a/src/WebApi.Contracts/Dto/HouseMetricsDto.cs b/src/WebApi.Contracts/Dto/HouseMetricsDto.cs new file mode 100644 index 0000000..3ccd2f2 --- /dev/null +++ b/src/WebApi.Contracts/Dto/HouseMetricsDto.cs @@ -0,0 +1,14 @@ +using System.Collections.Generic; + +namespace Keeptrack.WebApi.Contracts.Dto; + +/// +/// Computed metrics for one house: yearly cost history. +/// +public class HouseMetricsDto +{ + /// + /// Total cost of ownership, by year. + /// + public required List CostHistory { get; set; } +} diff --git a/src/WebApi/Controllers/CarController.cs b/src/WebApi/Controllers/CarController.cs index bed8645..6b9cbff 100644 --- a/src/WebApi/Controllers/CarController.cs +++ b/src/WebApi/Controllers/CarController.cs @@ -35,4 +35,11 @@ public async Task> GetMetrics(string id) return Ok(Mapper.Map(metricsService.ComputeMetrics(history.Items))); } + + /// + /// CarHistory is a separate top-level collection referencing its car by id, not an embedded array + /// (see CLAUDE.md's "Child entities" section) - without this, deleting a car would leave its fuel/ + /// maintenance history orphaned in MongoDB forever, since it's only ever reachable via the car's own id. + /// + protected override async Task OnDeletedAsync(string id, string ownerId) => await carHistoryRepository.DeleteAllForCarAsync(id, ownerId); } diff --git a/src/WebApi/Controllers/DataCrudControllerBase.cs b/src/WebApi/Controllers/DataCrudControllerBase.cs index 3554c18..4a27dc9 100644 --- a/src/WebApi/Controllers/DataCrudControllerBase.cs +++ b/src/WebApi/Controllers/DataCrudControllerBase.cs @@ -103,7 +103,15 @@ public async Task Delete(string id) return BadRequest(); } - await dataRepository.DeleteAsync(id, this.GetUserId()); + var ownerId = this.GetUserId(); + await dataRepository.DeleteAsync(id, ownerId); + await OnDeletedAsync(id, ownerId); return NoContent(); } + + /// + /// Hook for subclasses that need to react to an item being deleted (e.g. cascading the delete to a + /// child collection such as CarHistory). No-op by default, same shape as . + /// + protected virtual Task OnDeletedAsync(string id, string ownerId) => Task.CompletedTask; } diff --git a/src/WebApi/Controllers/HouseController.cs b/src/WebApi/Controllers/HouseController.cs new file mode 100644 index 0000000..8bd21fc --- /dev/null +++ b/src/WebApi/Controllers/HouseController.cs @@ -0,0 +1,44 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Keeptrack.Domain.Services; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Controllers; + +[ApiController] +[Authorize] +[Route("api/houses")] +public class HouseController( + IMapper mapper, + IHouseRepository dataRepository, + IHouseHistoryRepository houseHistoryRepository, + HouseMetricsService metricsService) + : DataCrudControllerBase(mapper, dataRepository) +{ + /// + /// Computed yearly cost history for this house - see . + /// + [HttpGet("{id}/metrics")] + [ProducesResponseType(200)] + [ProducesResponseType(404)] + public async Task> GetMetrics(string id) + { + var ownerId = this.GetUserId(); + + var house = await dataRepository.FindOneAsync(id, ownerId); + if (house is null) return NotFound(); + + var history = await houseHistoryRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, + new HouseHistoryModel { OwnerId = ownerId, HouseId = id, EventType = default, HistoryDate = default }); + + return Ok(Mapper.Map(metricsService.ComputeMetrics(history.Items))); + } + + /// + /// HouseHistory is a separate top-level collection referencing its house by id, not an embedded array + /// (see CLAUDE.md's "Child entities" section) - without this, deleting a house would leave its history + /// orphaned in MongoDB forever, since it's only ever reachable via the house's own id. + /// + protected override async Task OnDeletedAsync(string id, string ownerId) => await houseHistoryRepository.DeleteAllForHouseAsync(id, ownerId); +} diff --git a/src/WebApi/Controllers/HouseHistoryController.cs b/src/WebApi/Controllers/HouseHistoryController.cs new file mode 100644 index 0000000..59e7937 --- /dev/null +++ b/src/WebApi/Controllers/HouseHistoryController.cs @@ -0,0 +1,12 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Controllers; + +[ApiController] +[Authorize] +[Route("api/house-history")] +public class HouseHistoryController(IMapper mapper, IHouseHistoryRepository dataRepository) + : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index 8a9133e..b0a921d 100644 --- a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -31,6 +31,8 @@ internal static void AddMongoDbInfrastructure(this IServiceCollection services, services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); + services.TryAddScoped(); + services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); diff --git a/src/WebApi/Import/CarHistoryImportController.cs b/src/WebApi/Import/CarHistoryImportController.cs new file mode 100644 index 0000000..0e62a6a --- /dev/null +++ b/src/WebApi/Import/CarHistoryImportController.cs @@ -0,0 +1,36 @@ +using System.IO; +using System.Threading.Tasks; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.Controllers; +using Microsoft.AspNetCore.Authorization; +using Microsoft.AspNetCore.Mvc; + +namespace Keeptrack.WebApi.Import; + +[ApiController] +[Authorize] +[Route("api/import")] +public class CarHistoryImportController(CarHistoryImportService importService) : ControllerBase +{ + /// + /// Imports the personal "Voitures.xlsx" spreadsheet (fuel/maintenance history per car). Runs + /// synchronously - unlike the TV Time import, there's no external API call in the loop, so a few + /// hundred rows complete well within a normal request. + /// + [HttpPost("car-history")] + [RequestSizeLimit(10_000_000)] + [Consumes("multipart/form-data")] + [ProducesResponseType(200)] + [ProducesResponseType(400)] + public async Task> ImportCarHistory(IFormFile file) + { + if (file.Length == 0) + { + return BadRequest(); + } + + await using var stream = file.OpenReadStream(); + var result = await importService.ImportAsync(stream, this.GetUserId()); + return Ok(result); + } +} diff --git a/src/WebApi/Import/CarHistoryImportService.cs b/src/WebApi/Import/CarHistoryImportService.cs new file mode 100644 index 0000000..dfd35bb --- /dev/null +++ b/src/WebApi/Import/CarHistoryImportService.cs @@ -0,0 +1,254 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Threading.Tasks; +using ClosedXML.Excel; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Repositories; +using CarEnergyType = Keeptrack.Domain.Models.CarEnergyType; +using CarHistoryType = Keeptrack.Domain.Models.CarHistoryType; + +namespace Keeptrack.WebApi.Import; + +/// +/// One-off personal import of the "Voitures.xlsx" spreadsheet: one fuel-log sheet and (optionally) one +/// maintenance-log sheet per car, hand-tracked in French. This is a single-owner spreadsheet with a fixed, +/// known shape (not a generic user-facing file format like the TV Time GDPR export), so the sheet names and +/// column headers below are hardcoded rather than auto-detected. Not idempotent by design - matches an +/// existing car by name so re-running doesn't duplicate the cars themselves, but re-uploading the same +/// file will duplicate history entries. This is meant to be run once per car; unlike , +/// there is no per-entry natural key in the source data to de-duplicate against. +/// +public class CarHistoryImportService(ICarRepository carRepository, ICarHistoryRepository carHistoryRepository) +{ + private static readonly CultureInfo French = CultureInfo.GetCultureInfo("fr-FR"); + + private sealed record CarSheetGroup(string CarName, string Manufacturer, string Model, string? FuelSheet, string? MaintenanceSheet); + + private static readonly CarSheetGroup[] CarGroups = + [ + new("Renault Scenic", "Renault", "Scenic", "Carburant S", null), + new("Renault Modus", "Renault", "Modus", "Carburant M", "Interventions M"), + new("Peugeot 306", "Peugeot", "306", "Carburant 306", "Intervention 306") + ]; + + public async Task ImportAsync(Stream xlsxStream, string ownerId) + { + using var workbook = new XLWorkbook(xlsxStream); + var result = new CarHistoryImportResultDto(); + + var existingCars = (await carRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, NewCar(ownerId, string.Empty))).Items; + + foreach (var group in CarGroups) + { + var car = existingCars.FirstOrDefault(c => string.Equals(c.Name, group.CarName, StringComparison.OrdinalIgnoreCase)); + if (car is null) + { + car = await carRepository.CreateAsync(new CarModel + { + OwnerId = ownerId, + Name = group.CarName, + Manufacturer = group.Manufacturer, + Model = group.Model, + EnergyType = CarEnergyType.Combustion + }); + result.CarsCreated++; + } + else + { + result.CarsSkipped++; + } + + if (group.FuelSheet is not null && workbook.Worksheets.TryGetWorksheet(group.FuelSheet, out var fuelSheet)) + { + result.HistoryEntriesCreated += await ImportFuelSheetAsync(fuelSheet, car.Id!, ownerId, group.CarName, result.Warnings); + } + + if (group.MaintenanceSheet is not null && workbook.Worksheets.TryGetWorksheet(group.MaintenanceSheet, out var maintenanceSheet)) + { + result.HistoryEntriesCreated += await ImportMaintenanceSheetAsync(maintenanceSheet, car.Id!, ownerId, group.CarName, result.Warnings); + } + } + + return result; + } + + private async Task ImportFuelSheetAsync(IXLWorksheet sheet, string carId, string ownerId, string carName, List warnings) + { + var headers = ReadHeaders(sheet); + var created = 0; + + foreach (var row in DataRows(sheet)) + { + var dateCell = Cell(row, headers, "Date"); + if (dateCell is null || dateCell.IsEmpty()) continue; + + var date = ParseDate(dateCell); + if (date is null) + { + warnings.Add($"{carName}: skipped a fuel entry with an unreadable date (\"{dateCell.GetString()}\")."); + continue; + } + + var time = ParseTime(Cell(row, headers, "Heure")) ?? TimeOnly.MinValue; + + var entry = new CarHistoryModel + { + OwnerId = ownerId, + CarId = carId, + HistoryDate = date.Value.ToDateTime(time), + EventType = CarHistoryType.Refuel, + City = StringOrNull(Cell(row, headers, "Ville")), + PostalCode = StringOrNull(Cell(row, headers, "CP")), + FuelCategory = StringOrNull(Cell(row, headers, "Type carburant")), + FuelVolume = DoubleOrNull(Cell(row, headers, "Volume (L)")) ?? DoubleOrNull(Cell(row, headers, "Quantité (L)")), + FuelUnitPrice = PriceOrNull(Cell(row, headers, "Prix (€ / L)")), + Cost = PriceOrNull(Cell(row, headers, "Prix (€)")) ?? PriceOrNull(Cell(row, headers, "Montant (€)")), + Mileage = IntOrNull(Cell(row, headers, "Km")), + DeltaMileage = DoubleOrNull(Cell(row, headers, "Distance (km)")), + IsFullRefill = IsFlagSet(Cell(row, headers, "Plein")), + StationBrandName = StringOrNull(Cell(row, headers, "Distributeur")), + Description = JoinNonEmpty("; ", + StringOrNull(Cell(row, headers, "Voyage")) is { } voyage ? $"Voyage : {voyage}" : null, + StringOrNull(Cell(row, headers, "Détails")), + IsFlagSet(Cell(row, headers, "Autoroute Eloigné")) == true ? "Autoroute/éloigné" : null, + IsFlagSet(Cell(row, headers, "Autoroute")) == true ? "Autoroute" : null, + IsFlagSet(Cell(row, headers, "Gonflage")) == true ? "Gonflage pneus" : null) + }; + + await carHistoryRepository.CreateAsync(entry); + created++; + } + + return created; + } + + private async Task ImportMaintenanceSheetAsync(IXLWorksheet sheet, string carId, string ownerId, string carName, List warnings) + { + var headers = ReadHeaders(sheet); + var created = 0; + + foreach (var row in DataRows(sheet)) + { + var dateCell = Cell(row, headers, "Date"); + if (dateCell is null || dateCell.IsEmpty()) continue; + + var date = ParseDate(dateCell); + if (date is null) + { + warnings.Add($"{carName}: skipped a maintenance entry with an unreadable date (\"{dateCell.GetString()}\")."); + continue; + } + + var nature = StringOrNull(Cell(row, headers, "Nature")); + var invoiceNumber = StringOrNull(Cell(row, headers, "N° facture")); + + var entry = new CarHistoryModel + { + OwnerId = ownerId, + CarId = carId, + // Neither maintenance sheet has a time-of-day column, so this always defaults to midnight. + HistoryDate = date.Value.ToDateTime(TimeOnly.MinValue), + // "Achat" (purchase) is not a maintenance action - everything else in these two sheets is. + EventType = string.Equals(nature, "Achat", StringComparison.OrdinalIgnoreCase) ? CarHistoryType.Other : CarHistoryType.Maintenance, + City = StringOrNull(Cell(row, headers, "Ville")), + PostalCode = StringOrNull(Cell(row, headers, "CP")), + Cost = PriceOrNull(Cell(row, headers, "Prix (TTC)")), + Mileage = IntOrNull(Cell(row, headers, "Km")), + Garage = StringOrNull(Cell(row, headers, "Garage")), + Description = JoinNonEmpty("; ", + nature, + StringOrNull(Cell(row, headers, "Détail")), + StringOrNull(Cell(row, headers, "Complément")), + invoiceNumber is not null ? $"Facture {invoiceNumber}" : null) + }; + + await carHistoryRepository.CreateAsync(entry); + created++; + } + + return created; + } + + private static CarModel NewCar(string ownerId, string name) => new() { OwnerId = ownerId, Name = name, EnergyType = CarEnergyType.Combustion }; + + private static Dictionary ReadHeaders(IXLWorksheet sheet) + { + var headerRow = sheet.Row(1); + var headers = new Dictionary(); + foreach (var cell in headerRow.CellsUsed()) + { + // Some headers (e.g. "Autoroute\nEloigné") span two lines within a single cell; normalize + // whitespace so a lookup doesn't have to guess the exact line-break character used in the file. + var text = string.Join(' ', cell.GetString().Split([' ', '\r', '\n', '\t'], StringSplitOptions.RemoveEmptyEntries)); + if (text.Length > 0) headers.TryAdd(text, cell.Address.ColumnNumber); + } + + return headers; + } + + private static IEnumerable DataRows(IXLWorksheet sheet) => sheet.RowsUsed().Skip(1); + + private static IXLCell? Cell(IXLRow row, Dictionary headers, string header) => + headers.TryGetValue(header, out var column) ? row.Cell(column) : null; + + /// + /// Reads a date, falling back to a manual French (d/M/yyyy) text parse for the one row that wasn't + /// stored as a real Excel date. One entry in "Carburant S" has the corrupted literal text "11/06/0207", + /// confirmed (from the surrounding, chronologically-sorted rows: 2017-08-13 above, 2017-05-26 below) to + /// be a mistyped 11/06/2017 - fixed here rather than skipped, per a manual review of the source file. + /// + private static DateOnly? ParseDate(IXLCell cell) + { + if (cell.TryGetValue(out DateTime dateTime)) return DateOnly.FromDateTime(dateTime); + + var raw = cell.GetString().Trim(); + if (raw == "11/06/0207") return new DateOnly(2017, 6, 11); + + return DateOnly.TryParseExact(raw, "d/M/yyyy", French, DateTimeStyles.None, out var parsed) ? parsed : null; + } + + /// + /// The "Heure" column is inconsistent in this file - some cells are real Excel time values (a fraction + /// of a day), others are plain text like "11:57" - but GetFormattedString() renders both the + /// same way, so a single text parse handles both. + /// + private static TimeOnly? ParseTime(IXLCell? cell) + { + if (cell is null || cell.IsEmpty()) return null; + var text = cell.GetFormattedString().Trim(); + return TimeOnly.TryParse(text, CultureInfo.InvariantCulture, out var parsed) ? parsed : null; + } + + private static bool? IsFlagSet(IXLCell? cell) + { + if (cell is null || cell.IsEmpty()) return null; + return string.Equals(cell.GetString().Trim(), "O", StringComparison.OrdinalIgnoreCase); + } + + private static string? StringOrNull(IXLCell? cell) + { + if (cell is null || cell.IsEmpty()) return null; + var text = cell.GetString().Trim(); + return text.Length > 0 ? text : null; + } + + private static double? DoubleOrNull(IXLCell? cell) => cell is not null && !cell.IsEmpty() && cell.TryGetValue(out double value) ? value : null; + + /// + /// Several euro-amount columns are Excel formulas (e.g. volume × unit price), which routinely produce + /// floating-point noise like 180.77539999999996 instead of a clean 180.78 - rounded to the cent here so + /// every imported price is a real, displayable amount. + /// + private static double? PriceOrNull(IXLCell? cell) => DoubleOrNull(cell) is { } value ? Math.Round(value, 2) : null; + + private static int? IntOrNull(IXLCell? cell) => DoubleOrNull(cell) is { } value ? (int)Math.Round(value) : null; + + private static string? JoinNonEmpty(string separator, params string?[] parts) + { + var joined = string.Join(separator, parts.Where(p => !string.IsNullOrWhiteSpace(p))); + return joined.Length > 0 ? joined : null; + } +} diff --git a/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs index 2802f33..bf91a5d 100644 --- a/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs +++ b/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs @@ -24,6 +24,10 @@ private void MapCarHistoryModel() CreateMap() .ForMember(x => x.City, opt => opt.MapFrom( x => x.Location != null ? x.Location.City : null)) + .ForMember(x => x.PostalCode, opt => opt.MapFrom( + x => x.Location != null ? x.Location.PostalCode : null)) + .ForMember(x => x.Country, opt => opt.MapFrom( + x => x.Location != null ? x.Location.Country : null)) .ForMember(x => x.Longitude, opt => opt.MapFrom( x => x.Location != null && x.Location.Coordinates != null ? x.Location.Coordinates[0] : (double?)null)) .ForMember(x => x.Latitude, opt => opt.MapFrom( @@ -49,6 +53,12 @@ private void MapCarHistoryModel() private void MapCarHistory() { CreateMap() + // HistoryDate is a plain DateTime on both sides (unlike every other Date field in this codebase, + // which is DateOnly on the model and goes through DataStorageMappingProfile's DateOnly<->DateTime + // converter - that converter is what normally stamps DateTimeKind.Utc), so nothing upstream + // guarantees a Utc Kind here. The Mongo driver's default DateTimeSerializer requires it. + .ForMember(x => x.HistoryDate, opt => opt.MapFrom( + x => DateTime.SpecifyKind(x.HistoryDate, DateTimeKind.Utc))) .ForMember(x => x.Location, opt => opt.MapFrom( x => x)) .ForMember(x => x.Fuel, opt => opt.MapFrom( diff --git a/src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs new file mode 100644 index 0000000..ab83397 --- /dev/null +++ b/src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs @@ -0,0 +1,25 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; + +namespace Keeptrack.WebApi.MappingProfiles; + +public class HouseDataStorageMappingProfile : Profile +{ + public override string ProfileName + { + get { return "KeeptrackHouseDataStorageMappingProfile"; } + } + + public HouseDataStorageMappingProfile() + { + CreateMap(); + CreateMap(); + + // HistoryDate is DateOnly on the model, DateTime on the entity - the DateOnly<->DateTime converter + // registered in DataStorageMappingProfile (which also stamps DateTimeKind.Utc) applies automatically, + // same as every other date field in the app except Car's (see CarDataStorageMappingProfile for why + // Car needed its own explicit conversion instead). + CreateMap(); + CreateMap(); + } +} diff --git a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs index c2de262..ff5ae3b 100644 --- a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs +++ b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs @@ -21,6 +21,14 @@ public WebServiceMappingProfile() .ForMember(x => x.OwnerId, opt => opt.Ignore()); CreateMap(); + CreateMap() + .ForMember(x => x.OwnerId, opt => opt.Ignore()); + CreateMap(); + + CreateMap() + .ForMember(x => x.OwnerId, opt => opt.Ignore()); + CreateMap(); + CreateMap() .ForMember(x => x.OwnerId, opt => opt.Ignore()); CreateMap(); @@ -72,6 +80,12 @@ public WebServiceMappingProfile() CreateMap(); CreateMap(); + // House metrics reads are one-directional (Model -> Dto), same reasoning as Car metrics above: + // HouseMetricsService is a pure Domain-level computation with no Dto dependency. + CreateMap(); + CreateMap(); + CreateMap(); + // Reference-data reads are one-directional (Model -> Dto): admins submit a LinkReferenceRequestDto, // never a full TvShowReferenceDto/MovieReferenceDto, so there's no Dto -> Model direction to map. CreateMap(); diff --git a/src/WebApi/Program.cs b/src/WebApi/Program.cs index 360afd7..7549a48 100644 --- a/src/WebApi/Program.cs +++ b/src/WebApi/Program.cs @@ -22,9 +22,11 @@ builder.Services.AddSingleton(); builder.Services.AddSingleton(); builder.Services.AddSingleton(); +builder.Services.AddSingleton(); builder.Services.AddSingleton>(); builder.Services.AddSingleton>(); builder.Services.AddScoped(); +builder.Services.AddScoped(); builder.Services.AddSingleton(configuration.TmdbSettings); builder.Services.AddHttpClient(client => { diff --git a/src/WebApi/WebApi.csproj b/src/WebApi/WebApi.csproj index 0c1dfb7..d1d549c 100644 --- a/src/WebApi/WebApi.csproj +++ b/src/WebApi/WebApi.csproj @@ -12,6 +12,7 @@ + diff --git a/test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs b/test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs index 3b7b9cd..66cee7d 100644 --- a/test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/CarHistoryResourceTest.cs @@ -24,7 +24,7 @@ public class CarHistoryResourceTest(KestrelWebAppFactory factory) private static CarHistoryDto NewEntry(string carId, CarHistoryType eventType = CarHistoryType.Refuel) => new() { CarId = carId, - HistoryDate = DateOnly.FromDateTime(DateTime.Today), + HistoryDate = DateTime.Today, EventType = eventType, Mileage = 1000, Cost = 42.5, diff --git a/test/WebApi.IntegrationTests/Resources/HouseHistoryResourceTest.cs b/test/WebApi.IntegrationTests/Resources/HouseHistoryResourceTest.cs new file mode 100644 index 0000000..8c9a911 --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/HouseHistoryResourceTest.cs @@ -0,0 +1,103 @@ +using System; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Keeptrack.Common.System; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Basic full-cycle CRUD coverage for HouseHistory, same shape as . +/// +public class HouseHistoryResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + private const string ResourceEndpoint = "api/house-history"; + + private static HouseHistoryDto NewEntry(string houseId, HouseEventType eventType = HouseEventType.Maintenance) => new() + { + HouseId = houseId, + HistoryDate = DateOnly.FromDateTime(DateTime.Today), + EventType = eventType, + Cost = 42.5, + Description = "Test entry" + }; + + [Fact] + public async Task HouseHistoryResourceFullCycle_IsOk() + { + await GetAsync($"/{ResourceEndpoint}", HttpStatusCode.Unauthorized); + + await Authenticate(); + + var houseId = Guid.NewGuid().ToString(); + var initialItems = await GetAsync>($"/{ResourceEndpoint}?HouseId={houseId}"); + + var created = await PostAsync($"/{ResourceEndpoint}", NewEntry(houseId)); + created.Id.Should().NotBeNullOrEmpty(); + + try + { + created.Cost = 55.0; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + updated.Should().BeEquivalentTo(created); + + var finalItems = await GetAsync>($"/{ResourceEndpoint}?HouseId={houseId}"); + finalItems.TotalCount.Should().BeGreaterThan(initialItems.TotalCount); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + [Fact] + public async Task HouseHistoryResourceFilter_ByHouseId_OnlyReturnsThatHousesEntries_IsOk() + { + await Authenticate(); + + var houseId = Guid.NewGuid().ToString(); + var otherHouseId = Guid.NewGuid().ToString(); + var created = await PostAsync($"/{ResourceEndpoint}", NewEntry(houseId)); + var otherCreated = await PostAsync($"/{ResourceEndpoint}", NewEntry(otherHouseId)); + + try + { + var results = await GetAsync>($"/{ResourceEndpoint}?HouseId={houseId}"); + results.Items.Should().ContainSingle(x => x.Id == created.Id); + results.Items.Should().NotContain(x => x.Id == otherCreated.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + await DeleteAsync($"/{ResourceEndpoint}/{otherCreated.Id}"); + } + } + + [Fact] + public async Task HouseHistoryResourceFilter_ByHouseIdAndSearch_DoesNotThrow_IsOk() + { + await Authenticate(); + + var houseId = Guid.NewGuid().ToString(); + var description = Guid.NewGuid().ToString(); + var entry = NewEntry(houseId); + entry.Description = description; + var created = await PostAsync($"/{ResourceEndpoint}", entry); + + try + { + var results = await GetAsync>($"/{ResourceEndpoint}?HouseId={houseId}&search={description}"); + results.Items.Should().ContainSingle(x => x.Id == created.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } +} diff --git a/test/WebApi.IntegrationTests/Resources/HouseResourceTest.cs b/test/WebApi.IntegrationTests/Resources/HouseResourceTest.cs new file mode 100644 index 0000000..6c66834 --- /dev/null +++ b/test/WebApi.IntegrationTests/Resources/HouseResourceTest.cs @@ -0,0 +1,130 @@ +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using AwesomeAssertions; +using Bogus; +using Keeptrack.Common.System; +using Keeptrack.WebApi.Contracts.Dto; +using Keeptrack.WebApi.IntegrationTests.Hosting; +using Xunit; + +namespace Keeptrack.WebApi.IntegrationTests.Resources; + +/// +/// Basic full-cycle CRUD coverage for House, same shape as . +/// +public class HouseResourceTest(KestrelWebAppFactory factory) + : ResourceTestBase(factory) +{ + private const string ResourceEndpoint = "api/houses"; + + [Fact] + public async Task HouseResourceFullCycle_IsOk() + { + await GetAsync($"/{ResourceEndpoint}", HttpStatusCode.Unauthorized); + + await Authenticate(); + + var initialItems = await GetAsync>($"/{ResourceEndpoint}"); + + var input = new Faker() + .Rules((f, o) => + { + o.Name = f.Random.AlphaNumeric(14); + o.Address = f.Address.StreetAddress(); + o.City = f.Address.City(); + o.PostalCode = f.Address.ZipCode(); + o.Country = f.Address.Country(); + }) + .Generate(); + var created = await PostAsync($"/{ResourceEndpoint}", input); + created.Id.Should().NotBeNullOrEmpty(); + + try + { + created.Name = "New shiny name"; + await PutAsync($"/{ResourceEndpoint}/{created.Id}", created); + + var updated = await GetAsync($"/{ResourceEndpoint}/{created.Id}"); + updated.Should().BeEquivalentTo(created); + + var finalItems = await GetAsync>($"/{ResourceEndpoint}"); + finalItems.TotalCount.Should().BeGreaterThan(initialItems.TotalCount); + var firstItem = finalItems.Items.FirstOrDefault(x => x.Id == updated.Id); + firstItem.Should().NotBeNull(); + firstItem.Name.Should().Be(updated.Name); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + [Fact] + public async Task HouseResourceSearch_FiltersByName_IsOk() + { + await Authenticate(); + + var name = System.Guid.NewGuid().ToString(); + var created = await PostAsync($"/{ResourceEndpoint}", new HouseDto { Name = name }); + + try + { + var results = await GetAsync>($"/{ResourceEndpoint}?search={name}"); + results.Items.Should().ContainSingle(x => x.Id == created.Id); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + [Fact] + public async Task HouseResourceMetrics_ReturnsNotFound_ForAHouseThatDoesNotExist() + { + await Authenticate(); + + await GetAsync($"/{ResourceEndpoint}/{MongoDB.Bson.ObjectId.GenerateNewId()}/metrics", HttpStatusCode.NotFound); + } + + [Fact] + public async Task HouseResourceMetrics_ReturnsEmptyMetrics_ForAHouseWithNoHistoryYet() + { + await Authenticate(); + + var created = await PostAsync($"/{ResourceEndpoint}", new HouseDto { Name = System.Guid.NewGuid().ToString() }); + + try + { + var metrics = await GetAsync($"/{ResourceEndpoint}/{created.Id}/metrics"); + metrics.CostHistory.Should().BeEmpty(); + } + finally + { + await DeleteAsync($"/{ResourceEndpoint}/{created.Id}"); + } + } + + /// + /// HouseHistory is a separate top-level collection referencing its house by id (see CLAUDE.md's "Child + /// entities" section) - without HouseController.OnDeletedAsync cascading the delete, a deleted house's + /// history would be orphaned in MongoDB forever, only ever reachable via the now-gone house id. + /// + [Fact] + public async Task HouseResourceDelete_CascadesToItsHistory_IsOk() + { + await Authenticate(); + + var house = await PostAsync($"/{ResourceEndpoint}", new HouseDto { Name = System.Guid.NewGuid().ToString() }); + var entry = await PostAsync("/api/house-history", new HouseHistoryDto + { + HouseId = house.Id!, + HistoryDate = System.DateOnly.FromDateTime(System.DateTime.Today), + EventType = HouseEventType.Maintenance + }); + + await DeleteAsync($"/{ResourceEndpoint}/{house.Id}"); + + await GetAsync($"/api/house-history/{entry.Id}", HttpStatusCode.NotFound); + } +} diff --git a/test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs b/test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs index 18557c5..6b8a6ac 100644 --- a/test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs +++ b/test/WebApi.UnitTests/Services/CarMetricsServiceTest.cs @@ -12,7 +12,7 @@ public class CarMetricsServiceTest private readonly CarMetricsService _service = new(); private static CarHistoryModel Refuel( - string id, DateOnly date, int mileage, + string id, DateTime date, int mileage, double? fuelVolume = null, double? electricVolume = null, bool isFullRefill = true, double? deltaMileage = null, double? cost = null) => new() @@ -30,7 +30,7 @@ private static CarHistoryModel Refuel( Cost = cost }; - private static CarHistoryModel Maintenance(string id, DateOnly date, int? mileage = null, double? cost = null) => + private static CarHistoryModel Maintenance(string id, DateTime date, int? mileage = null, double? cost = null) => new() { Id = id, OwnerId = "owner", CarId = "car-1", HistoryDate = date, Mileage = mileage, EventType = CarHistoryType.Maintenance, Cost = cost }; [Fact] @@ -38,9 +38,9 @@ public void ComputeMetrics_FuelConsumption_OnlyEmitsAPointAcrossAFullRefill() { var history = new[] { - Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40, isFullRefill: true), - Refuel("h2", new DateOnly(2024, 1, 15), 1200, fuelVolume: 20, isFullRefill: false), - Refuel("h3", new DateOnly(2024, 2, 1), 1400, fuelVolume: 25, isFullRefill: true) + Refuel("h1", new DateTime(2024, 1, 1), 1000, fuelVolume: 40, isFullRefill: true), + Refuel("h2", new DateTime(2024, 1, 15), 1200, fuelVolume: 20, isFullRefill: false), + Refuel("h3", new DateTime(2024, 2, 1), 1400, fuelVolume: 25, isFullRefill: true) }; var result = _service.ComputeMetrics(history); @@ -55,10 +55,10 @@ public void ComputeMetrics_FuelAndElectricConsumption_AreComputedIndependentlyFo { var history = new[] { - Refuel("f1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40, isFullRefill: true), - Refuel("f2", new DateOnly(2024, 2, 1), 1500, fuelVolume: 35, isFullRefill: true), - Refuel("e1", new DateOnly(2024, 1, 10), 1100, electricVolume: 15, isFullRefill: true), - Refuel("e2", new DateOnly(2024, 1, 20), 1300, electricVolume: 30, isFullRefill: true) + Refuel("f1", new DateTime(2024, 1, 1), 1000, fuelVolume: 40, isFullRefill: true), + Refuel("f2", new DateTime(2024, 2, 1), 1500, fuelVolume: 35, isFullRefill: true), + Refuel("e1", new DateTime(2024, 1, 10), 1100, electricVolume: 15, isFullRefill: true), + Refuel("e2", new DateTime(2024, 1, 20), 1300, electricVolume: 30, isFullRefill: true) }; var result = _service.ComputeMetrics(history); @@ -75,9 +75,9 @@ public void ComputeMetrics_CostHistory_GroupsByMonthAndSplitsFuelFromMaintenance { var history = new[] { - Refuel("h1", new DateOnly(2024, 1, 5), 1000, fuelVolume: 40, cost: 60), - Maintenance("h2", new DateOnly(2024, 1, 20), 1050, cost: 150), - Refuel("h3", new DateOnly(2024, 2, 5), 1500, fuelVolume: 40, cost: 65) + Refuel("h1", new DateTime(2024, 1, 5), 1000, fuelVolume: 40, cost: 60), + Maintenance("h2", new DateTime(2024, 1, 20), 1050, cost: 150), + Refuel("h3", new DateTime(2024, 2, 5), 1500, fuelVolume: 40, cost: 65) }; var result = _service.ComputeMetrics(history); @@ -95,7 +95,7 @@ public void ComputeMetrics_CostHistory_GroupsByMonthAndSplitsFuelFromMaintenance [Fact] public void ComputeMetrics_NextMaintenance_IsNullWhenNoMaintenanceHistoryExists() { - var history = new[] { Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40) }; + var history = new[] { Refuel("h1", new DateTime(2024, 1, 1), 1000, fuelVolume: 40) }; var result = _service.ComputeMetrics(history); @@ -106,7 +106,7 @@ public void ComputeMetrics_NextMaintenance_IsNullWhenNoMaintenanceHistoryExists( public void ComputeMetrics_NextMaintenance_IsOneYearAfterTheLastMaintenanceEvent() { var lastMaintenance = DateOnly.FromDateTime(DateTime.Today).AddMonths(-10); - var history = new[] { Maintenance("h1", lastMaintenance) }; + var history = new[] { Maintenance("h1", lastMaintenance.ToDateTime(TimeOnly.MinValue)) }; var result = _service.ComputeMetrics(history); @@ -120,7 +120,7 @@ public void ComputeMetrics_NextMaintenance_IsOneYearAfterTheLastMaintenanceEvent public void ComputeMetrics_NextMaintenance_ReportsNegativeMonthsWhenOverdue() { var lastMaintenance = DateOnly.FromDateTime(DateTime.Today).AddMonths(-14); - var history = new[] { Maintenance("h1", lastMaintenance) }; + var history = new[] { Maintenance("h1", lastMaintenance.ToDateTime(TimeOnly.MinValue)) }; var result = _service.ComputeMetrics(history); @@ -132,8 +132,8 @@ public void ComputeMetrics_MileageWarnings_FlagsAnOdometerRegression() { var history = new[] { - Refuel("h1", new DateOnly(2024, 1, 1), 5000, fuelVolume: 40), - Refuel("h2", new DateOnly(2024, 2, 1), 4800, fuelVolume: 40) + Refuel("h1", new DateTime(2024, 1, 1), 5000, fuelVolume: 40), + Refuel("h2", new DateTime(2024, 2, 1), 4800, fuelVolume: 40) }; var result = _service.ComputeMetrics(history); @@ -148,8 +148,8 @@ public void ComputeMetrics_MileageWarnings_FlagsADeltaMismatchAndSuggestsAMissin // previous entry in the app - a refuel was very likely never logged in between var history = new[] { - Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40), - Refuel("h2", new DateOnly(2024, 2, 1), 1900, fuelVolume: 40, deltaMileage: 300) + Refuel("h1", new DateTime(2024, 1, 1), 1000, fuelVolume: 40), + Refuel("h2", new DateTime(2024, 2, 1), 1900, fuelVolume: 40, deltaMileage: 300) }; var result = _service.ComputeMetrics(history); @@ -163,8 +163,8 @@ public void ComputeMetrics_MileageWarnings_FlagsADeltaMismatchWithoutSuggestingA { var history = new[] { - Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40), - Refuel("h2", new DateOnly(2024, 2, 1), 1300, fuelVolume: 40, deltaMileage: 500) + Refuel("h1", new DateTime(2024, 1, 1), 1000, fuelVolume: 40), + Refuel("h2", new DateTime(2024, 2, 1), 1300, fuelVolume: 40, deltaMileage: 500) }; var result = _service.ComputeMetrics(history); @@ -178,8 +178,8 @@ public void ComputeMetrics_MileageWarnings_IsSilentWhenDeltaMileageMatchesWithin { var history = new[] { - Refuel("h1", new DateOnly(2024, 1, 1), 1000, fuelVolume: 40), - Refuel("h2", new DateOnly(2024, 2, 1), 1500, fuelVolume: 40, deltaMileage: 500.4) + Refuel("h1", new DateTime(2024, 1, 1), 1000, fuelVolume: 40), + Refuel("h2", new DateTime(2024, 2, 1), 1500, fuelVolume: 40, deltaMileage: 500.4) }; var result = _service.ComputeMetrics(history); diff --git a/test/WebApi.UnitTests/Services/HouseMetricsServiceTest.cs b/test/WebApi.UnitTests/Services/HouseMetricsServiceTest.cs new file mode 100644 index 0000000..fe1d359 --- /dev/null +++ b/test/WebApi.UnitTests/Services/HouseMetricsServiceTest.cs @@ -0,0 +1,74 @@ +using System; +using AwesomeAssertions; +using Keeptrack.Domain.Models; +using Keeptrack.Domain.Services; +using Xunit; + +namespace Keeptrack.WebApi.UnitTests.Services; + +[Trait("Category", "UnitTests")] +public class HouseMetricsServiceTest +{ + private readonly HouseMetricsService _service = new(); + + private static HouseHistoryModel Entry(string id, DateOnly date, HouseEventType eventType, double? cost = null) => + new() { Id = id, OwnerId = "owner", HouseId = "house-1", HistoryDate = date, EventType = eventType, Cost = cost }; + + [Fact] + public void ComputeMetrics_CostHistory_IsEmpty_WhenThereIsNoHistory() + { + var result = _service.ComputeMetrics([]); + + result.CostHistory.Should().BeEmpty(); + } + + [Fact] + public void ComputeMetrics_CostHistory_ExcludesEntriesWithNoCost() + { + var history = new[] { Entry("h1", new DateOnly(2024, 3, 1), HouseEventType.Maintenance, cost: null) }; + + var result = _service.ComputeMetrics(history); + + result.CostHistory.Should().BeEmpty(); + } + + [Fact] + public void ComputeMetrics_CostHistory_GroupsByYearAndSumsCost() + { + var history = new[] + { + Entry("h1", new DateOnly(2024, 1, 5), HouseEventType.Bill, cost: 60), + Entry("h2", new DateOnly(2024, 6, 1), HouseEventType.Maintenance, cost: 150), + Entry("h3", new DateOnly(2025, 2, 1), HouseEventType.Purchase, cost: 400) + }; + + var result = _service.ComputeMetrics(history); + + result.CostHistory.Should().HaveCount(2); + var year2024 = result.CostHistory[0]; + year2024.Year.Should().Be(2024); + year2024.TotalCost.Should().Be(210); + + var year2025 = result.CostHistory[1]; + year2025.Year.Should().Be(2025); + year2025.TotalCost.Should().Be(400); + } + + [Fact] + public void ComputeMetrics_CostHistory_BreaksDownByCategoryWithinAYear() + { + var history = new[] + { + Entry("h1", new DateOnly(2024, 1, 5), HouseEventType.Bill, cost: 60), + Entry("h2", new DateOnly(2024, 2, 5), HouseEventType.Bill, cost: 40), + Entry("h3", new DateOnly(2024, 6, 1), HouseEventType.Maintenance, cost: 150) + }; + + var result = _service.ComputeMetrics(history); + + var year2024 = result.CostHistory.Should().ContainSingle().Subject; + year2024.CostByCategory.Should().HaveCount(2); + year2024.CostByCategory.Should().ContainSingle(c => c.EventType == HouseEventType.Bill && c.Cost == 100); + year2024.CostByCategory.Should().ContainSingle(c => c.EventType == HouseEventType.Maintenance && c.Cost == 150); + } +} From 828eb6c3fd805380ce06c83a47d4eab9e5210f6f Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Sun, 12 Jul 2026 19:02:20 +0200 Subject: [PATCH 28/44] Add Automapper removal plan and switch license --- CLAUDE.md | 2 +- CONTRIBUTING.md | 15 +++- Keeptrack.slnx | 1 + LICENSE | 88 ++++++++++++++++------ README.md | 11 ++- docs/automapper-removal-plan.md | 129 ++++++++++++++++++++++++++++++++ 6 files changed, 222 insertions(+), 24 deletions(-) create mode 100644 docs/automapper-removal-plan.md diff --git a/CLAUDE.md b/CLAUDE.md index 46b218c..ece054d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co ## Project overview -Keeptrack is an open source application that lets users save and review everything they read, watch, listen to or play (books, movies, TV shows, music albums, video games, cars/car history). +Keeptrack is a source-available application (PolyForm Strict 1.0.0, see `LICENSE` - not open source) that lets users save and review everything they read, watch, listen to or play (books, movies, TV shows, music albums, video games, cars/car history). It is a three-tier .NET 10 / C# solution: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index c7c8c0a..7c0cb3e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -7,6 +7,17 @@ Follow this steps to run/debug/develop the application on your machine. For an environment, look at [operations.md](docs/operations.md). +## License and contribution terms + +Keeptrack is licensed under the [PolyForm Strict License 1.0.0](LICENSE), which by itself does not allow making changes or new works based on the software. +As an exception, the licensor grants you permission to modify the software solely for the purpose of developing, testing, and submitting contributions to the official repository (). +Running the application locally while developing a contribution is covered by the license's personal-use permission. + +By submitting a contribution in any form, you grant Bertrand THOMAS a perpetual, worldwide, irrevocable, royalty-free, sublicensable license over that contribution. +This grant covers using, reproducing, modifying, distributing, and relicensing it as part of Keeptrack, under any terms, including commercial ones. +You confirm that you have the right to grant this license for your contribution. +If you do not agree with these terms, do not submit a contribution. + ## Design The application source code is in the following .NET projects: @@ -229,7 +240,9 @@ Run a single test by fully qualified name (works for either project): dotnet test --filter-method "Keeptrack.WebApi.UnitTests.MappingProfiles.AutoMapperConfigurationTest.WebApiAutoMapperProfile_ShouldBeValid" ``` -`--filter-method` also accepts a wildcard, e.g. `--filter-method "*CarResourceTest*"` to run every test in a class - but it's a single glob pattern, not a real filter expression: it does not support `|`/`,` alternation to combine multiple patterns in one run (that just prints the CLI help instead of running anything), so run each pattern as its own `dotnet test` invocation. This project's test runner is `Microsoft.Testing.Platform` (`UseMicrosoftTestingPlatformRunner`, xunit v3), which does **not** understand the classic VSTest `--settings .runsettings` flag - passing it also just prints the help. `Local.runsettings` (below) is read automatically by Rider/Visual Studio for IDE-driven runs; for a CLI run, export the same values as environment variables instead (see "Integration tests" below). +`--filter-method` also accepts a wildcard, e.g. `--filter-method "*CarResourceTest*"` to run every test in a class - but it's a single glob pattern, not a real filter expression: it does not support `|`/`,` alternation to combine multiple patterns in one run (that just prints the CLI help instead of running anything), so run each pattern as its own `dotnet test` invocation. +This project's test runner is `Microsoft.Testing.Platform` (`UseMicrosoftTestingPlatformRunner`, xunit v3), which does **not** understand the classic VSTest `--settings .runsettings` flag - passing it also just prints the help. +`Local.runsettings` (below) is read automatically by Rider/Visual Studio for IDE-driven runs; for a CLI run, export the same values as environment variables instead (see "Integration tests" below). ### Unit tests diff --git a/Keeptrack.slnx b/Keeptrack.slnx index fc4787b..65f7fe4 100644 --- a/Keeptrack.slnx +++ b/Keeptrack.slnx @@ -12,6 +12,7 @@ + diff --git a/LICENSE b/LICENSE index 2a52121..a4a96c6 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,67 @@ -MIT License - -Copyright (c) 2019 Bertrand THOMAS - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. +Copyright (c) 2019-2026 Bertrand THOMAS + +This software is licensed under the PolyForm Strict License 1.0.0, reproduced verbatim below. +Contribution terms for this repository are described in CONTRIBUTING.md. +For any permission beyond the license below (including any commercial use, distribution, or hosting), contact the copyright holder. + +--- + +# PolyForm Strict License 1.0.0 + + + +## Acceptance + +In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses. + +## Copyright License + +The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose, other than distributing the software or making changes or new works based on the software. + +## Patent License + +The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software. + +## Noncommercial Purposes + +Any noncommercial purpose is a permitted purpose. + +## Personal Uses + +Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose. + +## Noncommercial Organizations + +Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding. + +## Fair Use + +You may have "fair use" rights for the software under the law. These terms do not limit them. + +## No Other Rights + +These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else. These terms do not imply any other licenses. + +## Patent Defense + +If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company. + +## Violations + +The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice. Otherwise, all your licenses end immediately. + +## No Liability + +***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.*** + +## Definitions + +The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms. + +**You** refers to the individual or entity agreeing to these terms. + +**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect. + +**Your licenses** are all the licenses granted to you for the software under these terms. + +**Use** means anything you do with the software requiring one of your licenses. diff --git a/README.md b/README.md index f54abab..b99c426 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ [![FOSSA Status](https://app.fossa.com/api/projects/custom%2B60068%2Fgithub.com%2Fdevpro%2Fkeeptrack.svg?type=shield&issueType=license)](https://app.fossa.com/projects/custom%2B60068%2Fgithub.com%2Fdevpro%2Fkeeptrack?ref=badge_shield&issueType=license) [![FOSSA Status](https://app.fossa.com/api/projects/custom%2B60068%2Fgithub.com%2Fdevpro%2Fkeeptrack.svg?type=shield&issueType=security)](https://app.fossa.com/projects/custom%2B60068%2Fgithub.com%2Fdevpro%2Fkeeptrack?ref=badge_shield&issueType=security) -Keeptrack is an open source application that let you save and review everything you read, watch, listen or play. +Keeptrack is a source-available application that let you save and review everything you read, watch, listen or play. ## Hosting @@ -27,3 +27,12 @@ Three-tier application: For more details, see [CONTRIBUTING.md](CONTRIBUTING.md). Any help is more than welcome 🙂 + +## License + +Keeptrack is licensed under the [PolyForm Strict License 1.0.0](LICENSE) - it is source-available, not open source. +You may read the code, run it for personal noncommercial purposes, and submit contributions (see [CONTRIBUTING.md](CONTRIBUTING.md) for the contribution terms). +Any other use - in particular any commercial use, distribution, or hosting the application for others - requires prior written permission from the repository owner. +Contact the repository owner to ask for permission. + +Versions of this repository published before this license change remain available under their original MIT license terms. diff --git a/docs/automapper-removal-plan.md b/docs/automapper-removal-plan.md new file mode 100644 index 0000000..3e8d26d --- /dev/null +++ b/docs/automapper-removal-plan.md @@ -0,0 +1,129 @@ +# AutoMapper removal and replacement plan + +## Why + +AutoMapper is no longer permissively licensed: since v15 (July 2025) it belongs to Lucky Penny Software and is dual-licensed, either the Reciprocal Public License 1.5 (RPL-1.5) or a commercial license. +RPL-1.5 is an aggressive copyleft license: using AutoMapper under it obligates Keeptrack itself to be licensed and published under RPL-1.5, which is incompatible with Keeptrack's own PolyForm Strict 1.0.0 license. +Until this removal ships, Keeptrack relies on AutoMapper's commercial "Community" tier (free below $5M revenue), which keeps the project bound to a third party's licensing terms and enforcement mechanism (license keys). +AutoMapper 16.2.0 is currently the only non-permissive dependency in `Directory.Packages.props`; every other package is MIT, Apache-2.0, BSD-3-Clause or MS-PL. +Removing it therefore ends the last third-party licensing constraint on Keeptrack. +It is also a quality win: the `AllowNullDestinationValues = false` behavior has caused at least four documented production bugs (see CLAUDE.md and `docs/code-quality-findings.md`). + +## Replacement choice + +Replace AutoMapper with [Riok.Mapperly](https://github.com/riok/mapperly) (Apache-2.0, actively maintained, v4.x), a compile-time source generator with no runtime reflection. + +Alternatives considered: + +- Fully hand-written mapper classes: zero dependencies, but no compile-time drift detection - adding a property and forgetting to map it fails silently, the class of bug `AutoMapperConfigurationTest` exists to catch today. +- Mapster: MIT-licensed but maintenance has stalled, and it is runtime-reflection based like AutoMapper, so it keeps the same "invalid configuration only fails at runtime" weakness. + +Mapperly wins because unmapped members surface as build diagnostics (`RMG012`/`RMG020`), which is a strictly stronger guarantee than the current runtime `AssertConfigurationIsValid` test. +Bespoke mappings that don't fit attribute configuration (Car's flattening) are hand-written as ordinary methods inside the same mapper class, which Mapperly supports natively. + +## Target architecture + +AutoMapper's single untyped `IMapper` is replaced by two small in-house interfaces, so the generic base classes stay generic: + +- `Infrastructure.MongoDb`: `IStorageMapper` with `TEntity ToEntity(TModel model)`, `TModel ToModel(TEntity entity)` and `List ToModels(List entities)`. +- `WebApi`: `IDtoMapper` with `TModel ToModel(TDto dto)` and `TDto ToDto(TModel model)`. + +`MongoDbRepositoryBase` takes `IStorageMapper` instead of `IMapper`; `DataCrudControllerBase` takes `IDtoMapper` instead of `IMapper`. +Each entity type gets one `[Mapper]` partial class per boundary (e.g. `BookStorageMapper : IStorageMapper` and `BookDtoMapper : IDtoMapper`). +All mappers are registered as singletons in the existing DI extension methods. +Storage mappers move into `Infrastructure.MongoDb/Mappers/` - they map entities to Domain models, so they belong in the project that owns both types. +They only live in `WebApi` today because `AddAutoMapper` is app-level wiring. +DTO mappers live in `WebApi/Mappers/`, replacing `WebApi/MappingProfiles/`. +The owner-less reference repositories inject their concrete mapper class directly - they are purpose-built already and need no shared abstraction. +This covers `TvShowReferenceRepository`, `MovieReferenceRepository`, `BookReferenceRepository`, `VideoGameReferenceRepository`, `AlbumReferenceRepository` and `PersonReferenceRepository`. +Read-only feature controllers (`WatchNextController`, `WishlistController`, `ReferenceDataController`, `CarController`'s metrics, `HouseController`'s metrics) get small one-directional Model-to-DTO mapper classes following the same pattern. +`PagedResult.Map` in `Common.System` takes a plain delegate and needs no change. + +## Behavioral decisions + +### Drop `AllowNullDestinationValues = false` (the central decision) + +AutoMapper is configured so that a null source string maps to `""` and a null source object maps to a new all-default instance. +Mapperly preserves nulls, which is the honest semantics this codebase has repeatedly patched its way back toward. +The evidence: the `FindOneAsync` 404 guard, the `ReferenceMatch.Creator` alias duplication, the `NextMaintenance` `AllowNull()`, and the `Coordinates` `AllowNull()`. +The migration deliberately adopts null-preserving semantics instead of replicating the old behavior. + +Consequences to handle: + +- New writes will omit unset string fields entirely (the codebase-wide `IgnoreIfNullConvention(true)` already does this for null properties) instead of storing `""`; old documents keep their stored `""` values. +- Every "is this string field unset" query must match null or empty - `UnresolvedFilter()` already does; audit for any other `Eq(field, "")` or `Eq(field, null)` unset-checks and align them. +- Explicit `ReferenceId = ""` assignments (the "clear the link" path in `TryLinkExisting*ReferenceAsync`) are plain code, not mapping behavior, and stay as-is. +- The `ReferenceMatch.Creator` and `CarHistoryLocation.Coordinates` `AllowNull()` opt-outs become dead configuration and are deleted; keep `UpsertAsync_PersistsANullCreator_AsAnActualBsonNullNotAnEmptyString` as the regression guard. +- The `entity is null` guards in `FindOneAsync` and the reference repositories' `Find*Async` methods stay: Mapperly throws on a null source, so the guards remain the only correct "not found" handling. + +### Nullable DTO members mapping to `required` model members + +`BookDto.Title` is nullable while `BookModel.Title` is `required` non-nullable (the `InventoryPageBase` `new()`-constraint gotcha), and AutoMapper silently substituted `""` today. +Mapperly refuses to compile this silently, which forces an explicit per-member decision. +For exact behavior parity, map these members with an explicit `?? string.Empty` user mapping in the affected DTO mappers first. +Tightening this to a real 400 validation error for a missing title is a worthwhile follow-up, but a separate change - don't mix a behavior change into the mechanical migration. + +### Enum mapping between Domain and Contracts + +Domain enums and their Contracts duplicates (`TvShowStatus`, `CarHistoryType`, `CarEnergyType`, `HouseEventType`, `ReferenceItemType`) are mapped by name today via AutoMapper's automatic enum-by-name convention. +Set `EnumMappingStrategy = EnumMappingStrategy.ByName` on the DTO mappers' `[Mapper]` attribute. +This upgrades the guarantee: a member-name drift between the two enum definitions becomes a build diagnostic instead of a runtime surprise. + +### `DateOnly` <-> `DateTime` UTC conversion + +The global converter pair in `DataStorageMappingProfile` becomes a shared static class (e.g. `CommonStorageMappings`) with two `[UserMapping]` methods. +Each storage mapper that needs it attaches it via `[UseStaticMapper(typeof(CommonStorageMappings))]`. +The `DateTimeKind.Utc` stamping must be preserved exactly - the Mongo driver's `DateTimeSerializer` requires it. + +### Car's bespoke flattening + +`CarDataStorageMappingProfile`'s `CarHistory` mapping (Location/Fuel/Station sub-documents, coordinate array packing, `DateTime.SpecifyKind` UTC stamping) is hand-written rather than translated to attribute configuration. +The hand-written method bodies live inside `CarHistoryStorageMapper` as ordinary C#. +The logic is bespoke enough that explicit C# is more readable than attribute soup, and Mapperly supports mixing hand-written and generated methods in one mapper class. +The null-coordinates semantics (never persist an empty list, only a 2-element list or nothing) must be preserved - `CarHistoryResourceTest` covers the round-trip. + +### Member ignores + +- `OwnerId` on every DTO-to-Model map: `[MapperIgnoreTarget(nameof(IHasIdAndOwnerId.OwnerId))]`, preserving the "OwnerId is set server-side from claims, never from client input" rule. +- `VideoGameModel.Platform`/`State` on the entity-to-model map: `[MapperIgnoreTarget]`, same as today's `ForMember` ignores. +- `TvShowReferenceDto`/`MovieReferenceDto.Cast`, `BookReferenceDto.AuthorName`/`AuthorImageUrl`, `AlbumReferenceDto.ArtistName`/`ArtistImageUrl`: `[MapperIgnoreTarget]` - these stay hydrated by `ReferenceDataController` joins. + +## Migration phases + +Each phase builds, passes the full test suite (including integration tests against a real MongoDB), and is independently committable. +`AddAutoMapper` stays registered until the last profile is deleted, so both systems coexist during the migration. + +### Phase 1: storage boundary (Infrastructure.MongoDb) + +1. Add the `Riok.Mapperly` package to `Directory.Packages.props` and `Infrastructure.MongoDb.csproj`. +2. Add `IStorageMapper` and `CommonStorageMappings`. +3. Implement one storage mapper per entity pair currently in the three `*DataStorageMappingProfile` classes (about 20 pairs, including embedded types like `Episode`, `ReferenceMatch` and `CastMember`). +4. Switch `MongoDbRepositoryBase` and the six owner-less reference repositories from `IMapper` to the new mappers, updating every repository's primary constructor. +5. Register the mappers in `InfrastructureServiceCollectionExtensions`. +6. Delete the three `*DataStorageMappingProfile` classes. +7. Run the integration test suite against a real MongoDB - the codebase's own history says serialization-level regressions (null vs `""`, missing UTC kind) are only catchable there, never by mocked unit tests. + +### Phase 2: web boundary (WebApi) + +1. Add `IDtoMapper` and implement one DTO mapper per pair currently in `WebServiceMappingProfile` (about 15 CRUD pairs plus the one-directional WatchNext, Wishlist, Car metrics, House metrics and reference-data maps). +2. Switch `DataCrudControllerBase`, every per-type controller, `WatchNextController`, `WishlistController` and `ReferenceDataController` to the new mappers. +3. Register the mappers in the WebApi DI wiring. +4. Delete `WebServiceMappingProfile`. +5. Run the full test suite again, plus a manual pass over one detail page per domain, a TV Time import, and the Car/House metrics endpoints. + +### Phase 3: removal and hardening + +1. Remove the `AddAutoMapper` call and the `AllowNullDestinationValues` configuration from `WebApi/Program.cs`. +2. Remove `global using AutoMapper;` from `WebApi/GlobalUsings.cs` and the remaining `using AutoMapper;` directives. +3. Remove the `AutoMapper` package reference from `Directory.Packages.props`, `WebApi.csproj`, `Infrastructure.MongoDb.csproj` and `WebApi.IntegrationTests.csproj` (the last is vestigial - tests resolve repositories through DI). +4. Delete `AutoMapperConfigurationTest` - its job is now done at compile time. +5. Escalate Mapperly's unmapped-member diagnostics (`RMG012`, `RMG020`) to errors in `.editorconfig`, so configuration drift fails the build the way the deleted test used to fail the run. +6. Update CLAUDE.md: rewrite the `AllowNullDestinationValues` gotchas for the new null-preserving semantics, and update the "Adding a new trackable item type" checklist (step 6 becomes "add a storage mapper and a DTO mapper"). +7. Update `CONTRIBUTING.md` and `docs/code-quality-findings.md` where they reference AutoMapper. + +## Out of scope + +- No MongoDB data migration is required: old documents with `""` values stay readable, and the null-or-empty query pattern covers both generations of data. +- An optional cleanup script normalizing stored `""` to unset (same run-once style as `migrate-poster-url-to-image-url.js`) can follow later but is not a prerequisite. +- Turning the missing-required-title case into a 400 validation error is deferred (see above). +- The project's own relicensing to PolyForm Strict 1.0.0 has already happened (see `LICENSE`); this removal ends the interim reliance on AutoMapper's Community tier. From 2a6ad69a16db54f23012b5c2edef99e808cdf92e Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Sun, 12 Jul 2026 21:40:29 +0200 Subject: [PATCH 29/44] Remove BOM from markdownlint config file --- .markdownlint-cli2.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.markdownlint-cli2.yaml b/.markdownlint-cli2.yaml index bc94ac6..5e56cf4 100644 --- a/.markdownlint-cli2.yaml +++ b/.markdownlint-cli2.yaml @@ -1,4 +1,4 @@ -gitignore: true +gitignore: true ignores: - "**/node_modules/**" config: From c7d8d8b918552eb4d42513478c04207c43ee8b8d Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Mon, 13 Jul 2026 01:23:50 +0200 Subject: [PATCH 30/44] AutoMapper removal MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 1 (storage boundary): Added Riok.Mapperly, created IStorageMapper + CommonStorageMappings (shared DateOnly<->DateTime UTC conversion), and 18 storage mapper classes in Infrastructure.MongoDb/Mappers/ (12 generated via [Mapper], CarHistoryStorageMapper hand-written for the bespoke Location/Fuel/Station flattening). Switched MongoDbRepositoryBase and all 18 repositories off IMapper, deleted the three *DataStorageMappingProfile classes. Phase 2 (web boundary): Added IDtoMapper + CommonDtoMappings (the ?? string.Empty fallback for nullable-DTO-to-required-model strings), 12 CRUD DTO mappers plus 8 one-directional Model→Dto mappers (WatchNext, Car/House metrics, the five reference-data types). Handled the one enum+nullability edge case (CarDto.EnergyType) with a hand-written null fallback wrapping a Mapperly-generated ByName enum conversion. Switched every controller off IMapper, deleted WebServiceMappingProfile. Phase 3 (removal/hardening): Removed AddAutoMapper, the AutoMapper package everywhere, and AutoMapperConfigurationTest (its job is now a compile-time check). Escalated Mapperly's RMG012/RMG020 to build errors in .editorconfig. Updated CLAUDE.md, CONTRIBUTING.md, and docs/code-quality-findings.md to reflect the new null-preserving semantics and reframe the old AllowNullDestinationValues gotchas as historical. --- .editorconfig | 4 + CLAUDE.md | 34 +++--- CONTRIBUTING.md | 2 +- Directory.Build.props | 6 +- Directory.Packages.props | 2 +- docs/code-quality-findings.md | 7 +- .../Entities/ReferenceMatch.cs | 13 +- .../Infrastructure.MongoDb.csproj | 2 +- .../Mappers/AlbumReferenceStorageMapper.cs | 17 +++ .../Mappers/AlbumStorageMapper.cs | 16 +++ .../Mappers/BookReferenceStorageMapper.cs | 17 +++ .../Mappers/BookStorageMapper.cs | 17 +++ .../Mappers/CarHistoryStorageMapper.cs | 115 ++++++++++++++++++ .../Mappers/CarStorageMapper.cs | 16 +++ .../Mappers/CommonStorageMappings.cs | 26 ++++ .../Mappers/EpisodeStorageMapper.cs | 17 +++ .../Mappers/HouseHistoryStorageMapper.cs | 17 +++ .../Mappers/HouseStorageMapper.cs | 16 +++ .../Mappers/IStorageMapper.cs | 18 +++ .../Mappers/MovieReferenceStorageMapper.cs | 17 +++ .../Mappers/MovieStorageMapper.cs | 17 +++ .../Mappers/PersonReferenceStorageMapper.cs | 17 +++ .../Mappers/PlaylistStorageMapper.cs | 16 +++ .../Mappers/SongStorageMapper.cs | 16 +++ .../Mappers/TvShowReferenceStorageMapper.cs | 19 +++ .../Mappers/TvShowStorageMapper.cs | 16 +++ .../VideoGameReferenceStorageMapper.cs | 17 +++ .../Mappers/VideoGameStorageMapper.cs | 24 ++++ .../Repositories/AlbumReferenceRepository.cs | 18 +-- .../Repositories/AlbumRepository.cs | 9 +- .../Repositories/BookReferenceRepository.cs | 18 +-- .../Repositories/BookRepository.cs | 9 +- .../Repositories/CarHistoryRepository.cs | 4 +- .../Repositories/CarRepository.cs | 6 +- .../Repositories/EpisodeRepository.cs | 4 +- .../Repositories/HouseHistoryRepository.cs | 4 +- .../Repositories/HouseRepository.cs | 4 +- .../Repositories/MongoDbRepositoryBase.cs | 27 ++-- .../Repositories/MovieReferenceRepository.cs | 22 ++-- .../Repositories/MovieRepository.cs | 9 +- .../Repositories/PersonReferenceRepository.cs | 18 +-- .../Repositories/PlaylistRepository.cs | 4 +- .../Repositories/SongRepository.cs | 4 +- .../Repositories/TvShowReferenceRepository.cs | 22 ++-- .../Repositories/TvShowRepository.cs | 9 +- .../VideoGameReferenceRepository.cs | 18 +-- .../Repositories/VideoGameRepository.cs | 9 +- src/WebApi.Contracts/Dto/HouseEventType.cs | 4 +- src/WebApi.Contracts/Dto/TvShowStatus.cs | 3 +- src/WebApi/Controllers/AlbumController.cs | 5 +- src/WebApi/Controllers/BookController.cs | 5 +- src/WebApi/Controllers/CarController.cs | 8 +- .../Controllers/CarHistoryController.cs | 3 +- .../Controllers/DataCrudControllerBase.cs | 19 +-- src/WebApi/Controllers/EpisodeController.cs | 3 +- src/WebApi/Controllers/HouseController.cs | 8 +- .../Controllers/HouseHistoryController.cs | 3 +- src/WebApi/Controllers/MovieController.cs | 5 +- src/WebApi/Controllers/PlaylistController.cs | 3 +- src/WebApi/Controllers/SongController.cs | 3 +- src/WebApi/Controllers/TvShowController.cs | 5 +- src/WebApi/Controllers/VideoGameController.cs | 5 +- src/WebApi/Controllers/WatchNextController.cs | 9 +- src/WebApi/Controllers/WishlistController.cs | 14 ++- ...frastructureServiceCollectionExtensions.cs | 24 +++- src/WebApi/GlobalUsings.cs | 1 - src/WebApi/Mappers/AlbumDtoMapper.cs | 16 +++ src/WebApi/Mappers/AlbumReferenceDtoMapper.cs | 23 ++++ src/WebApi/Mappers/BookDtoMapper.cs | 19 +++ src/WebApi/Mappers/BookReferenceDtoMapper.cs | 23 ++++ src/WebApi/Mappers/CarDtoMapper.cs | 32 +++++ src/WebApi/Mappers/CarHistoryDtoMapper.cs | 15 +++ src/WebApi/Mappers/CarMetricsDtoMapper.cs | 16 +++ src/WebApi/Mappers/CommonDtoMappings.cs | 23 ++++ src/WebApi/Mappers/EpisodeDtoMapper.cs | 15 +++ src/WebApi/Mappers/HouseDtoMapper.cs | 16 +++ src/WebApi/Mappers/HouseHistoryDtoMapper.cs | 15 +++ src/WebApi/Mappers/HouseMetricsDtoMapper.cs | 15 +++ src/WebApi/Mappers/IDtoMapper.cs | 16 +++ src/WebApi/Mappers/InProgressShowDtoMapper.cs | 16 +++ src/WebApi/Mappers/MovieDtoMapper.cs | 16 +++ src/WebApi/Mappers/MovieReferenceDtoMapper.cs | 20 +++ src/WebApi/Mappers/PlaylistDtoMapper.cs | 16 +++ src/WebApi/Mappers/SongDtoMapper.cs | 16 +++ src/WebApi/Mappers/TvShowDtoMapper.cs | 16 +++ .../Mappers/TvShowReferenceDtoMapper.cs | 23 ++++ src/WebApi/Mappers/VideoGameDtoMapper.cs | 16 +++ .../Mappers/VideoGameReferenceDtoMapper.cs | 17 +++ .../CarDataStorageMappingProfile.cs | 97 --------------- .../DataStorageMappingProfile.cs | 83 ------------- .../HouseDataStorageMappingProfile.cs | 25 ---- .../WebServiceMappingProfile.cs | 113 ----------------- src/WebApi/Program.cs | 36 ++++-- .../ReferenceData/ReferenceDataController.cs | 21 ++-- src/WebApi/WebApi.csproj | 2 +- src/WebApi/appsettings.json | 2 +- .../Resources/AlbumResourceTest.cs | 2 +- .../Resources/TvShowReferenceLinkingTest.cs | 5 +- .../TvShowReferenceRepositoryTest.cs | 2 +- .../WebApi.IntegrationTests.csproj | 1 - .../AutoMapperConfigurationTest.cs | 20 --- 101 files changed, 1134 insertions(+), 544 deletions(-) create mode 100644 src/Infrastructure.MongoDb/Mappers/AlbumReferenceStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/AlbumStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/BookReferenceStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/BookStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/CarHistoryStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/CarStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/CommonStorageMappings.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/EpisodeStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/HouseHistoryStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/HouseStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/IStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/MovieReferenceStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/MovieStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/PersonReferenceStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/PlaylistStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/SongStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/TvShowReferenceStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/TvShowStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/VideoGameReferenceStorageMapper.cs create mode 100644 src/Infrastructure.MongoDb/Mappers/VideoGameStorageMapper.cs create mode 100644 src/WebApi/Mappers/AlbumDtoMapper.cs create mode 100644 src/WebApi/Mappers/AlbumReferenceDtoMapper.cs create mode 100644 src/WebApi/Mappers/BookDtoMapper.cs create mode 100644 src/WebApi/Mappers/BookReferenceDtoMapper.cs create mode 100644 src/WebApi/Mappers/CarDtoMapper.cs create mode 100644 src/WebApi/Mappers/CarHistoryDtoMapper.cs create mode 100644 src/WebApi/Mappers/CarMetricsDtoMapper.cs create mode 100644 src/WebApi/Mappers/CommonDtoMappings.cs create mode 100644 src/WebApi/Mappers/EpisodeDtoMapper.cs create mode 100644 src/WebApi/Mappers/HouseDtoMapper.cs create mode 100644 src/WebApi/Mappers/HouseHistoryDtoMapper.cs create mode 100644 src/WebApi/Mappers/HouseMetricsDtoMapper.cs create mode 100644 src/WebApi/Mappers/IDtoMapper.cs create mode 100644 src/WebApi/Mappers/InProgressShowDtoMapper.cs create mode 100644 src/WebApi/Mappers/MovieDtoMapper.cs create mode 100644 src/WebApi/Mappers/MovieReferenceDtoMapper.cs create mode 100644 src/WebApi/Mappers/PlaylistDtoMapper.cs create mode 100644 src/WebApi/Mappers/SongDtoMapper.cs create mode 100644 src/WebApi/Mappers/TvShowDtoMapper.cs create mode 100644 src/WebApi/Mappers/TvShowReferenceDtoMapper.cs create mode 100644 src/WebApi/Mappers/VideoGameDtoMapper.cs create mode 100644 src/WebApi/Mappers/VideoGameReferenceDtoMapper.cs delete mode 100644 src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs delete mode 100644 src/WebApi/MappingProfiles/DataStorageMappingProfile.cs delete mode 100644 src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs delete mode 100644 src/WebApi/MappingProfiles/WebServiceMappingProfile.cs delete mode 100644 test/WebApi.UnitTests/MappingProfiles/AutoMapperConfigurationTest.cs diff --git a/.editorconfig b/.editorconfig index 0a60a2c..8fd4b9f 100644 --- a/.editorconfig +++ b/.editorconfig @@ -152,3 +152,7 @@ csharp_space_between_square_brackets = false csharp_prefer_braces = true:silent csharp_preserve_single_line_blocks = true csharp_preserve_single_line_statements = true +# Mapperly configuration drift (an unmapped source or target member on a [Mapper] class) must fail the build, the way AutoMapperConfigurationTest's AssertConfigurationIsValid() used to fail the test run +# before it was deleted - see docs/automapper-removal-plan.md. +dotnet_diagnostic.RMG012.severity = error +dotnet_diagnostic.RMG020.severity = error diff --git a/CLAUDE.md b/CLAUDE.md index ece054d..22e389a 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -33,7 +33,7 @@ dotnet test test/WebApi.UnitTests/WebApi.UnitTests.csproj dotnet test test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj # run a single test by fully qualified name -dotnet test --filter-method "Keeptrack.WebApi.UnitTests.MappingProfiles.AutoMapperConfigurationTest.WebApiAutoMapperProfile_ShouldBeValid" +dotnet test --filter-method "Keeptrack.WebApi.UnitTests.Services.WatchNextServiceTest.ComputeInProgressShows_IncludesShowWithAConfirmedAiredUnwatchedNextEpisode" # build container images docker build . -t devprofr/keeptrack-blazorapp:local -f src/BlazorApp/Dockerfile @@ -58,19 +58,21 @@ The solution follows a layered / clean-architecture style split across small, si | `Domain` | `Common.System` | Business models (`*Model` in `Models/`) and repository interfaces (`I*Repository` in `Repositories/`). No persistence or web concerns. | | `Infrastructure.MongoDb` | `Domain` | MongoDB implementation: BSON `Entities/` and `Repositories/` implementing the `Domain` interfaces. | | `WebApi.Contracts` | `Common.System` | Public REST DTOs (`Dto/`), shared between `WebApi` and `BlazorApp` so the Blazor client can deserialize API responses without duplicating classes. | -| `WebApi` | `Infrastructure.MongoDb`, `Domain`, `WebApi.Contracts` | ASP.NET Web API: controllers, AutoMapper profiles, DI wiring, JWT authentication, OpenAPI/Scalar docs. | +| `WebApi` | `Infrastructure.MongoDb`, `Domain`, `WebApi.Contracts` | ASP.NET Web API: controllers, DTO mappers, DI wiring, JWT authentication, OpenAPI/Scalar docs. | | `BlazorApp` | `Common.System`, `WebApi.Contracts` | Blazor Server UI. Talks to `WebApi` over HTTP using the shared DTOs; it never references `Domain` or `Infrastructure.MongoDb` directly. | ### Data model conventions -Every entity that belongs to a user implements `IHasIdAndOwnerId` (`Id` + `OwnerId`) at all three layers (`Domain` model, MongoDB entity, contract DTO), each with its own class. AutoMapper profiles convert between them: +Every entity that belongs to a user implements `IHasIdAndOwnerId` (`Id` + `OwnerId`) at all three layers (`Domain` model, MongoDB entity, contract DTO), each with its own class. Mapping between them is generated at compile time by [Riok.Mapperly](https://github.com/riok/mapperly) (a source generator, no runtime reflection) rather than AutoMapper - see `docs/automapper-removal-plan.md` for the removal history: -- `Infrastructure.MongoDb/../MappingProfiles`-equivalent lives in `WebApi/MappingProfiles/DataStorageMappingProfile.cs`: MongoDB entity <-> Domain model. -- `WebApi/MappingProfiles/WebServiceMappingProfile.cs`: DTO <-> Domain model. `OwnerId` is always ignored on the DTO -> model direction; it is set server-side from the authenticated user's claims, never trusted from client input. +- `Infrastructure.MongoDb/Mappers/`: one `[Mapper]` partial class per entity pair (e.g. `BookStorageMapper`), implementing `IStorageMapper` (`Infrastructure.MongoDb/Mappers/IStorageMapper.cs`) - MongoDB entity <-> Domain model. Injected into `MongoDbRepositoryBase` and the six owner-less reference repositories. +- `WebApi/Mappers/`: one `[Mapper]` partial class per CRUD pair (e.g. `BookDtoMapper`), implementing `IDtoMapper` (`WebApi/Mappers/IDtoMapper.cs`) - DTO <-> Domain model. `OwnerId` is always set via `[MapValue(nameof(Model.OwnerId), "")]` (not `[MapperIgnoreTarget]` - `OwnerId` is `required` on the model, so a plain ignore would fail to compile the generated object initializer) on the DTO -> model direction; the placeholder value is immediately overwritten server-side from the authenticated user's claims in `DataCrudControllerBase`, never trusted from client input. Read-only feature controllers (`WatchNextController`, `WishlistController`, `CarController`/`HouseController`'s metrics, `ReferenceDataController`) use a small one-directional Model-to-DTO mapper class instead (e.g. `CarMetricsDtoMapper`), injected as its concrete type rather than through `IDtoMapper` - they have no DTO -> Model direction to speak of. -`AutoMapperConfigurationTest` (in `WebApi.UnitTests`) asserts the whole mapping configuration is valid; add a mapping there whenever a new model/entity/DTO triple is introduced. +Unmapped members are build errors, not a runtime assertion: `RMG012`/`RMG020` (Mapperly's unmapped-target/unmapped-source diagnostics) are escalated to `error` severity in `.editorconfig`, so a new property added to a model/entity/DTO without a matching mapping fails the build immediately - this replaced the old `AutoMapperConfigurationTest`'s runtime `AssertConfigurationIsValid()` check, now enforced at compile time instead. A source-only member each direction doesn't need (like `OwnerId` on the Model -> Dto direction, or a filter-only DTO/model field with no entity counterpart) needs an explicit `[MapperIgnoreSource]`/`[MapperIgnoreTarget]` attribute to satisfy this - don't leave a member unmapped and unignored, the build won't compile. -An enum used in a `Domain` model (e.g. `TvShowModel.Status: TvShowStatus?`) needs its own **separate** definition in `WebApi.Contracts` (`TvShowDto.Status` uses `Keeptrack.WebApi.Contracts.Dto.TvShowStatus`, not the Domain one) - `WebApi.Contracts` doesn't depend on `Domain` (see the project table above), so the DTO can't reference the Domain enum directly. Keep the member names identical between the two; AutoMapper maps enum-to-enum by name automatically, no explicit `CreateMap` needed. The Mongo entity, on the other hand, *can* reuse the Domain enum directly (`Infrastructure.MongoDb` depends on `Domain`) - only the Contracts layer needs the duplicate. +An enum used in a `Domain` model (e.g. `TvShowModel.State: TvShowStatus?`) needs its own **separate** definition in `WebApi.Contracts` (`TvShowDto.State` uses `Keeptrack.WebApi.Contracts.Dto.TvShowStatus`, not the Domain one) - `WebApi.Contracts` doesn't depend on `Domain` (see the project table above), so the DTO can't reference the Domain enum directly. Keep the member names identical between the two; the DTO mapper sets `EnumMappingStrategy = EnumMappingStrategy.ByName` on its `[Mapper]` attribute so Mapperly maps enum-to-enum by name, generating a build diagnostic (rather than a silent runtime mismatch) if a member name ever drifts between the two definitions. The Mongo entity, on the other hand, *can* reuse the Domain enum directly (`Infrastructure.MongoDb` depends on `Domain`) - only the Contracts layer needs the duplicate, and storage mappers don't need the `ByName` strategy since there's only one enum type involved. + +**Gotcha:** a DTO member that's nullable while its model counterpart is `required` non-nullable (the `InventoryPageBase` `new()`-constraint gotcha two sections down - e.g. `BookDto.Title` vs. `BookModel.Title`) needs an explicit fallback on the DTO -> model direction; Mapperly refuses to compile a silent substitution the way AutoMapper used to. `CommonDtoMappings.ToRequiredString` (`WebApi/Mappers/`, a `[UserMapping]` static method attached to the affected DTO mappers via `[UseStaticMapper(typeof(CommonDtoMappings))]`) reproduces AutoMapper's old `?? string.Empty` behavior for every such string member across every mapper that needs it, for exact behavior parity - tightening this to a real 400 validation error for a missing title is a deliberate follow-up, not part of the mechanical migration. `CarDto.EnergyType` (nullable) -> `CarModel.EnergyType` (required, non-nullable, and a *different* enum type than the Dto's) needs the same treatment but can't reuse `ToRequiredString` (wrong types) - see `CarDtoMapper`'s own hand-written `[UserMapping]` for the pattern: a partial method gets the generated, drift-checked `ByName` enum conversion, wrapped by one small hand-written method that only handles the null -> `default` fallback. ### Adding a new trackable item type @@ -81,7 +83,7 @@ Follow the existing types (`Book`, `Movie`, `Album`, `TvShow`, `VideoGame`, `Car 3. `WebApi.Contracts/Dto/Dto.cs` (XML doc comments drive the generated OpenAPI spec). 4. `WebApi/Controllers/Controller.cs`: a one-line class extending `DataCrudControllerBase` — CRUD logic is never duplicated per controller. 5. Register the repository in `WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs`. -6. Add both AutoMapper maps (`DataStorageMappingProfile`, `WebServiceMappingProfile`). +6. Add a storage mapper (`Infrastructure.MongoDb/Mappers/StorageMapper.cs`, implementing `IStorageMapper`, registered in `InfrastructureServiceCollectionExtensions.cs`) and a DTO mapper (`WebApi/Mappers/DtoMapper.cs`, implementing `IDtoMapper`, registered in `Program.cs`). 7. `BlazorApp/Components/Inventory/Clients/ApiClient.cs` extending `InventoryApiClientBase`, plus a `Pages/.razor` / `.razor.cs` pair extending `InventoryPageBase`. **Gotcha:** `Dto` can never have a `required` member if `Pages/.razor.cs` extends `InventoryPageBase` — that base class is constrained `where TDto : IHasId, new()`, and a type with *any* `required` member can't satisfy a bare `new()` constraint in C# (`CS9040`). This is why `BookDto.Title`, `CarDto.Name`, etc. are all nullable even though their Domain model counterpart (`BookModel.Title`, `CarModel.Name`) is `required` — it's a hard language limitation forced by the generic list-page base class, not a design inconsistency to "fix" by making the Dto match the model. A Dto with no `InventoryPageBase` usage (e.g. `CarHistoryDto`, owned-by-a-parent types managed from their parent's detail page rather than their own list page) has no such constraint and can mirror the Domain model's `required` members in full. @@ -92,7 +94,7 @@ Follow the existing types (`Book`, `Movie`, `Album`, `TvShow`, `VideoGame`, `Car `CarHistoryModel.EventType` (`CarHistoryType`: `Refuel`/`Maintenance`/`Other`) is a real discriminated enum, not free text — the same "never name a property/field bare `Type`" rule as any other discriminator in this codebase (see `TvShowModel.State`'s own rename history above): a bare `Type` reads ambiguously and collides in spirit with `object.GetType()`/`System.Type`. `Car.EnergyType` (`CarEnergyType`: `Combustion`/`Hybrid`/`Electric`) and `CarHistoryModel.EventType`/`CarId`/`HistoryDate` are all `required` on both the Domain model and the Mongo entity; `CarDto` itself can't mirror `Name`/`EnergyType` as `required`, because `Cars.razor` extends `InventoryPageBase`, which needs a bare `new()` constraint — a type with *any* `required` member can't satisfy `new()` in C#, so the Dto layer stays nullable there by hard language necessity, not by choice (`CarHistoryDto` has no such constraint, so it mirrors `required` in full). `CarHistoryModel.DeltaMileage` is real user-entered data (typically read off the car's own trip computer at refuel time), not a derived/computed field, kept specifically so `Domain/Services/CarMetricsService.cs` can cross-check it against consecutive `Mileage` readings and flag a likely typo or a skipped entry — the automated version of a manual spreadsheet cross-check, and the reason this field was kept rather than dropped as "unused" during review. `CarMetricsService` (consumption — only ever computed across a full refill/recharge, never a partial one — cost-of-ownership history, mileage warnings, next-maintenance-due) follows `WatchNextService`'s shape: a plain, `AddSingleton`-registered, unit-tested pure computation class with no persistence of its own, exposed via `CarController.GetMetrics` the same way `VideoGameController.RefreshReference` adds an extra per-item action to an entity's own CRUD controller instead of a separate cross-entity controller. -`House`/`HouseHistory` (owned-by-a-parent, same shape as `Car`/`CarHistory` above) is a deliberately smaller sibling, not a second copy of Car's design: the priority (confirmed with the owner) is an exhaustive, browsable action log for insurance purposes plus a yearly cost review, not fuel/mileage tracking or reminders - the owner tracks recurring bills/maintenance schedules elsewhere and explicitly asked for reminders to stay out of scope ("keep it simple, not important, I manage it elsewhere"). Concretely: `HouseHistoryModel` has no `Mileage`/`DeltaMileage`/fuel fields, no location sub-fields (a house doesn't move, unlike a car's refuel stops), and `Domain/Services/HouseMetricsService.cs` has no `ComputeNextMaintenanceDue`-style due-date engine - it only computes `ComputeAnnualCostHistory` (cost per year, broken down by `HouseEventType`: `Maintenance`/`Installation`/`Rework`/`Purchase`/`Bill`/`Other`). `HouseHistoryModel.HistoryDate` stays `DateOnly` (not `DateTime` like `CarHistoryModel.HistoryDate`) - House has no Car-style same-day-multiple-entries ordering need (a road trip's several refuel stops), so it reuses the app's existing global `DateOnly<->DateTime` UTC-stamping AutoMapper converter for free instead of Car's bespoke `DateTime.SpecifyKind` `ForMember`/`ModalTimeText` "HH:mm" proxy machinery. `HouseHistoryModel.Provider` is a single field (contractor/technician/utility company/store name) covering every category, unlike Car's Refuel-only `StationBrandName` vs. Maintenance-only `Garage` split - House has no event type where "who was involved" doesn't apply, so one field suffices. +`House`/`HouseHistory` (owned-by-a-parent, same shape as `Car`/`CarHistory` above) is a deliberately smaller sibling, not a second copy of Car's design: the priority (confirmed with the owner) is an exhaustive, browsable action log for insurance purposes plus a yearly cost review, not fuel/mileage tracking or reminders - the owner tracks recurring bills/maintenance schedules elsewhere and explicitly asked for reminders to stay out of scope ("keep it simple, not important, I manage it elsewhere"). Concretely: `HouseHistoryModel` has no `Mileage`/`DeltaMileage`/fuel fields, no location sub-fields (a house doesn't move, unlike a car's refuel stops), and `Domain/Services/HouseMetricsService.cs` has no `ComputeNextMaintenanceDue`-style due-date engine - it only computes `ComputeAnnualCostHistory` (cost per year, broken down by `HouseEventType`: `Maintenance`/`Installation`/`Rework`/`Purchase`/`Bill`/`Other`). `HouseHistoryModel.HistoryDate` stays `DateOnly` (not `DateTime` like `CarHistoryModel.HistoryDate`) - House has no Car-style same-day-multiple-entries ordering need (a road trip's several refuel stops), so it reuses `CommonStorageMappings` (`Infrastructure.MongoDb/Mappers/`), the shared `DateOnly<->DateTime` UTC-stamping conversion every other date field in the app attaches via `[UseStaticMapper(typeof(CommonStorageMappings))]`, for free instead of Car's bespoke hand-written `DateTime.SpecifyKind`/`ModalTimeText` "HH:mm" proxy machinery. `HouseHistoryModel.Provider` is a single field (contractor/technician/utility company/store name) covering every category, unlike Car's Refuel-only `StationBrandName` vs. Maintenance-only `Garage` split - House has no event type where "who was involved" doesn't apply, so one field suffices. `HouseDetail.razor`'s yearly cost chart is a single-series bar chart (total cost per year) plus a plain HTML breakdown table underneath (rows = years, columns = the 6 categories + total), not a 6-color stacked bar chart - a stacked chart with that many categories would be visually noisy and add real code, and the table already carries the actual per-category precision an insurance review needs at a glance. The chart's axis-drawing code (`ChartGeometry`, `RenderAxes`, `EvenlySpacedIndices`) was extracted from `CarDetail.razor` into `src/BlazorApp/Components/Shared/SvgChartHelpers.cs` specifically so House's chart wouldn't duplicate it - the CLAUDE.md "no duplicated algorithms" quality bar applies to Razor-hosted chart code the same as any other logic. Only the axis/geometry math moved; each page's own series-drawing loop (Car's stacked 2-series cost bars, Car's single-series consumption line, House's single-series year bars) stays local, since that part differs enough per chart that forcing one shared renderer would have been the over-generalization the quality bar warns against. The shared CSS these charts need (`.kt-callout*`, `.kt-chart-axis-text`/`-title`, `.kt-chart-svg`, `.kt-sheet-table`, `.kt-chart-legend`/`.kt-legend-swatch`) moved from `CarDetail.razor.css` into `app.css` as plain global rules for the same reason - and as a side benefit, no longer need `::deep` to reach into child `*Row` components' markup, since global (non-isolated) CSS was never scoped to begin with. @@ -120,11 +122,11 @@ Reference data is meant to be portable across environments, not re-earned from T `TvTimeImportService`'s per-show/per-movie reference match (`TryEnrichShowAsync`/`TryEnrichMovieAsync`) fires on its own DI scope via `IServiceScopeFactory` (same shape as `TvShowController`/`MovieController.OnCreatedAsync`) rather than being awaited inline - a bulk import creating dozens of new shows/movies must not block on a sequential chain of TMDB HTTP calls (search + details + credits, per item) before the import job itself can report "Completed". If TV Time import feels slow again, check this path before assuming it's a missing Mongo index (already fully audited once - see `docs/code-quality-findings.md`). -**Gotcha:** "does this tenant document have no reference link yet" cannot be a plain `Eq(x => x.ReferenceId, null)` filter. `AddAutoMapper` is configured with `AllowNullDestinationValues = false` (`WebApi/Program.cs`), so mapping a model whose string property is null stores an **empty string**, never an actual BSON null. `TvShowRepository`/`MovieRepository`'s `UnresolvedFilter()` matches null *or* empty string for exactly this reason - copy that helper's shape (not a bare null check) for any new "is this string field unset" query. This one is easy to get wrong silently: it doesn't throw, it just quietly matches zero documents. A real-MongoDB integration test (`TvShowReferenceLinkingTest`) is what caught it, not the unit tests (which mock the repository and never see the actual serialization behavior). +**Gotcha (historical - fixed by the AutoMapper -> Mapperly migration, but old data still needs this):** "does this tenant document have no reference link yet" cannot be a plain `Eq(x => x.ReferenceId, null)` filter. Under AutoMapper, `AllowNullDestinationValues = false` made mapping a model whose string property is null store an **empty string**, never an actual BSON null; documents written that way still exist. `TvShowRepository`/`MovieRepository`'s `UnresolvedFilter()` matches null *or* empty string for exactly this reason - copy that helper's shape (not a bare null check) for any new "is this string field unset" query, even now that new writes store a real null (Mapperly preserves nulls by default). This one is easy to get wrong silently: it doesn't throw, it just quietly matches zero documents. A real-MongoDB integration test (`TvShowReferenceLinkingTest`) is what caught it originally, not the unit tests (which mock the repository and never see the actual serialization behavior). -**Second instance of the same gotcha:** the same `AllowNullDestinationValues = false` setting also changes `mapper.Map(source)` when `source` itself (not just one of its properties) is `null` - instead of returning `null`, AutoMapper returns a new, all-default instance of `TDestination`. Every `Find*Async` method on `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository` does `var entity = await Collection.Find(...).FirstOrDefaultAsync();` where `entity` can legitimately be null (nothing matched) - mapping it directly would silently turn "not found" into a fake found-but-empty model, which `ReferenceDataController`'s `model is null` 404 check (and anything else checking `is null` on a Find result) would never trigger. Each of those methods now checks `entity is null` before calling `mapper.Map`, returning `null` directly instead. **This turned out not to be limited to the owner-less reference repositories**: `MongoDbRepositoryBase.FindOneAsync` (the shared base every ordinary owner-scoped repository extends) had the exact same shape and hit the exact same bug - every entity's `GetById` 404 check was silently broken, returning 200 with a blank object for a nonexistent id, until this was found (2026-07-09, while building Car) and fixed with the same `entity is null` guard directly in the base method. Copy this guard for any new Find method that can legitimately return "nothing matched," anywhere in the codebase, not just the owner-less collections - a mocked-repository unit test cannot catch this, only a real MongoDB integration test can (a mock never exercises the real `AllowNullDestinationValues` behavior). +**Second instance of the same gotcha (also historical - see `docs/automapper-removal-plan.md`):** AutoMapper's `AllowNullDestinationValues = false` used to also change `mapper.Map(source)` when `source` itself (not just one of its properties) was `null` - instead of returning `null`, it returned a new, all-default instance of `TDestination`. Mapperly (the current mapper) takes the opposite, honest approach: it *throws* on a null source rather than fabricating a default instance, which is exactly why the `entity is null` guard below still matters, just for a different reason now. Every `Find*Async` method on `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository` does `var entity = await Collection.Find(...).FirstOrDefaultAsync();` where `entity` can legitimately be null (nothing matched) - mapping it directly would either fabricate a fake found-but-empty model (old AutoMapper behavior) or throw (current Mapperly behavior), neither of which is the `null` that `ReferenceDataController`'s `model is null` 404 check (and anything else checking `is null` on a Find result) needs. Each of those methods checks `entity is null` before calling the mapper, returning `null` directly instead. **This isn't limited to the owner-less reference repositories**: `MongoDbRepositoryBase.FindOneAsync` (the shared base every ordinary owner-scoped repository extends) has the exact same shape and needs the exact same guard - every entity's `GetById` 404 check depends on it. Copy this guard for any new Find method that can legitimately return "nothing matched," anywhere in the codebase, not just the owner-less collections - a mocked-repository unit test cannot catch a regression here, only a real MongoDB integration test can (a mock never exercises the real mapper/serialization behavior). -The reference layer also now has `Genres`, `Cast` (embedded `CastMemberModel` list, pointing at a third owner-less collection, `person_reference` - actors are deduplicated across every show/movie that credits them, keyed by TMDB person id via `IPersonReferenceRepository.FindByExternalIdAsync`, not by name), and `PosterUrl`/`CastMemberDto.ProfileImageUrl`. Images are **hotlinked directly from TMDB's CDN** (`https://image.tmdb.org/t/p/{size}{path}`, built once in `TmdbClient` and stored as a plain URL) rather than downloaded and re-hosted - confirmed this is TMDB's own sanctioned, standard usage pattern (a separate, unauthenticated static-asset host, not the rate-limited API), so there's no local storage/volume/static-file-serving subsystem to operate. `CastMemberDto` is fully hydrated server-side (`ReferenceDataController` joins the embedded cast list against `person_reference`) specifically because that join needs repository access AutoMapper profiles don't have - `WebServiceMappingProfile` ignores `Cast` for exactly this reason; don't try to make it a plain `CreateMap` member. +The reference layer also now has `Genres`, `Cast` (embedded `CastMemberModel` list, pointing at a third owner-less collection, `person_reference` - actors are deduplicated across every show/movie that credits them, keyed by TMDB person id via `IPersonReferenceRepository.FindByExternalIdAsync`, not by name), and `PosterUrl`/`CastMemberDto.ProfileImageUrl`. Images are **hotlinked directly from TMDB's CDN** (`https://image.tmdb.org/t/p/{size}{path}`, built once in `TmdbClient` and stored as a plain URL) rather than downloaded and re-hosted - confirmed this is TMDB's own sanctioned, standard usage pattern (a separate, unauthenticated static-asset host, not the rate-limited API), so there's no local storage/volume/static-file-serving subsystem to operate. `CastMemberDto` is fully hydrated server-side (`ReferenceDataController` joins the embedded cast list against `person_reference`) specifically because that join needs repository access a generated mapper doesn't have - `TvShowReferenceDtoMapper`/`MovieReferenceDtoMapper` (`WebApi/Mappers/`) ignore `Cast` via `[MapperIgnoreTarget]` for exactly this reason; don't try to make it a plain mapped member. `TvShowDetail.razor`'s episode list is a full watch-through checklist (every reference episode, checkbox = watched) once the show has a `ReferenceId`, falling back to the original recorded-episodes-only view with a manual add form when it doesn't (there's no way to know the full episode count without reference data, so that fallback is a deliberate scope boundary, not a bug). Checking a box creates an `Episode` with `WatchedAt = today`; unchecking deletes it - there's no way to set an arbitrary watched date from this view once a show is resolved. @@ -192,7 +194,7 @@ The TMDB-backed pattern above (shared `*_reference` collection, admin unresolved **Gotcha:** `OpenLibraryClient.SearchBooksAsync` deliberately never sends `year` as a server-side query filter (unlike TMDB/RAWG/Discogs, which do). Open Library's `first_publish_year` is a book's ORIGINAL publication year, not whatever edition/printing year a tenant happened to record - searching "Killing Floor" (Lee Child, first published 1997) with `first_publish_year=2016` (a tenant's 2016 reprint) returns zero relevant results, since Open Library filters the *work* by that exact year server-side and no edition of that work was first published in 2016. `year` is still returned per candidate for display/tie-breaking, just never used to narrow the query itself - confirmed against the real API (searching `title=Killing+Floor&first_publish_year=2016` returns an unrelated 2016 book; dropping the year filter and adding `author=Lee+Child` finds the real one). This is a book-specific problem (one canonical release date doesn't generalize to "the book was first published once, but every reader owns some edition"); RAWG/Discogs keep their year filters since no equivalent bug has been found for games/albums. -Book authors and album artists are deduplicated the same way TV/movie cast is: `PersonReferenceModel`/`person_reference` was kept as-is (no rename) and reused, rather than adding two more near-duplicate lookup tables - "Person" already meant "a named individual or group identified by an external provider id," not "actor" specifically, so extending it to a book's author (Open Library author id) or an album's artist (Discogs artist id, which can be a group/band) needed no rename, just reuse. `BookReferenceModel.AuthorReferenceId`/`AlbumReferenceModel.ArtistReferenceId` point at a `PersonReferenceModel` document instead of embedding a plain name string - `ReferenceEnrichmentService.ResolvePersonReferenceIdAsync` (shared helper in the core partial-class file) is the single dedup-by-external-id path used by cast resolution (`ResolveCastAsync`, refactored to call it per member) and by `ResolveBookAsync`/`ResolveAlbumAsync`. `BookReferenceDto.AuthorName`/`AlbumReferenceDto.ArtistName` are hydrated by `ReferenceDataController` joining `person_reference` by id (same `.ForMember(..., opt => opt.Ignore())` + manual join pattern as `Cast`) - the model only carries the id, never a denormalized name, so there's nothing to keep in sync. When linking (`TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync`), the tenant's own plain-string `BookModel.Author`/`AlbumModel.Artist` is still populated by resolving the reference's `*ReferenceId` to a name at link time (`ResolvePersonNameAsync`) - the tenant-facing field stays a free-text string editable like `Title`, only the shared reference document uses the dedup'd id. +Book authors and album artists are deduplicated the same way TV/movie cast is: `PersonReferenceModel`/`person_reference` was kept as-is (no rename) and reused, rather than adding two more near-duplicate lookup tables - "Person" already meant "a named individual or group identified by an external provider id," not "actor" specifically, so extending it to a book's author (Open Library author id) or an album's artist (Discogs artist id, which can be a group/band) needed no rename, just reuse. `BookReferenceModel.AuthorReferenceId`/`AlbumReferenceModel.ArtistReferenceId` point at a `PersonReferenceModel` document instead of embedding a plain name string - `ReferenceEnrichmentService.ResolvePersonReferenceIdAsync` (shared helper in the core partial-class file) is the single dedup-by-external-id path used by cast resolution (`ResolveCastAsync`, refactored to call it per member) and by `ResolveBookAsync`/`ResolveAlbumAsync`. `BookReferenceDto.AuthorName`/`AlbumReferenceDto.ArtistName` are hydrated by `ReferenceDataController` joining `person_reference` by id (same `[MapperIgnoreTarget]` + manual join pattern as `Cast`) - the model only carries the id, never a denormalized name, so there's nothing to keep in sync. When linking (`TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync`), the tenant's own plain-string `BookModel.Author`/`AlbumModel.Artist` is still populated by resolving the reference's `*ReferenceId` to a name at link time (`ResolvePersonNameAsync`) - the tenant-facing field stays a free-text string editable like `Title`, only the shared reference document uses the dedup'd id. `ReferenceEnrichmentService` is a single `partial class` split across `.TvShowsAndMovies.cs`/`.Books.cs`/`.VideoGames.cs`/`.Albums.cs` files (one class, same constructor, same five-method-per-domain template: `TryLinkExistingReferenceAsync`/`TryAutoResolveAsync`/`ResolveAsync`/`RefreshReferenceAsync`) - splitting by file rather than by class keeps the shared helpers (`MergeMatchedAliases`, `TitleNormalizer.Normalize`) in one place without one file growing to cover six domains' worth of logic. `ReferenceMatchModel`/`MatchedAliases` needed no changes at all to support the new domains - it was already generic, not TMDB-specific, per its original naming decision. @@ -220,9 +222,9 @@ Book authors and album artists are deduplicated the same way TV/movie cast is: ` `ReferenceMatchModel.Creator` (nullable `string`) extends the `MatchedAliases` match key beyond just (title, year) - a title+year match alone risks silently linking a tenant's book/album to a *different* tenant's unrelated one that happens to share a common title and year (a generic name re-published/re-released the same year is common; TV/movie titles almost never collide this hard, which is why they don't need this). `IBookReferenceRepository`/`IAlbumReferenceRepository`'s `FindByTitleYearAsync`/`FindByTitleAsync` now take a required `author`/`artist` parameter and add a `Creator` equality condition to the same `ElemMatch` filter (both title and creator normalized via `TitleNormalizer.Normalize`) - `Creator` is always derived from the **canonical** resolved `details.Author`/`details.Artist` (the external API's own response), never from whatever text the tenant/admin originally typed, since that let the design avoid adding a new parameter to `ResolveBookAsync`/`ResolveAlbumAsync`, `LinkReferenceRequestDto`, or the admin linking UI. TvShow/Movie/VideoGame's `MergeMatchedAliases` calls all pass `null` for `Creator` (no creator dimension in those domains' match key) - the shared helper's third tuple element is `null` for them, not omitted, since `ReferenceMatchModel` stays one generic shape across every domain rather than growing a Book/Album-only subtype. `BookReferenceRepository`/`AlbumReferenceRepository.UpsertAsync`'s defensive "always include the canonical title/year alias" safety net can't set `Creator` (the model only carries `AuthorReferenceId`/`ArtistReferenceId`, a dedup'd link, not denormalized text) - that alias is simply unreachable via the creator-required find methods, which is harmless (the normal Resolve/Refresh path always adds a proper creator-bearing alias first) rather than a false-positive risk; a real-MongoDB integration test (`BookReferenceRepositoryTest`/`AlbumReferenceRepositoryTest`) asserts on the stored alias directly for this specific case rather than through the creator-required lookup, since that lookup can no longer find it by design. -**Gotcha:** `MergeMatchedAliases`' dedup check compares a freshly-computed `Creator` against an existing alias's `Creator` (`m.Creator == normalizedCreator`), which silently duplicated aliases on every re-resolve/re-refresh for TV show/movie/video game (the three domains that always pass `null` for `Creator`, having no creator dimension). The reason: `AllowNullDestinationValues = false` (`Program.cs`) is a profile-wide AutoMapper default that substitutes `""` for a null *string* member during model → entity mapping - so a freshly-built alias with `Creator = null` got persisted as `Creator = ""`, and on the *next* resolve/refresh the freshly computed `normalizedCreator` (still literally `null`) never equalled that already-persisted `""`, so the dedup check saw no existing match and appended an exact duplicate `{title, year, creator: ""}` entry. Confirmed against a real video game reference (RAWG's "God of War", resolved/refreshed more than once) that had accumulated a literal duplicate alias this way. +**Gotcha (historical - structurally fixed by the AutoMapper -> Mapperly migration):** `MergeMatchedAliases`' dedup check compares a freshly-computed `Creator` against an existing alias's `Creator` (`m.Creator == normalizedCreator`), which used to silently duplicate aliases on every re-resolve/re-refresh for TV show/movie/video game (the three domains that always pass `null` for `Creator`, having no creator dimension). The reason: `AllowNullDestinationValues = false` (a profile-wide AutoMapper default, since removed along with AutoMapper itself) substituted `""` for a null *string* member during model → entity mapping - so a freshly-built alias with `Creator = null` got persisted as `Creator = ""`, and on the *next* resolve/refresh the freshly computed `normalizedCreator` (still literally `null`) never equalled that already-persisted `""`, so the dedup check saw no existing match and appended an exact duplicate `{title, year, creator: ""}` entry. Confirmed against a real video game reference (RAWG's "God of War", resolved/refreshed more than once) that had accumulated a literal duplicate alias this way. -The fix belongs at the mapping/entity layer, not as a comparison workaround in `MergeMatchedAliases` (an `(m.Creator ?? "") == (normalizedCreator ?? "")` patch was tried first and reverted) - `DataStorageMappingProfile`'s `ReferenceMatchModel` → `ReferenceMatch` map now opts `Creator` out of the profile-wide default with `.ForMember(x => x.Creator, opt => opt.AllowNull())`, so a null `Creator` reaches Mongo as an actual null again, and `MergeMatchedAliases` stays a plain, honest `m.Creator == normalizedCreator`. From there, the *already-registered*, codebase-wide `IgnoreIfNullConvention(true)` (`InfrastructureServiceCollectionExtensions.AddMongoDbInfrastructure`) does the rest for free - it omits any null property from the stored document, which is why `Year` (also nullable on `ReferenceMatch`) was never affected by this bug in the first place and needed no equivalent per-property `[BsonIgnoreIfNull]` fix; that attribute doesn't appear anywhere in this codebase, and shouldn't - "is this field omitted when unset" is a driver-convention-level answer here, not a per-entity one. Covered by `RefreshVideoGameReferenceAsync_DoesNotDuplicateAnAliasAlreadyPersistedWithANullCreator` (unit, mocked) and `TvShowReferenceRepositoryTest.UpsertAsync_PersistsANullCreator_AsAnActualBsonNullNotAnEmptyString` (integration, real MongoDB - the only way to actually catch a serialization-level regression like this one). A scan of the real dev database found only the one "God of War" document actually duplicated, cleaned up with the idempotent `scripts/dedupe-matched-aliases.js` (same "run once per environment" pattern as `migrate-poster-url-to-image-url.js`). +The fix belonged at the mapping/entity layer, not as a comparison workaround in `MergeMatchedAliases` (an `(m.Creator ?? "") == (normalizedCreator ?? "")` patch was tried first and reverted) - at the time, `DataStorageMappingProfile`'s `ReferenceMatchModel` → `ReferenceMatch` map opted `Creator` out of the profile-wide default with `.ForMember(x => x.Creator, opt => opt.AllowNull())`, so a null `Creator` reached Mongo as an actual null again, and `MergeMatchedAliases` stayed a plain, honest `m.Creator == normalizedCreator`. That per-member opt-out is gone now, not just moved: Mapperly (the current mapper) preserves nulls by default, so every storage mapper's `Creator` mapping is a real null with no configuration needed at all - this entire class of bug is structurally impossible today, not merely patched. From there, the *already-registered*, codebase-wide `IgnoreIfNullConvention(true)` (`InfrastructureServiceCollectionExtensions.AddMongoDbInfrastructure`) does the rest for free - it omits any null property from the stored document, which is why `Year` (also nullable on `ReferenceMatch`) was never affected by this bug in the first place and needed no equivalent per-property `[BsonIgnoreIfNull]` fix; that attribute doesn't appear anywhere in this codebase, and shouldn't - "is this field omitted when unset" is a driver-convention-level answer here, not a per-entity one. Was covered by `RefreshVideoGameReferenceAsync_DoesNotDuplicateAnAliasAlreadyPersistedWithANullCreator` (unit, mocked) and `TvShowReferenceRepositoryTest.UpsertAsync_PersistsANullCreator_AsAnActualBsonNullNotAnEmptyString` (integration, real MongoDB - the only way to actually catch a serialization-level regression like this one); both still pass under Mapperly as a regression guard, even though the bug they were written for can no longer occur. A scan of the real dev database found only the one "God of War" document actually duplicated, cleaned up with the idempotent `scripts/dedupe-matched-aliases.js` (same "run once per environment" pattern as `migrate-poster-url-to-image-url.js`). `BookModel`/`AlbumModel.Genre` (a single free-text field, not a list - it predates the reference-data feature, same as `Author`/`Artist` before `PersonReferenceModel` existed) is now propagated on link the same way `Title`/`Year`/`Author`/`Artist` already are: `TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync` and `ResolveBookAsync`/`ResolveAlbumAsync` join the reference's `Genres` list (`JoinGenres`, a shared helper in `ReferenceEnrichmentService.cs`) into that single field, both on the tenant's own document and via `IBookRepository`/`IAlbumRepository.SetReferenceLinkAsync`'s new `canonicalGenre` parameter (cross-tenant propagation, same incremental-parameter pattern already used for `canonicalAuthor`/`canonicalArtist`) - null (not overwritten) when the reference has no genres, same "don't overwrite with nothing" rule the other propagated fields already follow. `BookDetail.razor`/`AlbumDetail.razor` previously displayed the *reference's* raw `Genres` list directly (a read-only comma-joined paragraph) but never touched the tenant's own `Genre` field at all - that display was replaced with a plain editable `Genre` input (same shape as `Author`/`Series`/`Artist`), matching how `Author`/`Artist` already work: the reference data flows into the one tenant-owned field on link, there's no separate "raw reference value" display once linked. @@ -256,7 +258,7 @@ Before assuming a rule in `app.css` will style something, check whether that ele ## Tests -- `test/WebApi.UnitTests`: xunit v3 unit tests, e.g. AutoMapper configuration validation, the TV Time import parsers (`Import/Parsers/`, pure stream-in/records-out, no I/O beyond an in-memory stream), and `WatchNextService` (pure next-episode computation). +- `test/WebApi.UnitTests`: xunit v3 unit tests, e.g. the TV Time import parsers (`Import/Parsers/`, pure stream-in/records-out, no I/O beyond an in-memory stream), and `WatchNextService` (pure next-episode computation). Mapper configuration validation is a compile-time concern now (Mapperly's `RMG012`/`RMG020` diagnostics, escalated to build errors in `.editorconfig`), not a unit test - there's no equivalent of the old `AutoMapperConfigurationTest` to run here anymore. - `test/WebApi.IntegrationTests`: xunit v3 tests booted against a real Kestrel host (`KestrelWebAppFactory`) and a real MongoDB instance. `ResourceTestBase` provides typed `GetAsync`/`PostAsync`/`PutAsync`/`DeleteAsync`/`PostFileAsync` helpers and an `Authenticate()` helper that logs in against Firebase to obtain a bearer token. Resource tests (`BookResourceTest`, `MovieResourceTest`, `TvTimeImportResourceTest`) exercise a full create/read/update/delete (or upsert) cycle against the live API and clean up what they create. `TvTimeFixtureZipBuilder` builds a small synthetic TV Time export in memory for the import test — never commit a real personal export as a test fixture. - Assertions use `AwesomeAssertions` (a `FluentAssertions`-compatible API); test data is generated with `Bogus`. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 7c0cb3e..ab271d8 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -237,7 +237,7 @@ dotnet test test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj Run a single test by fully qualified name (works for either project): ```bash -dotnet test --filter-method "Keeptrack.WebApi.UnitTests.MappingProfiles.AutoMapperConfigurationTest.WebApiAutoMapperProfile_ShouldBeValid" +dotnet test --filter-method "Keeptrack.WebApi.UnitTests.Services.WatchNextServiceTest.ComputeInProgressShows_IncludesShowWithAConfirmedAiredUnwatchedNextEpisode" ``` `--filter-method` also accepts a wildcard, e.g. `--filter-method "*CarResourceTest*"` to run every test in a class - but it's a single glob pattern, not a real filter expression: it does not support `|`/`,` alternation to combine multiple patterns in one run (that just prints the CLI help instead of running anything), so run each pattern as its own `dotnet test` invocation. diff --git a/Directory.Build.props b/Directory.Build.props index af92fd9..622812a 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -2,12 +2,12 @@ $(MsBuildAllProjects);$(MsBuildThisFileFullPath) - + - 1.1.0 + 2.0.0 - + diff --git a/Directory.Packages.props b/Directory.Packages.props index d85cff8..b132c28 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -4,7 +4,6 @@ true - @@ -26,6 +25,7 @@ + diff --git a/docs/code-quality-findings.md b/docs/code-quality-findings.md index 31306da..d72689e 100644 --- a/docs/code-quality-findings.md +++ b/docs/code-quality-findings.md @@ -6,6 +6,10 @@ Update this file as items are fixed or as new reviews are performed. ## Fixed +Several findings below trace back to AutoMapper's profile-wide `AllowNullDestinationValues = false` (a null source string/collection/object silently substituted with `""`/an empty collection/a blank instance). +AutoMapper itself was removed in favor of Riok.Mapperly (see `docs/automapper-removal-plan.md`), which preserves nulls by default - the entire class of gotcha these findings patched around is now structurally impossible, not just individually fixed. +The `entity is null` guards these findings added stay in place regardless: Mapperly throws on a null source, so checking before mapping is still the only correct way to turn "no document matched" into a `null` return value. + ### `mapper.Map(null)` returned a fake empty object instead of null - also affected the shared base repository, not just the reference-data ones Found again on 2026-07-09 while building the Car/CarHistory feature and its `CarResourceTest` integration coverage: `MongoDbRepositoryBase.FindOneAsync` (the base class every entity's repository extends) had the exact same shape as the bug described just below - `Mapper.Map(await entities.FirstOrDefaultAsync())` - and hit the exact same `AllowNullDestinationValues = false` gotcha, silently returning a blank default model instead of `null` for a nonexistent id. @@ -20,8 +24,9 @@ File: `src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs` Found on 2026-07-09 while adding `CarHistoryResourceTest`: `CarHistoryModel -> CarHistory`'s `Coordinates` (`List`) `ForMember` mapped to `null` when `Longitude`/`Latitude` were unset, but `AllowNullDestinationValues = false` substituted a new **empty list** instead - the same class of bug as the `Creator`/empty-string gotchas already documented here and in CLAUDE.md, just for a `List` member instead of `string`. The reverse mapping (`CarHistory -> CarHistoryModel`) read it back with `x.Coordinates != null ? x.Coordinates[0] : null`, which an empty-but-non-null list defeats - `x.Coordinates[0]` threw `IndexOutOfRangeException` on every `POST`/`PUT` of a `CarHistory` entry with no location set. Fixed with `.AllowNull()` on that `ForMember`, same fix shape as the `Creator` case in CLAUDE.md. +The `AllowNull()` opt-out itself no longer exists - the AutoMapper -> Mapperly migration deleted `CarDataStorageMappingProfile` entirely; the same null-vs-empty-list handling now lives, hand-written, in `CarHistoryStorageMapper.BuildLocation`. -File: `src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs` +File (at the time of the fix): `src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs`, now `src/Infrastructure.MongoDb/Mappers/CarHistoryStorageMapper.cs` ### `mapper.Map(null)` returned a fake empty object instead of null diff --git a/src/Infrastructure.MongoDb/Entities/ReferenceMatch.cs b/src/Infrastructure.MongoDb/Entities/ReferenceMatch.cs index 412e475..76aa920 100644 --- a/src/Infrastructure.MongoDb/Entities/ReferenceMatch.cs +++ b/src/Infrastructure.MongoDb/Entities/ReferenceMatch.cs @@ -14,12 +14,13 @@ public class ReferenceMatch /// Null for TV show/movie/video game (no creator dimension in their match key). The global /// IgnoreIfNullConvention (InfrastructureServiceCollectionExtensions.AddMongoDbInfrastructure) /// already omits any null property from the document - no per-property [BsonIgnoreIfNull] needed - /// here or anywhere else in the codebase. What previously defeated that convention for this property - /// specifically was AutoMapper's profile-wide AllowNullDestinationValues = false (Program.cs) - /// substituting an empty string for the null *before* BSON serialization ever saw it - fixed at the - /// mapping layer instead (DataStorageMappingProfile's per-member .ForMember(x => x.Creator, - /// opt => opt.AllowNull())), so the value reaching the (already-correct) Mongo convention is a real - /// null again. + /// here or anywhere else in the codebase. This used to require a per-member AutoMapper opt-out + /// (.ForMember(x => x.Creator, opt => opt.AllowNull())) because AutoMapper's profile-wide + /// AllowNullDestinationValues = false substituted an empty string for the null before BSON + /// serialization ever saw it; Mapperly (the current mapper, see ReferenceMatchModel -> + /// ReferenceMatch mapping in TvShowReferenceStorageMapper etc.) preserves nulls by + /// default, so no such opt-out exists or is needed anymore. Historical documents written under the + /// old behavior still store "" instead of an absent field - see MergeMatchedAliases. /// public string? Creator { get; set; } } diff --git a/src/Infrastructure.MongoDb/Infrastructure.MongoDb.csproj b/src/Infrastructure.MongoDb/Infrastructure.MongoDb.csproj index 494be14..7d72880 100644 --- a/src/Infrastructure.MongoDb/Infrastructure.MongoDb.csproj +++ b/src/Infrastructure.MongoDb/Infrastructure.MongoDb.csproj @@ -8,9 +8,9 @@ - + diff --git a/src/Infrastructure.MongoDb/Mappers/AlbumReferenceStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/AlbumReferenceStorageMapper.cs new file mode 100644 index 0000000..8625326 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/AlbumReferenceStorageMapper.cs @@ -0,0 +1,17 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Injected directly by - see +/// for why this has no shared interface. +/// +[Mapper] +public partial class AlbumReferenceStorageMapper +{ + public partial AlbumReference ToEntity(AlbumReferenceModel model); + + public partial AlbumReferenceModel ToModel(AlbumReference entity); +} diff --git a/src/Infrastructure.MongoDb/Mappers/AlbumStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/AlbumStorageMapper.cs new file mode 100644 index 0000000..6d0deb1 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/AlbumStorageMapper.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +public partial class AlbumStorageMapper : IStorageMapper +{ + public partial Album ToEntity(AlbumModel model); + + public partial AlbumModel ToModel(Album entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/BookReferenceStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/BookReferenceStorageMapper.cs new file mode 100644 index 0000000..269756d --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/BookReferenceStorageMapper.cs @@ -0,0 +1,17 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Injected directly by - see +/// for why this has no shared interface. +/// +[Mapper] +public partial class BookReferenceStorageMapper +{ + public partial BookReference ToEntity(BookReferenceModel model); + + public partial BookReferenceModel ToModel(BookReference entity); +} diff --git a/src/Infrastructure.MongoDb/Mappers/BookStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/BookStorageMapper.cs new file mode 100644 index 0000000..79ad855 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/BookStorageMapper.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonStorageMappings))] +public partial class BookStorageMapper : IStorageMapper +{ + public partial Book ToEntity(BookModel model); + + public partial BookModel ToModel(Book entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/CarHistoryStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/CarHistoryStorageMapper.cs new file mode 100644 index 0000000..8ea259f --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/CarHistoryStorageMapper.cs @@ -0,0 +1,115 @@ +using System; +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Hand-written rather than a Mapperly [Mapper] class: 's flat +/// City/PostalCode/Country/Longitude/Latitude/Fuel*/StationBrandName fields fan out into +/// 's Location/Fuel/Station sub-documents on write and back on read, which is +/// bespoke enough that explicit C# is more readable than attribute configuration. +/// +public class CarHistoryStorageMapper : IStorageMapper +{ + public CarHistory ToEntity(CarHistoryModel model) + { + return new CarHistory + { + Id = model.Id, + OwnerId = model.OwnerId, + CarId = model.CarId, + // HistoryDate is a plain DateTime on both sides (the only date field in the codebase that + // isn't DateOnly on the model), so nothing upstream stamps DateTimeKind.Utc - the Mongo + // driver's default DateTimeSerializer requires it. + HistoryDate = DateTime.SpecifyKind(model.HistoryDate, DateTimeKind.Utc), + Mileage = model.Mileage, + EventType = model.EventType, + Description = model.Description, + Cost = model.Cost, + Location = BuildLocation(model), + Fuel = BuildFuel(model), + Station = BuildStation(model), + Garage = model.Garage, + }; + } + + public CarHistoryModel ToModel(CarHistory entity) + { + return new CarHistoryModel + { + Id = entity.Id, + OwnerId = entity.OwnerId, + CarId = entity.CarId, + HistoryDate = entity.HistoryDate, + Mileage = (int?)entity.Mileage, + EventType = entity.EventType, + Description = entity.Description, + Cost = entity.Cost, + City = entity.Location?.City, + PostalCode = entity.Location?.PostalCode, + Country = entity.Location?.Country, + Longitude = entity.Location?.Coordinates != null ? entity.Location.Coordinates[0] : null, + Latitude = entity.Location?.Coordinates != null ? entity.Location.Coordinates[1] : null, + FuelCategory = entity.Fuel?.Category, + FuelVolume = entity.Fuel?.Volume, + FuelUnitPrice = entity.Fuel?.UnitPrice, + ElectricVolume = entity.Fuel?.ElectricVolume, + ElectricUnitPrice = entity.Fuel?.ElectricUnitPrice, + IsFullRefill = entity.Fuel?.IsFullRefill, + DeltaMileage = entity.Fuel?.DeltaMileage, + StationBrandName = entity.Station?.BrandName, + Garage = entity.Garage, + }; + } + + public List ToModels(List entities) + { + var models = new List(entities.Count); + foreach (var entity in entities) models.Add(ToModel(entity)); + return models; + } + + private static CarHistoryLocation BuildLocation(CarHistoryModel model) + { + return new CarHistoryLocation + { + // CarHistoryLocation.City is `required` at the entity/schema level, but a non-Refuel event + // can legitimately carry no location at all - the null-forgiving operator here preserves that + // existing schema/model mismatch rather than introducing a new one. + City = model.City!, + PostalCode = model.PostalCode, + Country = model.Country, + // Coordinates: never persist an empty list, only a real 2-element [lon, lat] pair or nothing - + // the read side (ToModel) indexes Coordinates[0]/[1] guarded by "!= null", which an empty + // (not null) list would defeat. Covered by CarHistoryResourceTest's create/read round-trip. + Coordinates = model.Longitude.HasValue && model.Latitude.HasValue + ? [model.Longitude.Value, model.Latitude.Value] + : null, + }; + } + + private static CarHistoryFuel BuildFuel(CarHistoryModel model) + { + return new CarHistoryFuel + { + Category = model.FuelCategory, + Volume = model.FuelVolume, + UnitPrice = model.FuelUnitPrice, + ElectricVolume = model.ElectricVolume, + ElectricUnitPrice = model.ElectricUnitPrice, + IsFullRefill = model.IsFullRefill, + DeltaMileage = model.DeltaMileage, + }; + } + + private static CarHistoryStation BuildStation(CarHistoryModel model) + { + return new CarHistoryStation + { + // BrandName is `required` on the entity for the same reason City is above - preserved as-is. + BrandName = model.StationBrandName!, + }; + } +} diff --git a/src/Infrastructure.MongoDb/Mappers/CarStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/CarStorageMapper.cs new file mode 100644 index 0000000..dc334ed --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/CarStorageMapper.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +public partial class CarStorageMapper : IStorageMapper +{ + public partial Car ToEntity(CarModel model); + + public partial CarModel ToModel(Car entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/CommonStorageMappings.cs b/src/Infrastructure.MongoDb/Mappers/CommonStorageMappings.cs new file mode 100644 index 0000000..648c4c2 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/CommonStorageMappings.cs @@ -0,0 +1,26 @@ +using System; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Shared DateOnly <-> DateTime conversion, attached to any storage mapper that needs +/// it via [UseStaticMapper(typeof(CommonStorageMappings))]. Every Domain model date field is +/// while its Mongo entity counterpart is - the driver's +/// DateTimeSerializer requires , so stamps +/// it explicitly rather than leaving it . +/// +public static class CommonStorageMappings +{ + [UserMapping] + public static DateOnly ToDateOnly(DateTime dateTime) + { + return DateOnly.FromDateTime(dateTime); + } + + [UserMapping] + public static DateTime ToDateTime(DateOnly dateOnly) + { + return dateOnly.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc); + } +} diff --git a/src/Infrastructure.MongoDb/Mappers/EpisodeStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/EpisodeStorageMapper.cs new file mode 100644 index 0000000..b278261 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/EpisodeStorageMapper.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonStorageMappings))] +public partial class EpisodeStorageMapper : IStorageMapper +{ + public partial Episode ToEntity(EpisodeModel model); + + public partial EpisodeModel ToModel(Episode entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/HouseHistoryStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/HouseHistoryStorageMapper.cs new file mode 100644 index 0000000..dbce03d --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/HouseHistoryStorageMapper.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonStorageMappings))] +public partial class HouseHistoryStorageMapper : IStorageMapper +{ + public partial HouseHistory ToEntity(HouseHistoryModel model); + + public partial HouseHistoryModel ToModel(HouseHistory entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/HouseStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/HouseStorageMapper.cs new file mode 100644 index 0000000..9ed7544 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/HouseStorageMapper.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +public partial class HouseStorageMapper : IStorageMapper +{ + public partial House ToEntity(HouseModel model); + + public partial HouseModel ToModel(House entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/IStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/IStorageMapper.cs new file mode 100644 index 0000000..0e4b376 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/IStorageMapper.cs @@ -0,0 +1,18 @@ +using System.Collections.Generic; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Maps between a Domain model and its MongoDB entity counterpart. Implemented per entity pair by a +/// Mapperly [Mapper] partial class (e.g. BookStorageMapper) and injected into +/// instead of AutoMapper's untyped +/// IMapper. +/// +public interface IStorageMapper +{ + TEntity ToEntity(TModel model); + + TModel ToModel(TEntity entity); + + List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/MovieReferenceStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/MovieReferenceStorageMapper.cs new file mode 100644 index 0000000..2e3a0ab --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/MovieReferenceStorageMapper.cs @@ -0,0 +1,17 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Injected directly by - see +/// for why this has no shared interface. +/// +[Mapper] +public partial class MovieReferenceStorageMapper +{ + public partial MovieReference ToEntity(MovieReferenceModel model); + + public partial MovieReferenceModel ToModel(MovieReference entity); +} diff --git a/src/Infrastructure.MongoDb/Mappers/MovieStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/MovieStorageMapper.cs new file mode 100644 index 0000000..fda8ba6 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/MovieStorageMapper.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonStorageMappings))] +public partial class MovieStorageMapper : IStorageMapper +{ + public partial Movie ToEntity(MovieModel model); + + public partial MovieModel ToModel(Movie entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/PersonReferenceStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/PersonReferenceStorageMapper.cs new file mode 100644 index 0000000..bc187d9 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/PersonReferenceStorageMapper.cs @@ -0,0 +1,17 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Injected directly by - see +/// for why this has no shared interface. +/// +[Mapper] +public partial class PersonReferenceStorageMapper +{ + public partial PersonReference ToEntity(PersonReferenceModel model); + + public partial PersonReferenceModel ToModel(PersonReference entity); +} diff --git a/src/Infrastructure.MongoDb/Mappers/PlaylistStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/PlaylistStorageMapper.cs new file mode 100644 index 0000000..fdf3bae --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/PlaylistStorageMapper.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +public partial class PlaylistStorageMapper : IStorageMapper +{ + public partial Playlist ToEntity(PlaylistModel model); + + public partial PlaylistModel ToModel(Playlist entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/SongStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/SongStorageMapper.cs new file mode 100644 index 0000000..13fc6a9 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/SongStorageMapper.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +public partial class SongStorageMapper : IStorageMapper +{ + public partial Song ToEntity(SongModel model); + + public partial SongModel ToModel(Song entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/TvShowReferenceStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/TvShowReferenceStorageMapper.cs new file mode 100644 index 0000000..892f7e0 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/TvShowReferenceStorageMapper.cs @@ -0,0 +1,19 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Injected directly by - the owner-less reference +/// repositories are purpose-built already and need no shared +/// abstraction, per docs/automapper-removal-plan.md. +/// +[Mapper] +[UseStaticMapper(typeof(CommonStorageMappings))] +public partial class TvShowReferenceStorageMapper +{ + public partial TvShowReference ToEntity(TvShowReferenceModel model); + + public partial TvShowReferenceModel ToModel(TvShowReference entity); +} diff --git a/src/Infrastructure.MongoDb/Mappers/TvShowStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/TvShowStorageMapper.cs new file mode 100644 index 0000000..aa70c7d --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/TvShowStorageMapper.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +public partial class TvShowStorageMapper : IStorageMapper +{ + public partial TvShow ToEntity(TvShowModel model); + + public partial TvShowModel ToModel(TvShow entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Mappers/VideoGameReferenceStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/VideoGameReferenceStorageMapper.cs new file mode 100644 index 0000000..eea9732 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/VideoGameReferenceStorageMapper.cs @@ -0,0 +1,17 @@ +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +/// +/// Injected directly by - see +/// for why this has no shared interface. +/// +[Mapper] +public partial class VideoGameReferenceStorageMapper +{ + public partial VideoGameReference ToEntity(VideoGameReferenceModel model); + + public partial VideoGameReferenceModel ToModel(VideoGameReference entity); +} diff --git a/src/Infrastructure.MongoDb/Mappers/VideoGameStorageMapper.cs b/src/Infrastructure.MongoDb/Mappers/VideoGameStorageMapper.cs new file mode 100644 index 0000000..24364c0 --- /dev/null +++ b/src/Infrastructure.MongoDb/Mappers/VideoGameStorageMapper.cs @@ -0,0 +1,24 @@ +using System.Collections.Generic; +using Keeptrack.Domain.Models; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.Infrastructure.MongoDb.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonStorageMappings))] +public partial class VideoGameStorageMapper : IStorageMapper +{ + // Platform/State are filter-only members on VideoGameModel with no matching entity field - see + // VideoGameModel.Platform/State's own doc comments. Ignored on both directions: as an unmapped + // target on the read side, as an unmapped source (nothing to write) on the write side. + [MapperIgnoreSource(nameof(VideoGameModel.Platform))] + [MapperIgnoreSource(nameof(VideoGameModel.State))] + public partial VideoGame ToEntity(VideoGameModel model); + + [MapperIgnoreTarget(nameof(VideoGameModel.Platform))] + [MapperIgnoreTarget(nameof(VideoGameModel.State))] + public partial VideoGameModel ToModel(VideoGame entity); + + public partial List ToModels(List entities); +} diff --git a/src/Infrastructure.MongoDb/Repositories/AlbumReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/AlbumReferenceRepository.cs index 036db9b..e7d0f2b 100644 --- a/src/Infrastructure.MongoDb/Repositories/AlbumReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/AlbumReferenceRepository.cs @@ -1,16 +1,16 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Common.System; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class AlbumReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapper) : IAlbumReferenceRepository +public class AlbumReferenceRepository(IMongoDatabase mongoDatabase, AlbumReferenceStorageMapper mapper) : IAlbumReferenceRepository { private const string CollectionName = "album_reference"; @@ -19,7 +19,7 @@ public class AlbumReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp public async Task FindByIdAsync(string id) { var entity = await Collection.Find(x => x.Id == id).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleYearAsync(string title, int? year, string artist) @@ -31,7 +31,7 @@ public class AlbumReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp & Builders.Filter.Eq(m => m.Year, year) & Builders.Filter.Eq(m => m.Creator, normalizedArtist)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleAsync(string title, string artist) @@ -42,20 +42,20 @@ public class AlbumReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp Builders.Filter.Eq(m => m.Title, normalized) & Builders.Filter.Eq(m => m.Creator, normalizedArtist)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByExternalIdAsync(string provider, string externalId) { var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task> FindAllAsync() { var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); - return entities.Select(mapper.Map).ToList(); + return entities.Select(mapper.ToModel).ToList(); } public async Task UpsertAsync(AlbumReferenceModel model) @@ -68,7 +68,7 @@ public async Task UpsertAsync(AlbumReferenceModel model) { model.MatchedAliases.Add(new ReferenceMatchModel { Title = model.TitleNormalized, Year = model.Year }); } - var entity = mapper.Map(model); + var entity = mapper.ToEntity(model); if (string.IsNullOrEmpty(entity.Id)) { @@ -79,6 +79,6 @@ public async Task UpsertAsync(AlbumReferenceModel model) await Collection.ReplaceOneAsync(x => x.Id == entity.Id, entity, new ReplaceOptions { IsUpsert = true }); } - return mapper.Map(entity); + return mapper.ToModel(entity); } } diff --git a/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs b/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs index fac8b71..79f4f18 100644 --- a/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs @@ -2,17 +2,17 @@ using System.Linq; using System.Text.RegularExpressions; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Bson; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class AlbumRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class AlbumRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IAlbumRepository { protected override string CollectionName => "album"; @@ -53,8 +53,9 @@ public async Task SetReferenceLinkAsync(string title, int? year, string re /// /// "Has no reference link yet" means is null OR empty string, not - /// just null: AutoMapper is configured with AllowNullDestinationValues = false (see Program.cs), - /// so mapping a model with a null string property stores an empty string, never an actual null. + /// just null: old documents (written before the AutoMapper -> Mapperly migration) can still store "" + /// for an unset field; new writes store a real null instead (Mapperly preserves nulls, and the Mongo + /// driver's IgnoreIfNullConvention then omits it entirely). Both generations must match. /// private static FilterDefinition UnresolvedFilter() { diff --git a/src/Infrastructure.MongoDb/Repositories/BookReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/BookReferenceRepository.cs index 2cfa48f..3fa1283 100644 --- a/src/Infrastructure.MongoDb/Repositories/BookReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/BookReferenceRepository.cs @@ -1,16 +1,16 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Common.System; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class BookReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapper) : IBookReferenceRepository +public class BookReferenceRepository(IMongoDatabase mongoDatabase, BookReferenceStorageMapper mapper) : IBookReferenceRepository { private const string CollectionName = "book_reference"; @@ -19,7 +19,7 @@ public class BookReferenceRepository(IMongoDatabase mongoDatabase, IMapper mappe public async Task FindByIdAsync(string id) { var entity = await Collection.Find(x => x.Id == id).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleYearAsync(string title, int? year, string author) @@ -31,7 +31,7 @@ public class BookReferenceRepository(IMongoDatabase mongoDatabase, IMapper mappe & Builders.Filter.Eq(m => m.Year, year) & Builders.Filter.Eq(m => m.Creator, normalizedAuthor)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleAsync(string title, string author) @@ -42,20 +42,20 @@ public class BookReferenceRepository(IMongoDatabase mongoDatabase, IMapper mappe Builders.Filter.Eq(m => m.Title, normalized) & Builders.Filter.Eq(m => m.Creator, normalizedAuthor)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByExternalIdAsync(string provider, string externalId) { var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task> FindAllAsync() { var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); - return entities.Select(mapper.Map).ToList(); + return entities.Select(mapper.ToModel).ToList(); } public async Task UpsertAsync(BookReferenceModel model) @@ -70,7 +70,7 @@ public async Task UpsertAsync(BookReferenceModel model) { model.MatchedAliases.Add(new ReferenceMatchModel { Title = model.TitleNormalized, Year = model.Year }); } - var entity = mapper.Map(model); + var entity = mapper.ToEntity(model); if (string.IsNullOrEmpty(entity.Id)) { @@ -81,6 +81,6 @@ public async Task UpsertAsync(BookReferenceModel model) await Collection.ReplaceOneAsync(x => x.Id == entity.Id, entity, new ReplaceOptions { IsUpsert = true }); } - return mapper.Map(entity); + return mapper.ToModel(entity); } } diff --git a/src/Infrastructure.MongoDb/Repositories/BookRepository.cs b/src/Infrastructure.MongoDb/Repositories/BookRepository.cs index ff15554..bbe335f 100644 --- a/src/Infrastructure.MongoDb/Repositories/BookRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/BookRepository.cs @@ -2,17 +2,17 @@ using System.Linq; using System.Text.RegularExpressions; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Bson; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class BookRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class BookRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IBookRepository { protected override string CollectionName => "book"; @@ -56,8 +56,9 @@ public async Task SetReferenceLinkAsync(string title, int? year, string re /// /// "Has no reference link yet" means is null OR empty string, not - /// just null: AutoMapper is configured with AllowNullDestinationValues = false (see Program.cs), - /// so mapping a model with a null string property stores an empty string, never an actual null. + /// just null: old documents (written before the AutoMapper -> Mapperly migration) can still store "" + /// for an unset field; new writes store a real null instead (Mapperly preserves nulls, and the Mongo + /// driver's IgnoreIfNullConvention then omits it entirely). Both generations must match. /// private static FilterDefinition UnresolvedFilter() { diff --git a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs index d8d634e..038bbb1 100644 --- a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs @@ -1,14 +1,14 @@ using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class CarHistoryRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class CarHistoryRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ICarHistoryRepository { protected override string CollectionName => "car_history"; diff --git a/src/Infrastructure.MongoDb/Repositories/CarRepository.cs b/src/Infrastructure.MongoDb/Repositories/CarRepository.cs index 93d284d..4250fb3 100644 --- a/src/Infrastructure.MongoDb/Repositories/CarRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/CarRepository.cs @@ -1,13 +1,13 @@ -using AutoMapper; -using Keeptrack.Domain.Models; +using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class CarRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class CarRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ICarRepository { protected override string CollectionName => "car"; diff --git a/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs b/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs index 1eb9310..9243ac7 100644 --- a/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs @@ -1,13 +1,13 @@ -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class EpisodeRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class EpisodeRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IEpisodeRepository { protected override string CollectionName => "episode"; diff --git a/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs b/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs index afd09bd..b7afd76 100644 --- a/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs @@ -1,14 +1,14 @@ using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class HouseHistoryRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class HouseHistoryRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IHouseHistoryRepository { protected override string CollectionName => "house_history"; diff --git a/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs b/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs index cf44183..75896c9 100644 --- a/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs @@ -1,13 +1,13 @@ -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class HouseRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class HouseRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IHouseRepository { protected override string CollectionName => "house"; diff --git a/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs b/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs index 3b11104..a1df3c2 100644 --- a/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs +++ b/src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs @@ -1,8 +1,8 @@ using System.Collections.Generic; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Common.System; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; @@ -16,28 +16,25 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; public abstract class MongoDbRepositoryBase( IMongoDatabase mongoDatabase, ILogger> logger, - IMapper mapper) + IStorageMapper mapper) where TEntity : IHasIdAndOwnerId { protected abstract string CollectionName { get; } protected ILogger> Logger { get; } = logger; - private IMapper Mapper { get; } = mapper; + private IStorageMapper Mapper { get; } = mapper; /// - /// "Not found" must stay a real null, not a mapped default instance: AllowNullDestinationValues - /// = false (Program.cs) makes Mapper.Map<TModel>(entity) return a new, all-default - /// instead of null when itself is null - the same - /// gotcha already guarded against in the reference-data repositories' own Find* methods, just not here - /// yet. Without this guard, every controller's GetById "not found" check silently returned 200 - /// with a blank object instead of 404 for any entity type - caught via CarResourceTest, not a - /// mocked unit test, since a mocked repository never exercises the real mapping configuration. + /// "Not found" must stay a real null, not a mapped default instance: Mapperly throws on a null + /// source rather than substituting a default instance, so the missing-document check has to happen + /// before mapping regardless - this guard is what makes that "not found" case behave as null instead + /// of propagating an exception. /// public async Task FindOneAsync(string id, string ownerId) { var entity = await GetCollection().Find(x => x.Id == id && x.OwnerId == ownerId).FirstOrDefaultAsync(); - return entity is null ? default : Mapper.Map(entity); + return entity is null ? default : Mapper.ToModel(entity); } public async Task> FindAllAsync(string ownerId, int page, int pageSize, string? search, TModel input) @@ -54,7 +51,7 @@ public async Task> FindAllAsync(string ownerId, int page, in .ToListAsync(); return new PagedResult( - Mapper.Map>(entities), + Mapper.ToModels(entities), totalCount, page, pageSize @@ -63,14 +60,14 @@ public async Task> FindAllAsync(string ownerId, int page, in public async Task CreateAsync(TModel model) { - var entity = Mapper.Map(model); + var entity = Mapper.ToEntity(model); await GetCollection().InsertOneAsync(entity); - return Mapper.Map(entity); + return Mapper.ToModel(entity); } public async Task UpdateAsync(string id, TModel model, string ownerId) { - var entity = Mapper.Map(model); + var entity = Mapper.ToEntity(model); var result = await GetCollection().ReplaceOneAsync(x => x.Id == id && x.OwnerId == ownerId, entity); return result.ModifiedCount; } diff --git a/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs index 1a15b37..990e5c3 100644 --- a/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/MovieReferenceRepository.cs @@ -1,16 +1,16 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Common.System; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class MovieReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapper) : IMovieReferenceRepository +public class MovieReferenceRepository(IMongoDatabase mongoDatabase, MovieReferenceStorageMapper mapper) : IMovieReferenceRepository { private const string CollectionName = "movie_reference"; @@ -19,9 +19,9 @@ public class MovieReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp public async Task FindByIdAsync(string id) { var entity = await Collection.Find(x => x.Id == id).FirstOrDefaultAsync(); - // AutoMapper's AllowNullDestinationValues = false (Program.cs) makes Map(null) return a new, - // all-default instance instead of null - checking for a missing document must happen before mapping. - return entity is null ? null : mapper.Map(entity); + // Mapperly throws on a null source rather than substituting a default instance - checking for a + // missing document must happen before mapping regardless. + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleYearAsync(string title, int? year) @@ -35,7 +35,7 @@ public class MovieReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp var filter = Builders.Filter.ElemMatch(x => x.MatchedAliases, Builders.Filter.Eq(m => m.Title, normalized) & Builders.Filter.Eq(m => m.Year, year)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleAsync(string title) @@ -44,7 +44,7 @@ public class MovieReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp var filter = Builders.Filter.ElemMatch(x => x.MatchedAliases, Builders.Filter.Eq(m => m.Title, normalized)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByExternalIdAsync(string provider, string externalId) @@ -53,13 +53,13 @@ public class MovieReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapp // translation doesn't support indexing a Dictionary by a runtime key. var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task> FindAllAsync() { var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); - return entities.Select(mapper.Map).ToList(); + return entities.Select(mapper.ToModel).ToList(); } public async Task UpsertAsync(MovieReferenceModel model) @@ -71,7 +71,7 @@ public async Task UpsertAsync(MovieReferenceModel model) { model.MatchedAliases.Add(new ReferenceMatchModel { Title = model.TitleNormalized, Year = model.Year }); } - var entity = mapper.Map(model); + var entity = mapper.ToEntity(model); if (string.IsNullOrEmpty(entity.Id)) { @@ -82,6 +82,6 @@ public async Task UpsertAsync(MovieReferenceModel model) await Collection.ReplaceOneAsync(x => x.Id == entity.Id, entity, new ReplaceOptions { IsUpsert = true }); } - return mapper.Map(entity); + return mapper.ToModel(entity); } } diff --git a/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs b/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs index 489b000..c0c1477 100644 --- a/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs @@ -2,17 +2,17 @@ using System.Linq; using System.Text.RegularExpressions; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Bson; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class MovieRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class MovieRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IMovieRepository { protected override string CollectionName => "movie"; @@ -53,8 +53,9 @@ public async Task SetReferenceLinkAsync(string title, int? year, string re /// /// "Has no reference link yet" means is null OR empty string, not - /// just null: AutoMapper is configured with AllowNullDestinationValues = false (see Program.cs), - /// so mapping a model with a null string property stores an empty string, never an actual null. + /// just null: old documents (written before the AutoMapper -> Mapperly migration) can still store "" + /// for an unset field; new writes store a real null instead (Mapperly preserves nulls, and the Mongo + /// driver's IgnoreIfNullConvention then omits it entirely). Both generations must match. /// private static FilterDefinition UnresolvedFilter() { diff --git a/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs index ddd093b..166b767 100644 --- a/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/PersonReferenceRepository.cs @@ -1,15 +1,15 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class PersonReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapper) : IPersonReferenceRepository +public class PersonReferenceRepository(IMongoDatabase mongoDatabase, PersonReferenceStorageMapper mapper) : IPersonReferenceRepository { private const string CollectionName = "person_reference"; @@ -18,9 +18,9 @@ public class PersonReferenceRepository(IMongoDatabase mongoDatabase, IMapper map public async Task FindByIdAsync(string id) { var entity = await Collection.Find(x => x.Id == id).FirstOrDefaultAsync(); - // AutoMapper's AllowNullDestinationValues = false (Program.cs) makes Map(null) return a new, - // all-default instance instead of null - checking for a missing document must happen before mapping. - return entity is null ? null : mapper.Map(entity); + // Mapperly throws on a null source rather than substituting a default instance - checking for a + // missing document must happen before mapping regardless. + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByExternalIdAsync(string provider, string externalId) @@ -29,18 +29,18 @@ public class PersonReferenceRepository(IMongoDatabase mongoDatabase, IMapper map // translation doesn't support indexing a Dictionary by a runtime key. var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task> FindAllAsync() { var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); - return entities.Select(mapper.Map).ToList(); + return entities.Select(mapper.ToModel).ToList(); } public async Task UpsertAsync(PersonReferenceModel model) { - var entity = mapper.Map(model); + var entity = mapper.ToEntity(model); if (string.IsNullOrEmpty(entity.Id)) { @@ -51,6 +51,6 @@ public async Task UpsertAsync(PersonReferenceModel model) await Collection.ReplaceOneAsync(x => x.Id == entity.Id, entity, new ReplaceOptions { IsUpsert = true }); } - return mapper.Map(entity); + return mapper.ToModel(entity); } } diff --git a/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs b/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs index 3d22473..bfb8049 100644 --- a/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs @@ -1,13 +1,13 @@ -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class PlaylistRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class PlaylistRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IPlaylistRepository { protected override string CollectionName => "playlist"; diff --git a/src/Infrastructure.MongoDb/Repositories/SongRepository.cs b/src/Infrastructure.MongoDb/Repositories/SongRepository.cs index 0db21b4..6fed6eb 100644 --- a/src/Infrastructure.MongoDb/Repositories/SongRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/SongRepository.cs @@ -1,13 +1,13 @@ -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class SongRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class SongRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ISongRepository { protected override string CollectionName => "song"; diff --git a/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs index f68f29f..6ec21cf 100644 --- a/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs @@ -1,16 +1,16 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Common.System; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapper) : ITvShowReferenceRepository +public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, TvShowReferenceStorageMapper mapper) : ITvShowReferenceRepository { private const string CollectionName = "tvshow_reference"; @@ -19,9 +19,9 @@ public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, IMapper map public async Task FindByIdAsync(string id) { var entity = await Collection.Find(x => x.Id == id).FirstOrDefaultAsync(); - // AutoMapper's AllowNullDestinationValues = false (Program.cs) makes Map(null) return a new, - // all-default instance instead of null - checking for a missing document must happen before mapping. - return entity is null ? null : mapper.Map(entity); + // Mapperly throws on a null source rather than substituting a default instance - checking for a + // missing document must happen before mapping regardless. + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleYearAsync(string title, int? year) @@ -35,7 +35,7 @@ public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, IMapper map var filter = Builders.Filter.ElemMatch(x => x.MatchedAliases, Builders.Filter.Eq(m => m.Title, normalized) & Builders.Filter.Eq(m => m.Year, year)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleAsync(string title) @@ -44,7 +44,7 @@ public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, IMapper map var filter = Builders.Filter.ElemMatch(x => x.MatchedAliases, Builders.Filter.Eq(m => m.Title, normalized)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByExternalIdAsync(string provider, string externalId) @@ -53,13 +53,13 @@ public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, IMapper map // translation doesn't support indexing a Dictionary by a runtime key. var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task> FindAllAsync() { var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); - return entities.Select(mapper.Map).ToList(); + return entities.Select(mapper.ToModel).ToList(); } public async Task UpsertAsync(TvShowReferenceModel model) @@ -71,7 +71,7 @@ public async Task UpsertAsync(TvShowReferenceModel model) { model.MatchedAliases.Add(new ReferenceMatchModel { Title = model.TitleNormalized, Year = model.Year }); } - var entity = mapper.Map(model); + var entity = mapper.ToEntity(model); if (string.IsNullOrEmpty(entity.Id)) { @@ -82,6 +82,6 @@ public async Task UpsertAsync(TvShowReferenceModel model) await Collection.ReplaceOneAsync(x => x.Id == entity.Id, entity, new ReplaceOptions { IsUpsert = true }); } - return mapper.Map(entity); + return mapper.ToModel(entity); } } diff --git a/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs b/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs index ca55c06..75ca39f 100644 --- a/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs @@ -2,17 +2,17 @@ using System.Linq; using System.Text.RegularExpressions; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Bson; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class TvShowRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class TvShowRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ITvShowRepository { protected override string CollectionName => "tvshow"; @@ -54,8 +54,9 @@ public async Task SetReferenceLinkAsync(string title, int? year, string re /// /// "Has no reference link yet" means is null OR empty string, not - /// just null: AutoMapper is configured with AllowNullDestinationValues = false (see Program.cs), - /// so mapping a model with a null string property stores an empty string, never an actual null. + /// just null: old documents (written before the AutoMapper -> Mapperly migration) can still store "" + /// for an unset field; new writes store a real null instead (Mapperly preserves nulls, and the Mongo + /// driver's IgnoreIfNullConvention then omits it entirely). Both generations must match. /// private static FilterDefinition UnresolvedFilter() { diff --git a/src/Infrastructure.MongoDb/Repositories/VideoGameReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/VideoGameReferenceRepository.cs index 1389e39..5731084 100644 --- a/src/Infrastructure.MongoDb/Repositories/VideoGameReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/VideoGameReferenceRepository.cs @@ -1,16 +1,16 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Common.System; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class VideoGameReferenceRepository(IMongoDatabase mongoDatabase, IMapper mapper) : IVideoGameReferenceRepository +public class VideoGameReferenceRepository(IMongoDatabase mongoDatabase, VideoGameReferenceStorageMapper mapper) : IVideoGameReferenceRepository { private const string CollectionName = "videogame_reference"; @@ -19,7 +19,7 @@ public class VideoGameReferenceRepository(IMongoDatabase mongoDatabase, IMapper public async Task FindByIdAsync(string id) { var entity = await Collection.Find(x => x.Id == id).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleYearAsync(string title, int? year) @@ -28,7 +28,7 @@ public class VideoGameReferenceRepository(IMongoDatabase mongoDatabase, IMapper var filter = Builders.Filter.ElemMatch(x => x.MatchedAliases, Builders.Filter.Eq(m => m.Title, normalized) & Builders.Filter.Eq(m => m.Year, year)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleAsync(string title) @@ -37,20 +37,20 @@ public class VideoGameReferenceRepository(IMongoDatabase mongoDatabase, IMapper var filter = Builders.Filter.ElemMatch(x => x.MatchedAliases, Builders.Filter.Eq(m => m.Title, normalized)); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task FindByExternalIdAsync(string provider, string externalId) { var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); - return entity is null ? null : mapper.Map(entity); + return entity is null ? null : mapper.ToModel(entity); } public async Task> FindAllAsync() { var entities = await Collection.Find(FilterDefinition.Empty).ToListAsync(); - return entities.Select(mapper.Map).ToList(); + return entities.Select(mapper.ToModel).ToList(); } public async Task UpsertAsync(VideoGameReferenceModel model) @@ -60,7 +60,7 @@ public async Task UpsertAsync(VideoGameReferenceModel m { model.MatchedAliases.Add(new ReferenceMatchModel { Title = model.TitleNormalized, Year = model.Year }); } - var entity = mapper.Map(model); + var entity = mapper.ToEntity(model); if (string.IsNullOrEmpty(entity.Id)) { @@ -71,6 +71,6 @@ public async Task UpsertAsync(VideoGameReferenceModel m await Collection.ReplaceOneAsync(x => x.Id == entity.Id, entity, new ReplaceOptions { IsUpsert = true }); } - return mapper.Map(entity); + return mapper.ToModel(entity); } } diff --git a/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs b/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs index 949f437..2ae22e7 100644 --- a/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs @@ -2,17 +2,17 @@ using System.Linq; using System.Text.RegularExpressions; using System.Threading.Tasks; -using AutoMapper; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; using Microsoft.Extensions.Logging; using MongoDB.Bson; using MongoDB.Driver; namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class VideoGameRepository(IMongoDatabase mongoDatabase, ILogger> logger, IMapper mapper) +public class VideoGameRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IVideoGameRepository { protected override string CollectionName => "videogame"; @@ -53,8 +53,9 @@ public async Task SetReferenceLinkAsync(string title, int? year, string re /// /// "Has no reference link yet" means is null OR empty string, not - /// just null: AutoMapper is configured with AllowNullDestinationValues = false (see Program.cs), - /// so mapping a model with a null string property stores an empty string, never an actual null. + /// just null: old documents (written before the AutoMapper -> Mapperly migration) can still store "" + /// for an unset field; new writes store a real null instead (Mapperly preserves nulls, and the Mongo + /// driver's IgnoreIfNullConvention then omits it entirely). Both generations must match. /// private static FilterDefinition UnresolvedFilter() { diff --git a/src/WebApi.Contracts/Dto/HouseEventType.cs b/src/WebApi.Contracts/Dto/HouseEventType.cs index 6147390..727f77c 100644 --- a/src/WebApi.Contracts/Dto/HouseEventType.cs +++ b/src/WebApi.Contracts/Dto/HouseEventType.cs @@ -2,8 +2,8 @@ namespace Keeptrack.WebApi.Contracts.Dto; /// /// House history event type. Kept as a separate definition from Keeptrack.Domain.Models.HouseEventType -/// since WebApi.Contracts doesn't depend on Domain - member names must stay identical so AutoMapper can map -/// enum-to-enum by name. +/// since WebApi.Contracts doesn't depend on Domain - member names must stay identical so the generated +/// Mapperly mapper (EnumMappingStrategy.ByName) can map enum-to-enum by name. /// public enum HouseEventType { diff --git a/src/WebApi.Contracts/Dto/TvShowStatus.cs b/src/WebApi.Contracts/Dto/TvShowStatus.cs index 51680a9..80558d8 100644 --- a/src/WebApi.Contracts/Dto/TvShowStatus.cs +++ b/src/WebApi.Contracts/Dto/TvShowStatus.cs @@ -2,7 +2,8 @@ namespace Keeptrack.WebApi.Contracts.Dto; /// /// Mirrors Keeptrack.Domain.Models.TvShowStatus - WebApi.Contracts can't depend on Domain, so this -/// is a separate enum with matching member names; AutoMapper maps enum-to-enum by name automatically. +/// is a separate enum with matching member names; the generated Mapperly mapper (EnumMappingStrategy.ByName) +/// maps enum-to-enum by name. /// public enum TvShowStatus { diff --git a/src/WebApi/Controllers/AlbumController.cs b/src/WebApi/Controllers/AlbumController.cs index ef6a106..f1c76a1 100644 --- a/src/WebApi/Controllers/AlbumController.cs +++ b/src/WebApi/Controllers/AlbumController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Keeptrack.WebApi.ReferenceData; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -12,7 +13,7 @@ namespace Keeptrack.WebApi.Controllers; [Authorize] [Route("api/albums")] public class AlbumController( - IMapper mapper, + IDtoMapper mapper, IAlbumRepository dataRepository, ReferenceEnrichmentService enrichmentService, IServiceScopeFactory scopeFactory, @@ -56,6 +57,6 @@ public async Task> RefreshReference(string id) if (model is null) return NotFound(); model = await enrichmentService.TryLinkExistingAlbumReferenceAsync(model); - return Ok(Mapper.Map(model)); + return Ok(Mapper.ToDto(model)); } } diff --git a/src/WebApi/Controllers/BookController.cs b/src/WebApi/Controllers/BookController.cs index 592350b..e8a93df 100644 --- a/src/WebApi/Controllers/BookController.cs +++ b/src/WebApi/Controllers/BookController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Keeptrack.WebApi.ReferenceData; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -12,7 +13,7 @@ namespace Keeptrack.WebApi.Controllers; [Authorize] [Route("api/books")] public class BookController( - IMapper mapper, + IDtoMapper mapper, IBookRepository dataRepository, ReferenceEnrichmentService enrichmentService, IServiceScopeFactory scopeFactory, @@ -56,6 +57,6 @@ public async Task> RefreshReference(string id) if (model is null) return NotFound(); model = await enrichmentService.TryLinkExistingBookReferenceAsync(model); - return Ok(Mapper.Map(model)); + return Ok(Mapper.ToDto(model)); } } diff --git a/src/WebApi/Controllers/CarController.cs b/src/WebApi/Controllers/CarController.cs index 6b9cbff..a146e04 100644 --- a/src/WebApi/Controllers/CarController.cs +++ b/src/WebApi/Controllers/CarController.cs @@ -1,6 +1,7 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Domain.Services; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -10,10 +11,11 @@ namespace Keeptrack.WebApi.Controllers; [Authorize] [Route("api/cars")] public class CarController( - IMapper mapper, + IDtoMapper mapper, ICarRepository dataRepository, ICarHistoryRepository carHistoryRepository, - CarMetricsService metricsService) + CarMetricsService metricsService, + CarMetricsDtoMapper metricsMapper) : DataCrudControllerBase(mapper, dataRepository) { /// @@ -33,7 +35,7 @@ public async Task> GetMetrics(string id) var history = await carHistoryRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, new CarHistoryModel { OwnerId = ownerId, CarId = id, EventType = default, HistoryDate = default }); - return Ok(Mapper.Map(metricsService.ComputeMetrics(history.Items))); + return Ok(metricsMapper.ToDto(metricsService.ComputeMetrics(history.Items))); } /// diff --git a/src/WebApi/Controllers/CarHistoryController.cs b/src/WebApi/Controllers/CarHistoryController.cs index c49f657..83287d5 100644 --- a/src/WebApi/Controllers/CarHistoryController.cs +++ b/src/WebApi/Controllers/CarHistoryController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -8,5 +9,5 @@ namespace Keeptrack.WebApi.Controllers; [ApiController] [Authorize] [Route("api/car-history")] -public class CarHistoryController(IMapper mapper, ICarHistoryRepository dataRepository) +public class CarHistoryController(IDtoMapper mapper, ICarHistoryRepository dataRepository) : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/Controllers/DataCrudControllerBase.cs b/src/WebApi/Controllers/DataCrudControllerBase.cs index 4a27dc9..3a8bc83 100644 --- a/src/WebApi/Controllers/DataCrudControllerBase.cs +++ b/src/WebApi/Controllers/DataCrudControllerBase.cs @@ -1,5 +1,6 @@ using Keeptrack.Common.System; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Mvc; namespace Keeptrack.WebApi.Controllers; @@ -10,16 +11,16 @@ namespace Keeptrack.WebApi.Controllers; /// Data Transfer Object /// Domain Model [ApiController] -public abstract class DataCrudControllerBase(IMapper mapper, IDataRepository dataRepository) +public abstract class DataCrudControllerBase(IDtoMapper mapper, IDataRepository dataRepository) : ControllerBase where TModel : class, IHasIdAndOwnerId { /// /// Exposes the mapper to subclasses that add their own actions (e.g. a refresh-reference endpoint) - - /// lets them reuse this instance instead of capturing their own IMapper primary-constructor + /// lets them reuse this instance instead of capturing their own IDtoMapper primary-constructor /// parameter as a second field holding the same reference. /// - protected IMapper Mapper => mapper; + protected IDtoMapper Mapper => mapper; [HttpGet] [ProducesResponseType(200)] @@ -31,8 +32,8 @@ public async Task>> Get([FromQuery] PagedRequest pagedRequest.Page, pagedRequest.PageSize, pagedRequest.Search, - mapper.Map(input)); - return Ok(models.Map(mapper.Map)); + mapper.ToModel(input)); + return Ok(models.Map(mapper.ToDto)); } [HttpGet("{id}")] @@ -53,7 +54,7 @@ public async Task> GetById(string id) return NotFound(); } - return Ok(mapper.Map(model)); + return Ok(mapper.ToDto(model)); } [HttpPost] @@ -62,11 +63,11 @@ public async Task> GetById(string id) [ProducesResponseType(201)] public async Task Post([FromBody] TDto dto) { - var input = mapper.Map(dto); + var input = mapper.ToModel(dto); input.OwnerId = this.GetUserId(); var model = await dataRepository.CreateAsync(input); await OnCreatedAsync(model); - return CreatedAtAction(nameof(GetById), new { id = model.Id }, mapper.Map(model)); + return CreatedAtAction(nameof(GetById), new { id = model.Id }, mapper.ToDto(model)); } /// @@ -86,7 +87,7 @@ public async Task Put(string id, [FromBody] TDto dto) return BadRequest(); } - var input = mapper.Map(dto); + var input = mapper.ToModel(dto); input.OwnerId = this.GetUserId(); await dataRepository.UpdateAsync(id, input, this.GetUserId()); return NoContent(); diff --git a/src/WebApi/Controllers/EpisodeController.cs b/src/WebApi/Controllers/EpisodeController.cs index 4b56726..51aca95 100644 --- a/src/WebApi/Controllers/EpisodeController.cs +++ b/src/WebApi/Controllers/EpisodeController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -8,5 +9,5 @@ namespace Keeptrack.WebApi.Controllers; [ApiController] [Authorize] [Route("api/episodes")] -public class EpisodeController(IMapper mapper, IEpisodeRepository dataRepository) +public class EpisodeController(IDtoMapper mapper, IEpisodeRepository dataRepository) : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/Controllers/HouseController.cs b/src/WebApi/Controllers/HouseController.cs index 8bd21fc..309e92b 100644 --- a/src/WebApi/Controllers/HouseController.cs +++ b/src/WebApi/Controllers/HouseController.cs @@ -1,6 +1,7 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Domain.Services; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -10,10 +11,11 @@ namespace Keeptrack.WebApi.Controllers; [Authorize] [Route("api/houses")] public class HouseController( - IMapper mapper, + IDtoMapper mapper, IHouseRepository dataRepository, IHouseHistoryRepository houseHistoryRepository, - HouseMetricsService metricsService) + HouseMetricsService metricsService, + HouseMetricsDtoMapper metricsMapper) : DataCrudControllerBase(mapper, dataRepository) { /// @@ -32,7 +34,7 @@ public async Task> GetMetrics(string id) var history = await houseHistoryRepository.FindAllAsync(ownerId, 1, int.MaxValue, null, new HouseHistoryModel { OwnerId = ownerId, HouseId = id, EventType = default, HistoryDate = default }); - return Ok(Mapper.Map(metricsService.ComputeMetrics(history.Items))); + return Ok(metricsMapper.ToDto(metricsService.ComputeMetrics(history.Items))); } /// diff --git a/src/WebApi/Controllers/HouseHistoryController.cs b/src/WebApi/Controllers/HouseHistoryController.cs index 59e7937..97fda8a 100644 --- a/src/WebApi/Controllers/HouseHistoryController.cs +++ b/src/WebApi/Controllers/HouseHistoryController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -8,5 +9,5 @@ namespace Keeptrack.WebApi.Controllers; [ApiController] [Authorize] [Route("api/house-history")] -public class HouseHistoryController(IMapper mapper, IHouseHistoryRepository dataRepository) +public class HouseHistoryController(IDtoMapper mapper, IHouseHistoryRepository dataRepository) : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/Controllers/MovieController.cs b/src/WebApi/Controllers/MovieController.cs index b8ace84..4f5aaa8 100644 --- a/src/WebApi/Controllers/MovieController.cs +++ b/src/WebApi/Controllers/MovieController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Keeptrack.WebApi.ReferenceData; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -12,7 +13,7 @@ namespace Keeptrack.WebApi.Controllers; [Authorize] [Route("api/movies")] public class MovieController( - IMapper mapper, + IDtoMapper mapper, IMovieRepository dataRepository, ReferenceEnrichmentService enrichmentService, IServiceScopeFactory scopeFactory, @@ -55,6 +56,6 @@ public async Task> RefreshReference(string id) if (model is null) return NotFound(); model = await enrichmentService.TryLinkExistingMovieReferenceAsync(model); - return Ok(Mapper.Map(model)); + return Ok(Mapper.ToDto(model)); } } diff --git a/src/WebApi/Controllers/PlaylistController.cs b/src/WebApi/Controllers/PlaylistController.cs index 71a0b90..228d34b 100644 --- a/src/WebApi/Controllers/PlaylistController.cs +++ b/src/WebApi/Controllers/PlaylistController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -8,5 +9,5 @@ namespace Keeptrack.WebApi.Controllers; [ApiController] [Authorize] [Route("api/playlists")] -public class PlaylistController(IMapper mapper, IPlaylistRepository dataRepository) +public class PlaylistController(IDtoMapper mapper, IPlaylistRepository dataRepository) : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/Controllers/SongController.cs b/src/WebApi/Controllers/SongController.cs index 7d4978a..9088b3a 100644 --- a/src/WebApi/Controllers/SongController.cs +++ b/src/WebApi/Controllers/SongController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -8,5 +9,5 @@ namespace Keeptrack.WebApi.Controllers; [ApiController] [Authorize] [Route("api/songs")] -public class SongController(IMapper mapper, ISongRepository dataRepository) +public class SongController(IDtoMapper mapper, ISongRepository dataRepository) : DataCrudControllerBase(mapper, dataRepository); diff --git a/src/WebApi/Controllers/TvShowController.cs b/src/WebApi/Controllers/TvShowController.cs index a01ccf9..7386d37 100644 --- a/src/WebApi/Controllers/TvShowController.cs +++ b/src/WebApi/Controllers/TvShowController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Keeptrack.WebApi.ReferenceData; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -12,7 +13,7 @@ namespace Keeptrack.WebApi.Controllers; [Authorize] [Route("api/tv-shows")] public class TvShowController( - IMapper mapper, + IDtoMapper mapper, ITvShowRepository dataRepository, ReferenceEnrichmentService enrichmentService, IServiceScopeFactory scopeFactory, @@ -57,6 +58,6 @@ public async Task> RefreshReference(string id) if (model is null) return NotFound(); model = await enrichmentService.TryLinkExistingTvShowReferenceAsync(model); - return Ok(Mapper.Map(model)); + return Ok(Mapper.ToDto(model)); } } diff --git a/src/WebApi/Controllers/VideoGameController.cs b/src/WebApi/Controllers/VideoGameController.cs index 246b7f5..cfbced1 100644 --- a/src/WebApi/Controllers/VideoGameController.cs +++ b/src/WebApi/Controllers/VideoGameController.cs @@ -1,5 +1,6 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Keeptrack.WebApi.ReferenceData; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -12,7 +13,7 @@ namespace Keeptrack.WebApi.Controllers; [Authorize] [Route("api/video-games")] public class VideoGameController( - IMapper mapper, + IDtoMapper mapper, IVideoGameRepository dataRepository, ReferenceEnrichmentService enrichmentService, IServiceScopeFactory scopeFactory, @@ -55,6 +56,6 @@ public async Task> RefreshReference(string id) if (model is null) return NotFound(); model = await enrichmentService.TryLinkExistingVideoGameReferenceAsync(model); - return Ok(Mapper.Map(model)); + return Ok(Mapper.ToDto(model)); } } diff --git a/src/WebApi/Controllers/WatchNextController.cs b/src/WebApi/Controllers/WatchNextController.cs index d96c0b3..a09e5d8 100644 --- a/src/WebApi/Controllers/WatchNextController.cs +++ b/src/WebApi/Controllers/WatchNextController.cs @@ -1,6 +1,7 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Domain.Services; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -15,7 +16,8 @@ public class WatchNextController( IMovieRepository movieRepository, ITvShowReferenceRepository tvShowReferenceRepository, WatchNextService watchNextService, - IMapper mapper) : ControllerBase + InProgressShowDtoMapper inProgressShowMapper, + IDtoMapper movieMapper) : ControllerBase { [HttpGet] [ProducesResponseType(200)] @@ -42,8 +44,9 @@ public async Task> Get() return Ok(new WatchNextDto { - InProgressShows = mapper.Map>(watchNextService.ComputeInProgressShows(shows.Items, episodes.Items, referencesByShowId)), - MoviesToWatch = mapper.Map>(watchNextService.FilterMoviesToWatch(moviesToWatch.Items)) + InProgressShows = watchNextService.ComputeInProgressShows(shows.Items, episodes.Items, referencesByShowId) + .Select(inProgressShowMapper.ToDto).ToList(), + MoviesToWatch = watchNextService.FilterMoviesToWatch(moviesToWatch.Items).Select(movieMapper.ToDto).ToList() }); } } diff --git a/src/WebApi/Controllers/WishlistController.cs b/src/WebApi/Controllers/WishlistController.cs index 87b64fa..ddac055 100644 --- a/src/WebApi/Controllers/WishlistController.cs +++ b/src/WebApi/Controllers/WishlistController.cs @@ -1,6 +1,7 @@ using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; using Keeptrack.Domain.Services; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -15,7 +16,10 @@ public class WishlistController( IBookRepository bookRepository, IVideoGameRepository videoGameRepository, WishlistService wishlistService, - IMapper mapper) : ControllerBase + IDtoMapper movieMapper, + IDtoMapper tvShowMapper, + IDtoMapper bookMapper, + IDtoMapper videoGameMapper) : ControllerBase { [HttpGet] [ProducesResponseType(200)] @@ -35,10 +39,10 @@ public async Task> Get() return Ok(new WishlistDto { - Movies = mapper.Map>(wishlistService.SortMovies(movies.Items)), - TvShows = mapper.Map>(wishlistService.SortTvShows(tvShows.Items)), - Books = mapper.Map>(wishlistService.SortBooks(books.Items)), - VideoGames = mapper.Map>(wishlistService.SortVideoGames(videoGames.Items)) + Movies = wishlistService.SortMovies(movies.Items).Select(movieMapper.ToDto).ToList(), + TvShows = wishlistService.SortTvShows(tvShows.Items).Select(tvShowMapper.ToDto).ToList(), + Books = wishlistService.SortBooks(books.Items).Select(bookMapper.ToDto).ToList(), + VideoGames = wishlistService.SortVideoGames(videoGames.Items).Select(videoGameMapper.ToDto).ToList() }); } } diff --git a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs index b0a921d..d895de1 100644 --- a/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs +++ b/src/WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs @@ -1,4 +1,6 @@ -using Keeptrack.Infrastructure.MongoDb.Repositories; +using Keeptrack.Infrastructure.MongoDb.Entities; +using Keeptrack.Infrastructure.MongoDb.Mappers; +using Keeptrack.Infrastructure.MongoDb.Repositories; using Microsoft.Extensions.DependencyInjection.Extensions; using MongoDB.Bson.Serialization.Conventions; using MongoDB.Driver; @@ -25,6 +27,26 @@ internal static void AddMongoDbInfrastructure(this IServiceCollection services, services.AddSingleton(sp => sp.GetRequiredService().GetDatabase(configuration.DatabaseName)); + services.AddSingleton, BookStorageMapper>(); + services.AddSingleton, MovieStorageMapper>(); + services.AddSingleton, TvShowStorageMapper>(); + services.AddSingleton, AlbumStorageMapper>(); + services.AddSingleton, EpisodeStorageMapper>(); + services.AddSingleton, SongStorageMapper>(); + services.AddSingleton, PlaylistStorageMapper>(); + services.AddSingleton, VideoGameStorageMapper>(); + services.AddSingleton, CarStorageMapper>(); + services.AddSingleton, CarHistoryStorageMapper>(); + services.AddSingleton, HouseStorageMapper>(); + services.AddSingleton, HouseHistoryStorageMapper>(); + + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.TryAddScoped(); services.TryAddScoped(); services.TryAddScoped(); diff --git a/src/WebApi/GlobalUsings.cs b/src/WebApi/GlobalUsings.cs index 9f22a2e..657a236 100644 --- a/src/WebApi/GlobalUsings.cs +++ b/src/WebApi/GlobalUsings.cs @@ -1,5 +1,4 @@ global using System; -global using AutoMapper; global using Keeptrack.WebApi; global using Keeptrack.WebApi.Contracts.Dto; global using Keeptrack.WebApi.DependencyInjection; diff --git a/src/WebApi/Mappers/AlbumDtoMapper.cs b/src/WebApi/Mappers/AlbumDtoMapper.cs new file mode 100644 index 0000000..6194e6e --- /dev/null +++ b/src/WebApi/Mappers/AlbumDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class AlbumDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(AlbumModel.OwnerId), "")] + public partial AlbumModel ToModel(AlbumDto dto); + + [MapperIgnoreSource(nameof(AlbumModel.OwnerId))] + public partial AlbumDto ToDto(AlbumModel model); +} diff --git a/src/WebApi/Mappers/AlbumReferenceDtoMapper.cs b/src/WebApi/Mappers/AlbumReferenceDtoMapper.cs new file mode 100644 index 0000000..77ae813 --- /dev/null +++ b/src/WebApi/Mappers/AlbumReferenceDtoMapper.cs @@ -0,0 +1,23 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto) - see for the general rationale. +/// / are ignored +/// here and hydrated manually by - same reasoning as +/// . +/// +[Mapper] +public partial class AlbumReferenceDtoMapper +{ + [MapperIgnoreTarget(nameof(AlbumReferenceDto.ArtistName))] + [MapperIgnoreTarget(nameof(AlbumReferenceDto.ArtistImageUrl))] + [MapperIgnoreSource(nameof(AlbumReferenceModel.TitleNormalized))] + [MapperIgnoreSource(nameof(AlbumReferenceModel.ArtistReferenceId))] + [MapperIgnoreSource(nameof(AlbumReferenceModel.ExternalIds))] + [MapperIgnoreSource(nameof(AlbumReferenceModel.MatchedAliases))] + [MapperIgnoreSource(nameof(AlbumReferenceModel.LastEnrichedAt))] + public partial AlbumReferenceDto ToDto(AlbumReferenceModel model); +} diff --git a/src/WebApi/Mappers/BookDtoMapper.cs b/src/WebApi/Mappers/BookDtoMapper.cs new file mode 100644 index 0000000..b8c4ea2 --- /dev/null +++ b/src/WebApi/Mappers/BookDtoMapper.cs @@ -0,0 +1,19 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class BookDtoMapper : IDtoMapper +{ + // OwnerId is `required` on BookModel, so it can't just be ignored (Mapperly's generated object + // initializer would fail to compile) - MapValue satisfies the required-member constructor while + // still leaving OwnerId to be set server-side from claims (DataCrudControllerBase), never from + // client input, exactly like the ignored member it replaces. + [MapValue(nameof(BookModel.OwnerId), "")] + public partial BookModel ToModel(BookDto dto); + + [MapperIgnoreSource(nameof(BookModel.OwnerId))] + public partial BookDto ToDto(BookModel model); +} diff --git a/src/WebApi/Mappers/BookReferenceDtoMapper.cs b/src/WebApi/Mappers/BookReferenceDtoMapper.cs new file mode 100644 index 0000000..560b211 --- /dev/null +++ b/src/WebApi/Mappers/BookReferenceDtoMapper.cs @@ -0,0 +1,23 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto) - see for the general rationale. +/// / are ignored here +/// and hydrated manually by : the model only carries an +/// AuthorReferenceId, the Dto needs the person's name joined in from person_reference. +/// +[Mapper] +public partial class BookReferenceDtoMapper +{ + [MapperIgnoreTarget(nameof(BookReferenceDto.AuthorName))] + [MapperIgnoreTarget(nameof(BookReferenceDto.AuthorImageUrl))] + [MapperIgnoreSource(nameof(BookReferenceModel.TitleNormalized))] + [MapperIgnoreSource(nameof(BookReferenceModel.AuthorReferenceId))] + [MapperIgnoreSource(nameof(BookReferenceModel.ExternalIds))] + [MapperIgnoreSource(nameof(BookReferenceModel.MatchedAliases))] + [MapperIgnoreSource(nameof(BookReferenceModel.LastEnrichedAt))] + public partial BookReferenceDto ToDto(BookReferenceModel model); +} diff --git a/src/WebApi/Mappers/CarDtoMapper.cs b/src/WebApi/Mappers/CarDtoMapper.cs new file mode 100644 index 0000000..5482128 --- /dev/null +++ b/src/WebApi/Mappers/CarDtoMapper.cs @@ -0,0 +1,32 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper(EnumMappingStrategy = EnumMappingStrategy.ByName)] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class CarDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(CarModel.OwnerId), "")] + public partial CarModel ToModel(CarDto dto); + + [MapperIgnoreSource(nameof(CarModel.OwnerId))] + public partial CarDto ToDto(CarModel model); + + /// + /// CarDto.EnergyType is nullable (CarEnergyType?) while CarModel.EnergyType is required - the same + /// "nullable DTO member mapping to a required model member" gotcha as CommonDtoMappings.ToRequiredString, + /// just for an enum instead of a string, so it can't reuse that helper. MapEnergyType below still gets + /// the generated, drift-checked ByName enum conversion; only the null -> default fallback is hand-written. + /// A Mapperly mapper class's partial methods must all be instance or all be static - both stay instance + /// to match ToModel/ToDto above. + /// + [UserMapping] + private Domain.Models.CarEnergyType ToRequiredCarEnergyType(Contracts.Dto.CarEnergyType? value) + { + return value.HasValue ? MapEnergyType(value.Value) : default; + } + + private partial Domain.Models.CarEnergyType MapEnergyType(Contracts.Dto.CarEnergyType value); +} diff --git a/src/WebApi/Mappers/CarHistoryDtoMapper.cs b/src/WebApi/Mappers/CarHistoryDtoMapper.cs new file mode 100644 index 0000000..f18c825 --- /dev/null +++ b/src/WebApi/Mappers/CarHistoryDtoMapper.cs @@ -0,0 +1,15 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper(EnumMappingStrategy = EnumMappingStrategy.ByName)] +public partial class CarHistoryDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(CarHistoryModel.OwnerId), "")] + public partial CarHistoryModel ToModel(CarHistoryDto dto); + + [MapperIgnoreSource(nameof(CarHistoryModel.OwnerId))] + public partial CarHistoryDto ToDto(CarHistoryModel model); +} diff --git a/src/WebApi/Mappers/CarMetricsDtoMapper.cs b/src/WebApi/Mappers/CarMetricsDtoMapper.cs new file mode 100644 index 0000000..2fc0be4 --- /dev/null +++ b/src/WebApi/Mappers/CarMetricsDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto): is a pure Domain-level +/// computation with no Dto dependency, so maps its +/// result here. Mapperly preserves a null as null natively - +/// no AllowNull()-style opt-out needed, unlike the AutoMapper original. +/// +[Mapper] +public partial class CarMetricsDtoMapper +{ + public partial CarMetricsDto ToDto(CarMetricsModel model); +} diff --git a/src/WebApi/Mappers/CommonDtoMappings.cs b/src/WebApi/Mappers/CommonDtoMappings.cs new file mode 100644 index 0000000..7cd9f8c --- /dev/null +++ b/src/WebApi/Mappers/CommonDtoMappings.cs @@ -0,0 +1,23 @@ +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// Shared fallback for a nullable DTO string member mapping to a Domain model member that has no +/// sensible default (typically required) - BookDto.Title is nullable while +/// BookModel.Title is required non-nullable, the InventoryPageBase new()- +/// constraint gotcha documented in CLAUDE.md. AutoMapper silently substituted "" for a null +/// source string everywhere; this reproduces that one specific behavior deliberately, for exact parity, +/// rather than letting a missing title become a null reference deeper in the model. Attached to every +/// DTO mapper that has at least one such member via [UseStaticMapper(typeof(CommonDtoMappings))]. +/// Tightening this to a real 400 validation error for a missing title is a deliberate follow-up, not +/// part of this mechanical migration - see docs/automapper-removal-plan.md. +/// +public static class CommonDtoMappings +{ + [UserMapping] + public static string ToRequiredString(string? value) + { + return value ?? string.Empty; + } +} diff --git a/src/WebApi/Mappers/EpisodeDtoMapper.cs b/src/WebApi/Mappers/EpisodeDtoMapper.cs new file mode 100644 index 0000000..2283f78 --- /dev/null +++ b/src/WebApi/Mappers/EpisodeDtoMapper.cs @@ -0,0 +1,15 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper] +public partial class EpisodeDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(EpisodeModel.OwnerId), "")] + public partial EpisodeModel ToModel(EpisodeDto dto); + + [MapperIgnoreSource(nameof(EpisodeModel.OwnerId))] + public partial EpisodeDto ToDto(EpisodeModel model); +} diff --git a/src/WebApi/Mappers/HouseDtoMapper.cs b/src/WebApi/Mappers/HouseDtoMapper.cs new file mode 100644 index 0000000..2f9e327 --- /dev/null +++ b/src/WebApi/Mappers/HouseDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class HouseDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(HouseModel.OwnerId), "")] + public partial HouseModel ToModel(HouseDto dto); + + [MapperIgnoreSource(nameof(HouseModel.OwnerId))] + public partial HouseDto ToDto(HouseModel model); +} diff --git a/src/WebApi/Mappers/HouseHistoryDtoMapper.cs b/src/WebApi/Mappers/HouseHistoryDtoMapper.cs new file mode 100644 index 0000000..99143bf --- /dev/null +++ b/src/WebApi/Mappers/HouseHistoryDtoMapper.cs @@ -0,0 +1,15 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper(EnumMappingStrategy = EnumMappingStrategy.ByName)] +public partial class HouseHistoryDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(HouseHistoryModel.OwnerId), "")] + public partial HouseHistoryModel ToModel(HouseHistoryDto dto); + + [MapperIgnoreSource(nameof(HouseHistoryModel.OwnerId))] + public partial HouseHistoryDto ToDto(HouseHistoryModel model); +} diff --git a/src/WebApi/Mappers/HouseMetricsDtoMapper.cs b/src/WebApi/Mappers/HouseMetricsDtoMapper.cs new file mode 100644 index 0000000..3e761bb --- /dev/null +++ b/src/WebApi/Mappers/HouseMetricsDtoMapper.cs @@ -0,0 +1,15 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto): is a pure Domain-level +/// computation with no Dto dependency, so maps its +/// result here. +/// +[Mapper(EnumMappingStrategy = EnumMappingStrategy.ByName)] +public partial class HouseMetricsDtoMapper +{ + public partial HouseMetricsDto ToDto(HouseMetricsModel model); +} diff --git a/src/WebApi/Mappers/IDtoMapper.cs b/src/WebApi/Mappers/IDtoMapper.cs new file mode 100644 index 0000000..6526d1a --- /dev/null +++ b/src/WebApi/Mappers/IDtoMapper.cs @@ -0,0 +1,16 @@ +namespace Keeptrack.WebApi.Mappers; + +/// +/// Maps between a public REST DTO and its Domain model counterpart. Implemented per CRUD pair by a +/// Mapperly [Mapper] partial class (e.g. BookDtoMapper) and injected into +/// instead of AutoMapper's untyped +/// IMapper. Read-only feature controllers (WatchNext, Wishlist, Car/House metrics, +/// reference-data) use a small one-directional Model-to-DTO mapper class instead - they have no DTO -> +/// Model direction at all, so this bidirectional interface doesn't fit them. +/// +public interface IDtoMapper +{ + TModel ToModel(TDto dto); + + TDto ToDto(TModel model); +} diff --git a/src/WebApi/Mappers/InProgressShowDtoMapper.cs b/src/WebApi/Mappers/InProgressShowDtoMapper.cs new file mode 100644 index 0000000..c91c984 --- /dev/null +++ b/src/WebApi/Mappers/InProgressShowDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto): is a pure Domain-level +/// computation with no Dto dependency, so maps its result +/// here. Injected directly, same shape as the reference-data storage mappers - see +/// docs/automapper-removal-plan.md. +/// +[Mapper] +public partial class InProgressShowDtoMapper +{ + public partial InProgressShowDto ToDto(InProgressShowModel model); +} diff --git a/src/WebApi/Mappers/MovieDtoMapper.cs b/src/WebApi/Mappers/MovieDtoMapper.cs new file mode 100644 index 0000000..dd56e2d --- /dev/null +++ b/src/WebApi/Mappers/MovieDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class MovieDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(MovieModel.OwnerId), "")] + public partial MovieModel ToModel(MovieDto dto); + + [MapperIgnoreSource(nameof(MovieModel.OwnerId))] + public partial MovieDto ToDto(MovieModel model); +} diff --git a/src/WebApi/Mappers/MovieReferenceDtoMapper.cs b/src/WebApi/Mappers/MovieReferenceDtoMapper.cs new file mode 100644 index 0000000..76241ec --- /dev/null +++ b/src/WebApi/Mappers/MovieReferenceDtoMapper.cs @@ -0,0 +1,20 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto) - see for why, including the +/// ignore. +/// +[Mapper] +public partial class MovieReferenceDtoMapper +{ + [MapperIgnoreTarget(nameof(MovieReferenceDto.Cast))] + [MapperIgnoreSource(nameof(MovieReferenceModel.TitleNormalized))] + [MapperIgnoreSource(nameof(MovieReferenceModel.ExternalIds))] + [MapperIgnoreSource(nameof(MovieReferenceModel.MatchedAliases))] + [MapperIgnoreSource(nameof(MovieReferenceModel.Cast))] + [MapperIgnoreSource(nameof(MovieReferenceModel.LastEnrichedAt))] + public partial MovieReferenceDto ToDto(MovieReferenceModel model); +} diff --git a/src/WebApi/Mappers/PlaylistDtoMapper.cs b/src/WebApi/Mappers/PlaylistDtoMapper.cs new file mode 100644 index 0000000..80e44d9 --- /dev/null +++ b/src/WebApi/Mappers/PlaylistDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class PlaylistDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(PlaylistModel.OwnerId), "")] + public partial PlaylistModel ToModel(PlaylistDto dto); + + [MapperIgnoreSource(nameof(PlaylistModel.OwnerId))] + public partial PlaylistDto ToDto(PlaylistModel model); +} diff --git a/src/WebApi/Mappers/SongDtoMapper.cs b/src/WebApi/Mappers/SongDtoMapper.cs new file mode 100644 index 0000000..4eabff6 --- /dev/null +++ b/src/WebApi/Mappers/SongDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class SongDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(SongModel.OwnerId), "")] + public partial SongModel ToModel(SongDto dto); + + [MapperIgnoreSource(nameof(SongModel.OwnerId))] + public partial SongDto ToDto(SongModel model); +} diff --git a/src/WebApi/Mappers/TvShowDtoMapper.cs b/src/WebApi/Mappers/TvShowDtoMapper.cs new file mode 100644 index 0000000..a4ac75d --- /dev/null +++ b/src/WebApi/Mappers/TvShowDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper(EnumMappingStrategy = EnumMappingStrategy.ByName)] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class TvShowDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(TvShowModel.OwnerId), "")] + public partial TvShowModel ToModel(TvShowDto dto); + + [MapperIgnoreSource(nameof(TvShowModel.OwnerId))] + public partial TvShowDto ToDto(TvShowModel model); +} diff --git a/src/WebApi/Mappers/TvShowReferenceDtoMapper.cs b/src/WebApi/Mappers/TvShowReferenceDtoMapper.cs new file mode 100644 index 0000000..903b23b --- /dev/null +++ b/src/WebApi/Mappers/TvShowReferenceDtoMapper.cs @@ -0,0 +1,23 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto): admins submit a LinkReferenceRequestDto, never a full +/// , so there's no Dto -> Model direction to map. +/// is ignored here and hydrated manually by - the +/// model only carries a PersonReferenceId, while the Dto needs the person's name/photo joined in +/// from person_reference, a join Mapperly has no repository access to perform. +/// +[Mapper] +public partial class TvShowReferenceDtoMapper +{ + [MapperIgnoreTarget(nameof(TvShowReferenceDto.Cast))] + [MapperIgnoreSource(nameof(TvShowReferenceModel.TitleNormalized))] + [MapperIgnoreSource(nameof(TvShowReferenceModel.ExternalIds))] + [MapperIgnoreSource(nameof(TvShowReferenceModel.MatchedAliases))] + [MapperIgnoreSource(nameof(TvShowReferenceModel.Cast))] + [MapperIgnoreSource(nameof(TvShowReferenceModel.LastEnrichedAt))] + public partial TvShowReferenceDto ToDto(TvShowReferenceModel model); +} diff --git a/src/WebApi/Mappers/VideoGameDtoMapper.cs b/src/WebApi/Mappers/VideoGameDtoMapper.cs new file mode 100644 index 0000000..5b4ffb4 --- /dev/null +++ b/src/WebApi/Mappers/VideoGameDtoMapper.cs @@ -0,0 +1,16 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +[Mapper(EnumMappingStrategy = EnumMappingStrategy.ByName)] +[UseStaticMapper(typeof(CommonDtoMappings))] +public partial class VideoGameDtoMapper : IDtoMapper +{ + // see BookDtoMapper.ToModel for why MapValue (not MapperIgnoreTarget) is required here + [MapValue(nameof(VideoGameModel.OwnerId), "")] + public partial VideoGameModel ToModel(VideoGameDto dto); + + [MapperIgnoreSource(nameof(VideoGameModel.OwnerId))] + public partial VideoGameDto ToDto(VideoGameModel model); +} diff --git a/src/WebApi/Mappers/VideoGameReferenceDtoMapper.cs b/src/WebApi/Mappers/VideoGameReferenceDtoMapper.cs new file mode 100644 index 0000000..46e4d8c --- /dev/null +++ b/src/WebApi/Mappers/VideoGameReferenceDtoMapper.cs @@ -0,0 +1,17 @@ +using Keeptrack.Domain.Models; +using Riok.Mapperly.Abstractions; + +namespace Keeptrack.WebApi.Mappers; + +/// +/// One-directional (Model -> Dto) - see for the general rationale. +/// +[Mapper] +public partial class VideoGameReferenceDtoMapper +{ + [MapperIgnoreSource(nameof(VideoGameReferenceModel.TitleNormalized))] + [MapperIgnoreSource(nameof(VideoGameReferenceModel.ExternalIds))] + [MapperIgnoreSource(nameof(VideoGameReferenceModel.MatchedAliases))] + [MapperIgnoreSource(nameof(VideoGameReferenceModel.LastEnrichedAt))] + public partial VideoGameReferenceDto ToDto(VideoGameReferenceModel model); +} diff --git a/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs deleted file mode 100644 index bf91a5d..0000000 --- a/src/WebApi/MappingProfiles/CarDataStorageMappingProfile.cs +++ /dev/null @@ -1,97 +0,0 @@ -using Keeptrack.Domain.Models; -using Keeptrack.Infrastructure.MongoDb.Entities; - -namespace Keeptrack.WebApi.MappingProfiles; - -public class CarDataStorageMappingProfile : Profile -{ - public override string ProfileName - { - get { return "KeeptrackCarDataStorageMappingProfile"; } - } - - public CarDataStorageMappingProfile() - { - CreateMap(); - CreateMap(); - - MapCarHistoryModel(); - MapCarHistory(); - } - - private void MapCarHistoryModel() - { - CreateMap() - .ForMember(x => x.City, opt => opt.MapFrom( - x => x.Location != null ? x.Location.City : null)) - .ForMember(x => x.PostalCode, opt => opt.MapFrom( - x => x.Location != null ? x.Location.PostalCode : null)) - .ForMember(x => x.Country, opt => opt.MapFrom( - x => x.Location != null ? x.Location.Country : null)) - .ForMember(x => x.Longitude, opt => opt.MapFrom( - x => x.Location != null && x.Location.Coordinates != null ? x.Location.Coordinates[0] : (double?)null)) - .ForMember(x => x.Latitude, opt => opt.MapFrom( - x => x.Location != null && x.Location.Coordinates != null ? x.Location.Coordinates[1] : (double?)null)) - .ForMember(x => x.FuelCategory, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.Category : null)) - .ForMember(x => x.FuelVolume, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.Volume : null)) - .ForMember(x => x.FuelUnitPrice, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.UnitPrice : null)) - .ForMember(x => x.ElectricVolume, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.ElectricVolume : null)) - .ForMember(x => x.ElectricUnitPrice, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.ElectricUnitPrice : null)) - .ForMember(x => x.IsFullRefill, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.IsFullRefill : null)) - .ForMember(x => x.DeltaMileage, opt => opt.MapFrom( - x => x.Fuel != null ? x.Fuel.DeltaMileage : null)) - .ForMember(x => x.StationBrandName, opt => opt.MapFrom( - x => x.Station != null ? x.Station.BrandName : null)); - } - - private void MapCarHistory() - { - CreateMap() - // HistoryDate is a plain DateTime on both sides (unlike every other Date field in this codebase, - // which is DateOnly on the model and goes through DataStorageMappingProfile's DateOnly<->DateTime - // converter - that converter is what normally stamps DateTimeKind.Utc), so nothing upstream - // guarantees a Utc Kind here. The Mongo driver's default DateTimeSerializer requires it. - .ForMember(x => x.HistoryDate, opt => opt.MapFrom( - x => DateTime.SpecifyKind(x.HistoryDate, DateTimeKind.Utc))) - .ForMember(x => x.Location, opt => opt.MapFrom( - x => x)) - .ForMember(x => x.Fuel, opt => opt.MapFrom( - x => x)) - .ForMember(x => x.Station, opt => opt.MapFrom( - x => x)); - - // Coordinates lives inside CarHistoryLocation (alongside City) - both are location data, so both - // belong in the one sub-document instead of Coordinates sitting as a separate sibling field on - // CarHistory itself, which was the original (unreviewed) shape. - CreateMap() - .ForMember(x => x.Coordinates, opt => - { - // AllowNull() is required here: AllowNullDestinationValues = false (Program.cs) otherwise - // substitutes a new empty List for a null MapFrom result (same class of gotcha as - // ReferenceMatchModel.Creator, documented in CLAUDE.md) - MapCarHistoryModel's reverse mapping - // reads Coordinates[0]/[1] guarded by "!= null", which an empty (not null) list defeats, - // throwing IndexOutOfRange the moment Longitude/Latitude are unset. Caught by a real-MongoDB - // CarHistoryResourceTest create/read round-trip, not by a mocked unit test. - opt.MapFrom(x => (x.Longitude.HasValue && x.Latitude.HasValue) ? new List { x.Longitude.Value, x.Latitude.Value } : null); - opt.AllowNull(); - }); - - CreateMap() - .ForMember(x => x.Category, opt => opt.MapFrom( - x => x.FuelCategory)) - .ForMember(x => x.Volume, opt => opt.MapFrom( - x => x.FuelVolume)) - .ForMember(x => x.UnitPrice, opt => opt.MapFrom( - x => x.FuelUnitPrice)); - - CreateMap() - .ForMember(x => x.BrandName, opt => opt.MapFrom( - x => x.StationBrandName)); - } -} diff --git a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs deleted file mode 100644 index 2df2541..0000000 --- a/src/WebApi/MappingProfiles/DataStorageMappingProfile.cs +++ /dev/null @@ -1,83 +0,0 @@ -namespace Keeptrack.WebApi.MappingProfiles; - -public class DataStorageMappingProfile : Profile -{ - public override string ProfileName - { - get { return "KeeptrackDataStorageMappingProfile"; } - } - - public DataStorageMappingProfile() - { - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap() - .ForMember(x => x.Platform, opt => opt.Ignore()) - .ForMember(x => x.State, opt => opt.Ignore()); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - - // Creator has no creator dimension for TV show/movie/video game (always null there) - overriding - // the profile-wide AllowNullDestinationValues = false (Program.cs) just for this member keeps a - // null Creator stored as an actual BSON null instead of "", so the app never has to treat null and - // "" as equivalent when comparing it (see ReferenceEnrichmentService.MergeMatchedAliases). - CreateMap() - .ForMember(x => x.Creator, opt => opt.AllowNull()); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap().ConvertUsing(dt => DateOnly.FromDateTime(dt)); - CreateMap().ConvertUsing(d => d.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc)); - } -} diff --git a/src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs b/src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs deleted file mode 100644 index ab83397..0000000 --- a/src/WebApi/MappingProfiles/HouseDataStorageMappingProfile.cs +++ /dev/null @@ -1,25 +0,0 @@ -using Keeptrack.Domain.Models; -using Keeptrack.Infrastructure.MongoDb.Entities; - -namespace Keeptrack.WebApi.MappingProfiles; - -public class HouseDataStorageMappingProfile : Profile -{ - public override string ProfileName - { - get { return "KeeptrackHouseDataStorageMappingProfile"; } - } - - public HouseDataStorageMappingProfile() - { - CreateMap(); - CreateMap(); - - // HistoryDate is DateOnly on the model, DateTime on the entity - the DateOnly<->DateTime converter - // registered in DataStorageMappingProfile (which also stamps DateTimeKind.Utc) applies automatically, - // same as every other date field in the app except Car's (see CarDataStorageMappingProfile for why - // Car needed its own explicit conversion instead). - CreateMap(); - CreateMap(); - } -} diff --git a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs b/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs deleted file mode 100644 index ff5ae3b..0000000 --- a/src/WebApi/MappingProfiles/WebServiceMappingProfile.cs +++ /dev/null @@ -1,113 +0,0 @@ -namespace Keeptrack.WebApi.MappingProfiles; - -public class WebServiceMappingProfile : Profile -{ - public override string ProfileName - { - get { return "KeeptrackWebServiceMappingProfile"; } - } - - public WebServiceMappingProfile() - { - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap() - .ForMember(x => x.OwnerId, opt => opt.Ignore()); - CreateMap(); - - CreateMap(); - CreateMap(); - - CreateMap(); - CreateMap(); - - // WatchNext reads are one-directional (Model -> Dto): WatchNextService is a pure Domain-level - // computation with no Dto dependency, so WatchNextController maps its result here. - CreateMap(); - - // Car metrics reads are one-directional (Model -> Dto), same reasoning as WatchNext above: - // CarMetricsService is a pure Domain-level computation with no Dto dependency. - // NextMaintenance needs AllowNull() for the same reason ReferenceMatchModel.Creator does (see - // Program.cs's AllowNullDestinationValues = false): without it, a null NextMaintenance model (no - // maintenance recorded yet) maps to a new, all-default NextMaintenanceDto instead of staying null - - // caught by CarResourceTest against a real car with no history, not by a mocked unit test. - CreateMap() - .ForMember(x => x.NextMaintenance, opt => opt.AllowNull()); - CreateMap(); - CreateMap(); - CreateMap(); - CreateMap(); - - // House metrics reads are one-directional (Model -> Dto), same reasoning as Car metrics above: - // HouseMetricsService is a pure Domain-level computation with no Dto dependency. - CreateMap(); - CreateMap(); - CreateMap(); - - // Reference-data reads are one-directional (Model -> Dto): admins submit a LinkReferenceRequestDto, - // never a full TvShowReferenceDto/MovieReferenceDto, so there's no Dto -> Model direction to map. - CreateMap(); - CreateMap(); - - // Cast is ignored here and hydrated manually by ReferenceDataController: CastMemberModel only - // carries a PersonReferenceId, while CastMemberDto needs the person's name/photo joined in from - // person_reference - a join AutoMapper has no repository access to perform. - CreateMap() - .ForMember(x => x.Cast, opt => opt.Ignore()); - CreateMap() - .ForMember(x => x.Cast, opt => opt.Ignore()); - - // AuthorName/ArtistName are ignored here and hydrated manually by ReferenceDataController, same - // reasoning as Cast above: the model only carries a *ReferenceId, the DTO needs the person's name - // joined in from person_reference. - CreateMap() - .ForMember(x => x.AuthorName, opt => opt.Ignore()) - .ForMember(x => x.AuthorImageUrl, opt => opt.Ignore()); - CreateMap(); - CreateMap() - .ForMember(x => x.ArtistName, opt => opt.Ignore()) - .ForMember(x => x.ArtistImageUrl, opt => opt.Ignore()); - } -} diff --git a/src/WebApi/Program.cs b/src/WebApi/Program.cs index 7549a48..3f70bc8 100644 --- a/src/WebApi/Program.cs +++ b/src/WebApi/Program.cs @@ -7,22 +7,36 @@ // adds services to the container builder.Services.AddControllers(opts => { opts.Filters.Add(); }); builder.Services.AddOpenApi(); -builder.Services.AddAutoMapper(config => - { - config.AllowNullDestinationValues = false; - }, - typeof(Program).Assembly); builder.Services.AddHealthChecks(); -// a hosted BackgroundService (e.g. ReferenceSyncBackgroundService) already catches and logs every -// exception it can anticipate, but this is a systemic safety net for whatever it doesn't: by default, -// an unhandled exception escaping a BackgroundService.ExecuteAsync stops the whole host, taking every -// other endpoint down with it - "Ignore" logs it instead and lets the rest of the app keep serving requests. -builder.Services.Configure(opts => - opts.BackgroundServiceExceptionBehavior = Microsoft.Extensions.Hosting.BackgroundServiceExceptionBehavior.Ignore); +// a hosted BackgroundService (e.g. ReferenceSyncBackgroundService) already catches and logs every exception it can anticipate, +// but this is a systemic safety net for whatever it doesn't: by default, an unhandled exception escaping a BackgroundService.ExecuteAsync stops the whole host, +// taking every other endpoint down with it - "Ignore" logs it instead and lets the rest of the app keep serving requests. +builder.Services.Configure(opts => + opts.BackgroundServiceExceptionBehavior = BackgroundServiceExceptionBehavior.Ignore); builder.Services.AddSingleton(); builder.Services.AddSingleton(); builder.Services.AddSingleton(); builder.Services.AddSingleton(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.BookDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.CarDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.CarHistoryDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.HouseDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.HouseHistoryDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.EpisodeDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.MovieDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.AlbumDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.TvShowDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.SongDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.PlaylistDtoMapper>(); +builder.Services.AddSingleton, Keeptrack.WebApi.Mappers.VideoGameDtoMapper>(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); builder.Services.AddSingleton>(); builder.Services.AddSingleton>(); builder.Services.AddScoped(); diff --git a/src/WebApi/ReferenceData/ReferenceDataController.cs b/src/WebApi/ReferenceData/ReferenceDataController.cs index 33ff166..dd1b686 100644 --- a/src/WebApi/ReferenceData/ReferenceDataController.cs +++ b/src/WebApi/ReferenceData/ReferenceDataController.cs @@ -3,6 +3,7 @@ using System.Threading.Tasks; using Keeptrack.Domain.Models; using Keeptrack.Domain.Repositories; +using Keeptrack.WebApi.Mappers; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; @@ -17,7 +18,11 @@ namespace Keeptrack.WebApi.ReferenceData; [Authorize] [Route("api/reference-data")] public class ReferenceDataController( - IMapper mapper, + TvShowReferenceDtoMapper tvShowReferenceMapper, + MovieReferenceDtoMapper movieReferenceMapper, + BookReferenceDtoMapper bookReferenceMapper, + VideoGameReferenceDtoMapper videoGameReferenceMapper, + AlbumReferenceDtoMapper albumReferenceMapper, ITvShowReferenceRepository tvShowReferenceRepository, IMovieReferenceRepository movieReferenceRepository, IPersonReferenceRepository personReferenceRepository, @@ -34,7 +39,7 @@ public async Task> GetTvShow(string referenceId var model = await tvShowReferenceRepository.FindByIdAsync(referenceId); if (model is null) return NotFound(); - var dto = mapper.Map(model); + var dto = tvShowReferenceMapper.ToDto(model); dto.Cast = await HydrateCastAsync(model.Cast); return Ok(dto); } @@ -47,7 +52,7 @@ public async Task> GetMovie(string referenceId) var model = await movieReferenceRepository.FindByIdAsync(referenceId); if (model is null) return NotFound(); - var dto = mapper.Map(model); + var dto = movieReferenceMapper.ToDto(model); dto.Cast = await HydrateCastAsync(model.Cast); return Ok(dto); } @@ -60,7 +65,7 @@ public async Task> GetBook(string referenceId) var model = await bookReferenceRepository.FindByIdAsync(referenceId); if (model is null) return NotFound(); - var dto = mapper.Map(model); + var dto = bookReferenceMapper.ToDto(model); (dto.AuthorName, dto.AuthorImageUrl) = await HydratePersonAsync(model.AuthorReferenceId); return Ok(dto); } @@ -71,7 +76,7 @@ public async Task> GetBook(string referenceId) public async Task> GetVideoGame(string referenceId) { var model = await videoGameReferenceRepository.FindByIdAsync(referenceId); - return model is null ? NotFound() : Ok(mapper.Map(model)); + return model is null ? NotFound() : Ok(videoGameReferenceMapper.ToDto(model)); } [HttpGet("albums/{referenceId}")] @@ -82,7 +87,7 @@ public async Task> GetAlbum(string referenceId) var model = await albumReferenceRepository.FindByIdAsync(referenceId); if (model is null) return NotFound(); - var dto = mapper.Map(model); + var dto = albumReferenceMapper.ToDto(model); (dto.ArtistName, dto.ArtistImageUrl) = await HydratePersonAsync(model.ArtistReferenceId); return Ok(dto); } @@ -101,8 +106,8 @@ public async Task> GetAlbum(string referenceId) /// /// Joins the embedded cast list against person_reference to build the fully-hydrated DTO the client - /// renders directly - see for - /// why this can't just be an AutoMapper member mapping. + /// renders directly - see 's Cast ignore for why this + /// can't just be a generated mapper member mapping. /// private async Task> HydrateCastAsync(List cast) { diff --git a/src/WebApi/WebApi.csproj b/src/WebApi/WebApi.csproj index d1d549c..ba09f4a 100644 --- a/src/WebApi/WebApi.csproj +++ b/src/WebApi/WebApi.csproj @@ -11,7 +11,6 @@ - @@ -19,6 +18,7 @@ + diff --git a/src/WebApi/appsettings.json b/src/WebApi/appsettings.json index 37354ea..f481fa5 100644 --- a/src/WebApi/appsettings.json +++ b/src/WebApi/appsettings.json @@ -45,6 +45,6 @@ "OpenApi": { "Title": "Keeptrack Web API", "Description": "REST API for Keeptrack data", - "Version": "v1.1" + "Version": "v2.0" } } diff --git a/test/WebApi.IntegrationTests/Resources/AlbumResourceTest.cs b/test/WebApi.IntegrationTests/Resources/AlbumResourceTest.cs index a4c5402..7405e62 100644 --- a/test/WebApi.IntegrationTests/Resources/AlbumResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/AlbumResourceTest.cs @@ -59,7 +59,7 @@ public async Task AlbumResourceFullCycle_IsOk() public async Task AlbumResourceUpdate_PersistsArtistChange_IsOk() { // regression test for a reported "editing the artist doesn't update the data" bug - full review of - // AlbumDetail.razor/Albums.razor/AlbumApiClient/DataCrudControllerBase/both AutoMapper profiles found + // AlbumDetail.razor/Albums.razor/AlbumApiClient/DataCrudControllerBase/both mapper layers found // no code-level cause (identical shape to Book's Author editing, which isn't reported as broken); this // locks in that a PUT changing only Artist persists correctly end-to-end. await Authenticate(); diff --git a/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs b/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs index e0aa4d1..0edd389 100644 --- a/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs +++ b/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs @@ -49,8 +49,9 @@ public async Task SetReferenceLinkAsync_UpdatesEveryMatchingTenantsShow_ButNotOt // the tenant's own title is replaced with the reference's canonical name, not just the id tenantAResult.Title.Should().Be(canonicalTitle); (await repository.FindOneAsync(tenantBShow.Id!, "reference-link-tenant-b"))!.ReferenceId.Should().Be("reference-123"); - // AutoMapper's AllowNullDestinationValues=false (see Program.cs) means an unset ReferenceId - // round-trips as "" rather than null - BeNullOrEmpty is the correct "still unresolved" check. + // An unset ReferenceId can round-trip as either "" (documents written before the + // AutoMapper -> Mapperly migration) or null (new writes) - BeNullOrEmpty is the correct + // "still unresolved" check that covers both generations. (await repository.FindOneAsync(differentYearShow.Id!, "reference-link-tenant-a"))!.ReferenceId.Should().BeNullOrEmpty(); // a show that already has a link is never clobbered by a later automatic/admin resolution var alreadyLinkedResult = (await repository.FindOneAsync(alreadyLinkedShow.Id!, "reference-link-tenant-c"))!; diff --git a/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs b/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs index 8408b75..491f3b8 100644 --- a/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs +++ b/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs @@ -124,7 +124,7 @@ public async Task UpsertAsync_PersistsANullCreator_AsAnActualBsonNullNotAnEmptyS // in-memory dedup comparison and duplicated an alias on every re-resolve/re-refresh (confirmed // against a real video game reference, RAWG's "God of War", that had accumulated an exact duplicate // this way - see scripts/dedupe-matched-aliases.js). Only a real MongoDB round-trip can catch this; - // a mocked repository never exercises the actual AutoMapper/BSON serialization behavior. + // a mocked repository never exercises the actual mapper/BSON serialization behavior. using var scope = factory.Services.CreateScope(); var repository = scope.ServiceProvider.GetRequiredService(); var title = $"Null Creator Title {Guid.NewGuid()}"; diff --git a/test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj b/test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj index c8f9a64..9326cc0 100644 --- a/test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj +++ b/test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj @@ -12,7 +12,6 @@ - diff --git a/test/WebApi.UnitTests/MappingProfiles/AutoMapperConfigurationTest.cs b/test/WebApi.UnitTests/MappingProfiles/AutoMapperConfigurationTest.cs deleted file mode 100644 index 4f4a23b..0000000 --- a/test/WebApi.UnitTests/MappingProfiles/AutoMapperConfigurationTest.cs +++ /dev/null @@ -1,20 +0,0 @@ -using AutoMapper; -using Microsoft.Extensions.Logging.Abstractions; -using Xunit; - -namespace Keeptrack.WebApi.UnitTests.MappingProfiles; - -[Trait("Category", "UnitTests")] -public class AutoMapperConfigurationTest -{ - [Fact] - public void WebApiAutoMapperProfile_ShouldBeValid() - { - var config = new MapperConfiguration(config => - { - config.AddMaps(typeof(Program).Assembly); - }, NullLoggerFactory.Instance); - - config.AssertConfigurationIsValid(); - } -} From 9282f25f58882d41153a06a5f832de1bb27e6b57 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 16:43:04 +0200 Subject: [PATCH 31/44] Update reusable workflows --- .github/workflows/ci.yaml | 14 ++++++++------ .github/workflows/pkg.yaml | 2 +- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index b827e19..2ad5715 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -4,9 +4,11 @@ on: push: - branches: [ main ] + branches: + - main pull_request: - branches: [ main ] + branches: + - main workflow_dispatch: inputs: run-code-quality: @@ -37,13 +39,13 @@ jobs: markup-lint: name: Markup - uses: devpro/github-workflow-parts/.github/workflows/reusable-markup-lint.yml@c90ba46a93ca90123f57744b47e49c1a73962cea + uses: devpro/github-workflow-parts/.github/workflows/reusable-markup-lint.yml@f9d8c00db1ed723e39cfff6c4c7addc77a23c54d code-quality: name: Code needs: git-check if: needs.git-check.outputs.app_changed == 'true' || (github.event_name == 'workflow_dispatch' && inputs.run-code-quality) - uses: devpro/github-workflow-parts/.github/workflows/reusable-dotnet-quality.yml@c90ba46a93ca90123f57744b47e49c1a73962cea + uses: devpro/github-workflow-parts/.github/workflows/reusable-dotnet-quality.yml@f9d8c00db1ed723e39cfff6c4c7addc77a23c54d with: custom-commands: | ./scripts/mongodb-install.sh @@ -62,7 +64,7 @@ jobs: sonar-organization: ${{ vars.SONAR_ORG }} sonar-project-key: ${{ vars.SONAR_PROJECT_KEY }} sonar-project-name: Keeptrack - workflow-parts-version: c90ba46a93ca90123f57744b47e49c1a73962cea + workflow-parts-version: f9d8c00db1ed723e39cfff6c4c7addc77a23c54d secrets: fossa-api-key: ${{ secrets.FOSSA_API_KEY }} sonar-token: ${{ secrets.SONAR_TOKEN }} @@ -90,7 +92,7 @@ jobs: - name: "Web Api" image-name: "keeptrack-webapi" image-definition: "src/WebApi/Dockerfile" - uses: devpro/github-workflow-parts/.github/workflows/reusable-container-scan.yml@c90ba46a93ca90123f57744b47e49c1a73962cea + uses: devpro/github-workflow-parts/.github/workflows/reusable-container-scan.yml@f9d8c00db1ed723e39cfff6c4c7addc77a23c54d with: image-definition: ${{ matrix.image-definition }} image-name: ${{ matrix.image-name }} diff --git a/.github/workflows/pkg.yaml b/.github/workflows/pkg.yaml index 82d0668..caed832 100644 --- a/.github/workflows/pkg.yaml +++ b/.github/workflows/pkg.yaml @@ -28,7 +28,7 @@ jobs: permissions: id-token: write contents: read - uses: devpro/github-workflow-parts/.github/workflows/reusable-container-publication.yml@c90ba46a93ca90123f57744b47e49c1a73962cea + uses: devpro/github-workflow-parts/.github/workflows/reusable-container-publication.yml@f9d8c00db1ed723e39cfff6c4c7addc77a23c54d with: create-latest: ${{ github.ref_name == 'main' }} image-definition: ${{ matrix.image-definition }} From 892c38fc7d8924bcabeeb03f81c53796802a3ea1 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 17:00:53 +0200 Subject: [PATCH 32/44] Format test classes --- .../Resources/AlbumReferenceRepositoryTest.cs | 13 ++- .../Resources/BookReferenceRepositoryTest.cs | 13 ++- .../PersonReferenceRepositoryTest.cs | 7 +- .../ReferenceDataExportImportTest.cs | 38 ++++++-- .../Resources/RefreshReferenceResourceTest.cs | 25 ++++-- .../Resources/TvShowReferenceLinkingTest.cs | 10 ++- .../TvShowReferenceRepositoryTest.cs | 9 +- .../Resources/TvTimeFixtureZipBuilder.cs | 87 ++++++++++++++----- .../VideoGameReferenceRepositoryTest.cs | 13 ++- .../ReferenceEnrichmentServiceTest.cs | 72 +++++++++++---- 10 files changed, 221 insertions(+), 66 deletions(-) diff --git a/test/WebApi.IntegrationTests/Resources/AlbumReferenceRepositoryTest.cs b/test/WebApi.IntegrationTests/Resources/AlbumReferenceRepositoryTest.cs index 7b3691f..49170c8 100644 --- a/test/WebApi.IntegrationTests/Resources/AlbumReferenceRepositoryTest.cs +++ b/test/WebApi.IntegrationTests/Resources/AlbumReferenceRepositoryTest.cs @@ -28,7 +28,9 @@ public async Task FindByTitleYearAsync_MatchesAnAliasWhoseConfirmedYearDiffersFr var created = await repository.UpsertAsync(new AlbumReferenceModel { - Title = "Canonical Album Title", TitleNormalized = "canonical album title", Year = 2005, + Title = "Canonical Album Title", + TitleNormalized = "canonical album title", + Year = 2005, ExternalIds = new Dictionary { ["discogs"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = alternateTitle.ToLowerInvariant(), Year = 2004, Creator = "some artist" }] }); @@ -55,7 +57,9 @@ public async Task FindByTitleAsync_MatchesAnAlternateTitle_IgnoringYear() var created = await repository.UpsertAsync(new AlbumReferenceModel { - Title = "Canonical Album Title", TitleNormalized = "canonical album title", Year = 2005, + Title = "Canonical Album Title", + TitleNormalized = "canonical album title", + Year = 2005, ExternalIds = new Dictionary { ["discogs"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = alternateTitle.ToLowerInvariant(), Year = 2005, Creator = "some artist" }] }); @@ -82,7 +86,10 @@ public async Task UpsertAsync_AlwaysIncludesTheCanonicalTitleAndYearInMatchedAli var created = await repository.UpsertAsync(new AlbumReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2010, ExternalIds = new Dictionary { ["discogs"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2010, + ExternalIds = new Dictionary { ["discogs"] = "1" } }); try diff --git a/test/WebApi.IntegrationTests/Resources/BookReferenceRepositoryTest.cs b/test/WebApi.IntegrationTests/Resources/BookReferenceRepositoryTest.cs index fc9203e..f552435 100644 --- a/test/WebApi.IntegrationTests/Resources/BookReferenceRepositoryTest.cs +++ b/test/WebApi.IntegrationTests/Resources/BookReferenceRepositoryTest.cs @@ -28,7 +28,9 @@ public async Task FindByTitleYearAsync_MatchesAnAliasWhoseConfirmedYearDiffersFr var created = await repository.UpsertAsync(new BookReferenceModel { - Title = "Canonical Book Title", TitleNormalized = "canonical book title", Year = 2005, + Title = "Canonical Book Title", + TitleNormalized = "canonical book title", + Year = 2005, ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" }, MatchedAliases = [new ReferenceMatchModel { Title = alternateTitle.ToLowerInvariant(), Year = 2004, Creator = "some author" }] }); @@ -55,7 +57,9 @@ public async Task FindByTitleAsync_MatchesAnAlternateTitle_IgnoringYear() var created = await repository.UpsertAsync(new BookReferenceModel { - Title = "Canonical Book Title", TitleNormalized = "canonical book title", Year = 2005, + Title = "Canonical Book Title", + TitleNormalized = "canonical book title", + Year = 2005, ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" }, MatchedAliases = [new ReferenceMatchModel { Title = alternateTitle.ToLowerInvariant(), Year = 2005, Creator = "some author" }] }); @@ -82,7 +86,10 @@ public async Task UpsertAsync_AlwaysIncludesTheCanonicalTitleAndYearInMatchedAli var created = await repository.UpsertAsync(new BookReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2010, ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2010, + ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" } }); try diff --git a/test/WebApi.IntegrationTests/Resources/PersonReferenceRepositoryTest.cs b/test/WebApi.IntegrationTests/Resources/PersonReferenceRepositoryTest.cs index 2144936..cf88603 100644 --- a/test/WebApi.IntegrationTests/Resources/PersonReferenceRepositoryTest.cs +++ b/test/WebApi.IntegrationTests/Resources/PersonReferenceRepositoryTest.cs @@ -27,7 +27,8 @@ public async Task UpsertAsync_ThenFindByExternalIdAsync_RoundTripsAndDeduplicate var created = await repository.UpsertAsync(new PersonReferenceModel { - Name = "Test Actor", ExternalIds = new Dictionary { ["tmdb"] = tmdbId } + Name = "Test Actor", + ExternalIds = new Dictionary { ["tmdb"] = tmdbId } }); try @@ -41,7 +42,9 @@ public async Task UpsertAsync_ThenFindByExternalIdAsync_RoundTripsAndDeduplicate // update the existing document, not create a second one var updated = await repository.UpsertAsync(new PersonReferenceModel { - Id = created.Id, Name = "Test Actor (updated)", ExternalIds = new Dictionary { ["tmdb"] = tmdbId } + Id = created.Id, + Name = "Test Actor (updated)", + ExternalIds = new Dictionary { ["tmdb"] = tmdbId } }); updated.Id.Should().Be(created.Id); diff --git a/test/WebApi.IntegrationTests/Resources/ReferenceDataExportImportTest.cs b/test/WebApi.IntegrationTests/Resources/ReferenceDataExportImportTest.cs index cb1e9fa..2b18309 100644 --- a/test/WebApi.IntegrationTests/Resources/ReferenceDataExportImportTest.cs +++ b/test/WebApi.IntegrationTests/Resources/ReferenceDataExportImportTest.cs @@ -29,7 +29,10 @@ public async Task TvShowReferenceRepository_FindAllAsync_IncludesEveryDocument() var created = await repository.UpsertAsync(new TvShowReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["tmdb"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2020, + ExternalIds = new Dictionary { ["tmdb"] = "1" } }); try @@ -53,7 +56,10 @@ public async Task TvShowReferenceRepository_ReimportingTheSameExportedDocument_I var created = await repository.UpsertAsync(new TvShowReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["tmdb"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2020, + ExternalIds = new Dictionary { ["tmdb"] = "1" } }); try @@ -61,7 +67,10 @@ public async Task TvShowReferenceRepository_ReimportingTheSameExportedDocument_I // simulates re-running an import of a previously exported document: same id, same content await repository.UpsertAsync(new TvShowReferenceModel { - Id = created.Id, Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, + Id = created.Id, + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2020, ExternalIds = new Dictionary { ["tmdb"] = "1" } }); @@ -84,7 +93,10 @@ public async Task MovieReferenceRepository_FindAllAsync_IncludesEveryDocument() var created = await repository.UpsertAsync(new MovieReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["tmdb"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2020, + ExternalIds = new Dictionary { ["tmdb"] = "1" } }); try @@ -108,7 +120,8 @@ public async Task PersonReferenceRepository_FindAllAsync_IncludesEveryDocument() var created = await repository.UpsertAsync(new PersonReferenceModel { - Name = "Export Test Actor", ExternalIds = new Dictionary { ["tmdb"] = tmdbId } + Name = "Export Test Actor", + ExternalIds = new Dictionary { ["tmdb"] = tmdbId } }); try @@ -132,7 +145,10 @@ public async Task BookReferenceRepository_FindAllAsync_IncludesEveryDocument() var created = await repository.UpsertAsync(new BookReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2020, + ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" } }); try @@ -156,7 +172,10 @@ public async Task VideoGameReferenceRepository_FindAllAsync_IncludesEveryDocumen var created = await repository.UpsertAsync(new VideoGameReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["rawg"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2020, + ExternalIds = new Dictionary { ["rawg"] = "1" } }); try @@ -180,7 +199,10 @@ public async Task AlbumReferenceRepository_FindAllAsync_IncludesEveryDocument() var created = await repository.UpsertAsync(new AlbumReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2020, ExternalIds = new Dictionary { ["discogs"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2020, + ExternalIds = new Dictionary { ["discogs"] = "1" } }); try diff --git a/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs b/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs index 3781036..9fd0954 100644 --- a/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs +++ b/test/WebApi.IntegrationTests/Resources/RefreshReferenceResourceTest.cs @@ -33,7 +33,10 @@ public async Task RefreshReference_LinksTvShow_WhenAnExistingReferenceMatchesByT var reference = await referenceRepository.UpsertAsync(new TvShowReferenceModel { - Title = "Canonical Title", TitleNormalized = "canonical title", Year = year, ExternalIds = new Dictionary { ["tmdb"] = "1" }, + Title = "Canonical Title", + TitleNormalized = "canonical title", + Year = year, + ExternalIds = new Dictionary { ["tmdb"] = "1" }, // the reference is only found by the show's own (title, year) via its aliases - a real reference // resolved from this show would carry exactly this alias (see MatchedAliases / TryLinkExisting...) MatchedAliases = [new ReferenceMatchModel { Title = TitleNormalizer.Normalize(title), Year = year }] @@ -85,7 +88,10 @@ public async Task RefreshReference_LinksMovie_WhenAnExistingReferenceMatchesByTi var reference = await referenceRepository.UpsertAsync(new MovieReferenceModel { - Title = "Canonical Movie Title", TitleNormalized = "canonical movie title", Year = year, ExternalIds = new Dictionary { ["tmdb"] = "1" }, + Title = "Canonical Movie Title", + TitleNormalized = "canonical movie title", + Year = year, + ExternalIds = new Dictionary { ["tmdb"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = TitleNormalizer.Normalize(title), Year = year }] }); @@ -116,7 +122,10 @@ public async Task RefreshReference_LinksBook_WhenAnExistingReferenceMatchesByTit var reference = await referenceRepository.UpsertAsync(new BookReferenceModel { - Title = "Canonical Book Title", TitleNormalized = "canonical book title", Year = year, ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" }, + Title = "Canonical Book Title", + TitleNormalized = "canonical book title", + Year = year, + ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" }, // book/album aliases also carry the normalized creator - the lookup matches title+year+creator MatchedAliases = [new ReferenceMatchModel { Title = TitleNormalizer.Normalize(title), Year = year, Creator = TitleNormalizer.Normalize("Some Author") }] }); @@ -148,7 +157,10 @@ public async Task RefreshReference_LinksVideoGame_WhenAnExistingReferenceMatches var reference = await referenceRepository.UpsertAsync(new VideoGameReferenceModel { - Title = "Canonical Game Title", TitleNormalized = "canonical game title", Year = year, ExternalIds = new Dictionary { ["rawg"] = "1" }, + Title = "Canonical Game Title", + TitleNormalized = "canonical game title", + Year = year, + ExternalIds = new Dictionary { ["rawg"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = TitleNormalizer.Normalize(title), Year = year }] }); @@ -179,7 +191,10 @@ public async Task RefreshReference_LinksAlbum_WhenAnExistingReferenceMatchesByTi var reference = await referenceRepository.UpsertAsync(new AlbumReferenceModel { - Title = "Canonical Album Title", TitleNormalized = "canonical album title", Year = year, ExternalIds = new Dictionary { ["discogs"] = "1" }, + Title = "Canonical Album Title", + TitleNormalized = "canonical album title", + Year = year, + ExternalIds = new Dictionary { ["discogs"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = TitleNormalizer.Normalize(title), Year = year, Creator = TitleNormalizer.Normalize("Some Artist") }] }); diff --git a/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs b/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs index 0edd389..b3565bf 100644 --- a/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs +++ b/test/WebApi.IntegrationTests/Resources/TvShowReferenceLinkingTest.cs @@ -36,7 +36,10 @@ public async Task SetReferenceLinkAsync_UpdatesEveryMatchingTenantsShow_ButNotOt var differentYearShow = await repository.CreateAsync(new TvShowModel { OwnerId = "reference-link-tenant-a", Title = title, Year = year + 1 }); var alreadyLinkedShow = await repository.CreateAsync(new TvShowModel { - OwnerId = "reference-link-tenant-c", Title = title, Year = year, ReferenceId = "pre-existing-link" + OwnerId = "reference-link-tenant-c", + Title = title, + Year = year, + ReferenceId = "pre-existing-link" }); try @@ -78,7 +81,10 @@ public async Task FindDistinctUnresolvedTitleYearsAsync_ReturnsDistinctUnlinkedT var showB = await repository.CreateAsync(new TvShowModel { OwnerId = "unresolved-tenant-b", Title = title, Year = 2022 }); var linkedShow = await repository.CreateAsync(new TvShowModel { - OwnerId = "unresolved-tenant-c", Title = title, Year = 2022, ReferenceId = "already-linked" + OwnerId = "unresolved-tenant-c", + Title = title, + Year = 2022, + ReferenceId = "already-linked" }); try diff --git a/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs b/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs index 491f3b8..cc8e4d4 100644 --- a/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs +++ b/test/WebApi.IntegrationTests/Resources/TvShowReferenceRepositoryTest.cs @@ -131,7 +131,9 @@ public async Task UpsertAsync_PersistsANullCreator_AsAnActualBsonNullNotAnEmptyS var created = await repository.UpsertAsync(new TvShowReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2010, + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2010, ExternalIds = new Dictionary { ["tmdb"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = title.ToLowerInvariant(), Year = 2010, Creator = null }] }); @@ -158,7 +160,10 @@ public async Task UpsertAsync_AlwaysIncludesTheCanonicalTitleAndYearInMatchedAli var created = await repository.UpsertAsync(new TvShowReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2010, ExternalIds = new Dictionary { ["tmdb"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2010, + ExternalIds = new Dictionary { ["tmdb"] = "1" } }); try diff --git a/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs b/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs index 878347b..39f14d2 100644 --- a/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs +++ b/test/WebApi.IntegrationTests/Resources/TvTimeFixtureZipBuilder.cs @@ -50,21 +50,37 @@ public static byte[] Build() "watched_episode_range_key", "watch_date_range_key", "unitarian"], new Dictionary { - ["series_name"] = ShowTitle, ["uuid"] = "aaaa", ["type-uuid-n"] = "count-watch-episode-series-aaaa", - ["type"] = "count-watch-episode-series", ["created_at"] = "2020-01-04 00:00:00", ["series_id"] = "999001", ["user_id"] = "999" + ["series_name"] = ShowTitle, + ["uuid"] = "aaaa", + ["type-uuid-n"] = "count-watch-episode-series-aaaa", + ["type"] = "count-watch-episode-series", + ["created_at"] = "2020-01-04 00:00:00", + ["series_id"] = "999001", + ["user_id"] = "999" }, new Dictionary { - ["series_name"] = ShowTitle, ["uuid"] = "bbbb", ["type-uuid-n"] = "watch-bbbb-0", ["type"] = "watch", - ["created_at"] = "2020-01-04 00:00:00", ["series_id"] = "999001", ["user_id"] = "999", ["entity_type"] = "episode", - ["season_number"] = "1", ["episode_number"] = "3" + ["series_name"] = ShowTitle, + ["uuid"] = "bbbb", + ["type-uuid-n"] = "watch-bbbb-0", + ["type"] = "watch", + ["created_at"] = "2020-01-04 00:00:00", + ["series_id"] = "999001", + ["user_id"] = "999", + ["entity_type"] = "episode", + ["season_number"] = "1", + ["episode_number"] = "3" }, // movie watch event: the only source of a movie's watched date (confirmed against a real // export - the rating/emotion vote files never carry one) new Dictionary { - ["uuid"] = "movie-watch-1", ["type"] = "watch", ["created_at"] = "2020-01-07 00:00:00", - ["user_id"] = "999", ["movie_name"] = MovieTitle, ["entity_type"] = "movie" + ["uuid"] = "movie-watch-1", + ["type"] = "watch", + ["created_at"] = "2020-01-07 00:00:00", + ["user_id"] = "999", + ["movie_name"] = MovieTitle, + ["entity_type"] = "movie" }), ["tracking-prod-records-v2.csv"] = BuildCsv( ["s_id", "user_id", "episode_id", "series_name", "gsi", "runtime", "created_at", "season_number", "episode_number", @@ -73,22 +89,45 @@ public static byte[] Build() "uuid", "followed_at", "is_archived", "is_unitary", "rewatch_count", "bulk_type", "is_special"], new Dictionary { - ["s_id"] = "999001", ["user_id"] = "999", ["series_name"] = ShowTitle, ["created_at"] = "2020-01-01 00:00:00", - ["key"] = "user-series-999001", ["ep_watch_count"] = "4", ["updated_at"] = "2020-01-05 00:00:00", ["is_followed"] = "true", - ["uuid"] = "999001-summary", ["is_archived"] = "false" + ["s_id"] = "999001", + ["user_id"] = "999", + ["series_name"] = ShowTitle, + ["created_at"] = "2020-01-01 00:00:00", + ["key"] = "user-series-999001", + ["ep_watch_count"] = "4", + ["updated_at"] = "2020-01-05 00:00:00", + ["is_followed"] = "true", + ["uuid"] = "999001-summary", + ["is_archived"] = "false" }, new Dictionary { - ["s_id"] = "999001", ["user_id"] = "999", ["episode_id"] = "4", ["series_name"] = ShowTitle, - ["gsi"] = "watch-episode-1578182400", ["created_at"] = "2020-01-05 00:00:00", ["season_number"] = "2", - ["episode_number"] = "1", ["key"] = "watch-episode-999001-cccc", ["updated_at"] = "2020-01-05 00:00:00", ["is_unitary"] = "true" + ["s_id"] = "999001", + ["user_id"] = "999", + ["episode_id"] = "4", + ["series_name"] = ShowTitle, + ["gsi"] = "watch-episode-1578182400", + ["created_at"] = "2020-01-05 00:00:00", + ["season_number"] = "2", + ["episode_number"] = "1", + ["key"] = "watch-episode-999001-cccc", + ["updated_at"] = "2020-01-05 00:00:00", + ["is_unitary"] = "true" }, // OrphanShowTitle: deliberately has NO row in followed_tv_show.csv new Dictionary { - ["s_id"] = "999003", ["user_id"] = "999", ["episode_id"] = "5", ["series_name"] = OrphanShowTitle, - ["gsi"] = "watch-episode-1578268800", ["created_at"] = "2020-01-06 00:00:00", ["season_number"] = "1", - ["episode_number"] = "1", ["key"] = "watch-episode-999003-dddd", ["updated_at"] = "2020-01-06 00:00:00", ["is_unitary"] = "true" + ["s_id"] = "999003", + ["user_id"] = "999", + ["episode_id"] = "5", + ["series_name"] = OrphanShowTitle, + ["gsi"] = "watch-episode-1578268800", + ["created_at"] = "2020-01-06 00:00:00", + ["season_number"] = "1", + ["episode_number"] = "1", + ["key"] = "watch-episode-999003-dddd", + ["updated_at"] = "2020-01-06 00:00:00", + ["is_unitary"] = "true" }), ["user_tv_show_data.csv"] = $""" user_id,tv_show_id,is_followed,is_favorited,nb_episodes_seen,tv_show_name @@ -99,13 +138,21 @@ public static byte[] Build() ["created_at", "updated_at", "tv_show_name", "user_id", "tv_show_id", "rating"], new Dictionary { - ["created_at"] = "2020-01-01 00:00:00", ["updated_at"] = "2020-01-01 00:00:00", ["tv_show_name"] = ShowTitle, - ["user_id"] = "999", ["tv_show_id"] = "999001", ["rating"] = "4.5" + ["created_at"] = "2020-01-01 00:00:00", + ["updated_at"] = "2020-01-01 00:00:00", + ["tv_show_name"] = ShowTitle, + ["user_id"] = "999", + ["tv_show_id"] = "999001", + ["rating"] = "4.5" }, new Dictionary { - ["created_at"] = "2020-01-06 00:00:00", ["updated_at"] = "2020-01-06 00:00:00", ["tv_show_name"] = OrphanShowTitle, - ["user_id"] = "999", ["tv_show_id"] = "999003", ["rating"] = "3.5" + ["created_at"] = "2020-01-06 00:00:00", + ["updated_at"] = "2020-01-06 00:00:00", + ["tv_show_name"] = OrphanShowTitle, + ["user_id"] = "999", + ["tv_show_id"] = "999003", + ["rating"] = "3.5" }), ["user_show_special_status.csv"] = $""" created_at,updated_at,tv_show_name,user_id,tv_show_id,status diff --git a/test/WebApi.IntegrationTests/Resources/VideoGameReferenceRepositoryTest.cs b/test/WebApi.IntegrationTests/Resources/VideoGameReferenceRepositoryTest.cs index 9cba0d6..c6e266d 100644 --- a/test/WebApi.IntegrationTests/Resources/VideoGameReferenceRepositoryTest.cs +++ b/test/WebApi.IntegrationTests/Resources/VideoGameReferenceRepositoryTest.cs @@ -28,7 +28,9 @@ public async Task FindByTitleYearAsync_MatchesAnAliasWhoseConfirmedYearDiffersFr var created = await repository.UpsertAsync(new VideoGameReferenceModel { - Title = "Canonical Game Title", TitleNormalized = "canonical game title", Year = 2005, + Title = "Canonical Game Title", + TitleNormalized = "canonical game title", + Year = 2005, ExternalIds = new Dictionary { ["rawg"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = alternateTitle.ToLowerInvariant(), Year = 2004 }] }); @@ -55,7 +57,9 @@ public async Task FindByTitleAsync_MatchesAnAlternateTitle_IgnoringYear() var created = await repository.UpsertAsync(new VideoGameReferenceModel { - Title = "Canonical Game Title", TitleNormalized = "canonical game title", Year = 2005, + Title = "Canonical Game Title", + TitleNormalized = "canonical game title", + Year = 2005, ExternalIds = new Dictionary { ["rawg"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = alternateTitle.ToLowerInvariant(), Year = 2005 }] }); @@ -82,7 +86,10 @@ public async Task UpsertAsync_AlwaysIncludesTheCanonicalTitleAndYearInMatchedAli var created = await repository.UpsertAsync(new VideoGameReferenceModel { - Title = title, TitleNormalized = title.ToLowerInvariant(), Year = 2010, ExternalIds = new Dictionary { ["rawg"] = "1" } + Title = title, + TitleNormalized = title.ToLowerInvariant(), + Year = 2010, + ExternalIds = new Dictionary { ["rawg"] = "1" } }); try diff --git a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs index 11730d1..70e0501 100644 --- a/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs +++ b/test/WebApi.UnitTests/ReferenceData/ReferenceEnrichmentServiceTest.cs @@ -104,7 +104,10 @@ public async Task ResolveTvShowAsync_ReusesTheSameReferenceByTmdbId_EvenWhenTitl .Setup(r => r.FindByExternalIdAsync("tmdb", "42")) .ReturnsAsync(new TvShowReferenceModel { - Id = "reference-1", Title = "The Wire", TitleNormalized = "the wire", ExternalIds = new Dictionary { ["tmdb"] = "42" }, + Id = "reference-1", + Title = "The Wire", + TitleNormalized = "the wire", + ExternalIds = new Dictionary { ["tmdb"] = "42" }, MatchedAliases = [new ReferenceMatchModel { Title = "the wire", Year = 2002 }] }); _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); @@ -143,7 +146,10 @@ public async Task ResolveTvShowAsync_PreservesPreviouslyKnownMatchedAliases_When .Setup(r => r.FindByTitleYearAsync("Le Fil", 2002)) .ReturnsAsync(new TvShowReferenceModel { - Id = "reference-1", Title = "The Wire", TitleNormalized = "the wire", ExternalIds = [], + Id = "reference-1", + Title = "The Wire", + TitleNormalized = "the wire", + ExternalIds = [], MatchedAliases = [new ReferenceMatchModel { Title = "the wire", Year = 2002 }, new ReferenceMatchModel { Title = "il filo", Year = 2001 }] }); _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); @@ -368,8 +374,11 @@ public async Task RefreshTvShowReferenceAsync_OnlyBumpsLastEnrichedAt_WhenTmdbRe var lastEnrichedAt = DateTime.UtcNow.AddDays(-5); var reference = new TvShowReferenceModel { - Id = "reference-1", Title = "Some Show", TitleNormalized = "some show", - ExternalIds = new Dictionary { ["tmdb"] = "42" }, LastEnrichedAt = lastEnrichedAt + Id = "reference-1", + Title = "Some Show", + TitleNormalized = "some show", + ExternalIds = new Dictionary { ["tmdb"] = "42" }, + LastEnrichedAt = lastEnrichedAt }; _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); var service = CreateService(tmdbClient); @@ -390,8 +399,11 @@ public async Task RefreshTvShowReferenceAsync_RefetchesDetails_WhenTmdbReportsCh tmdbClient.TvShowDetails["42"] = new TmdbTvShowDetails("42", "Some Show - Updated", 2020, "New synopsis", [], ["Drama"], null); var reference = new TvShowReferenceModel { - Id = "reference-1", Title = "Some Show", TitleNormalized = "some show", - ExternalIds = new Dictionary { ["tmdb"] = "42" }, LastEnrichedAt = DateTime.UtcNow.AddDays(-5) + Id = "reference-1", + Title = "Some Show", + TitleNormalized = "some show", + ExternalIds = new Dictionary { ["tmdb"] = "42" }, + LastEnrichedAt = DateTime.UtcNow.AddDays(-5) }; _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); var service = CreateService(tmdbClient); @@ -412,8 +424,11 @@ public async Task RefreshTvShowReferenceAsync_RefetchesDetails_WhenNeverPrevious tmdbClient.TvShowDetails["42"] = new TmdbTvShowDetails("42", "Some Show", 2020, "Synopsis", [], [], null); var reference = new TvShowReferenceModel { - Id = "reference-1", Title = "Some Show", TitleNormalized = "some show", - ExternalIds = new Dictionary { ["tmdb"] = "42" }, LastEnrichedAt = null + Id = "reference-1", + Title = "Some Show", + TitleNormalized = "some show", + ExternalIds = new Dictionary { ["tmdb"] = "42" }, + LastEnrichedAt = null }; _tvShowReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((TvShowReferenceModel m) => m); var service = CreateService(tmdbClient); @@ -571,8 +586,11 @@ public async Task RefreshBookReferenceAsync_AlwaysRefetches_RegardlessOfLastEnri bookReferenceClient.Details["OL1W"] = new BookDetails("OL1W", "Some Book - Updated", 2020, "New synopsis", "Some Author", "OL1A", ["Fiction"], null); var reference = new BookReferenceModel { - Id = "reference-1", Title = "Some Book", TitleNormalized = "some book", - ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" }, LastEnrichedAt = DateTime.UtcNow + Id = "reference-1", + Title = "Some Book", + TitleNormalized = "some book", + ExternalIds = new Dictionary { ["openlibrary"] = "OL1W" }, + LastEnrichedAt = DateTime.UtcNow }; _bookReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((BookReferenceModel m) => m); _personReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((PersonReferenceModel m) => { m.Id ??= "person-1"; return m; }); @@ -632,7 +650,10 @@ public async Task TryLinkExistingVideoGameReferenceAsync_LinksAndUpdatesTitle_On var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); var model = new VideoGameModel { - Id = "game-1", OwnerId = "owner", Title = "Some Typo'd Game", Year = 2020, + Id = "game-1", + OwnerId = "owner", + Title = "Some Typo'd Game", + Year = 2020, Platforms = [new VideoGamePlatformModel { Platform = "PC", State = "Current" }] }; _videoGameReferenceRepository @@ -653,7 +674,10 @@ public async Task TryLinkExistingVideoGameReferenceAsync_UpdatesYearToTheReferen var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); var model = new VideoGameModel { - Id = "game-1", OwnerId = "owner", Title = "Some Game", Year = 2019, + Id = "game-1", + OwnerId = "owner", + Title = "Some Game", + Year = 2019, Platforms = [new VideoGamePlatformModel { Platform = "PC", State = "Current" }] }; _videoGameReferenceRepository @@ -672,7 +696,11 @@ public async Task TryLinkExistingVideoGameReferenceAsync_Unlinks_WhenAlreadyLink var service = CreateService(FakeTmdbClient.WithTvShowSearchResults()); var model = new VideoGameModel { - Id = "game-1", OwnerId = "owner", Title = "Some Game", Year = 2020, ReferenceId = "old-reference", + Id = "game-1", + OwnerId = "owner", + Title = "Some Game", + Year = 2020, + ReferenceId = "old-reference", Platforms = [new VideoGamePlatformModel { Platform = "PC", State = "Current" }] }; _videoGameReferenceRepository.Setup(r => r.FindByTitleYearAsync("Some Game", 2020)).ReturnsAsync((VideoGameReferenceModel?)null); @@ -706,8 +734,11 @@ public async Task RefreshVideoGameReferenceAsync_AlwaysRefetches_RegardlessOfLas rawgClient.Details["1"] = new RawgGameDetails("1", "Some Game - Updated", 2020, "New synopsis", ["Action"], ["PC"], null); var reference = new VideoGameReferenceModel { - Id = "reference-1", Title = "Some Game", TitleNormalized = "some game", - ExternalIds = new Dictionary { ["rawg"] = "1" }, LastEnrichedAt = DateTime.UtcNow + Id = "reference-1", + Title = "Some Game", + TitleNormalized = "some game", + ExternalIds = new Dictionary { ["rawg"] = "1" }, + LastEnrichedAt = DateTime.UtcNow }; _videoGameReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((VideoGameReferenceModel m) => m); var service = CreateService(FakeTmdbClient.WithTvShowSearchResults(), rawgClient: rawgClient); @@ -735,7 +766,9 @@ public async Task RefreshVideoGameReferenceAsync_DoesNotDuplicateAnAliasAlreadyP rawgClient.Details["1"] = new RawgGameDetails("1", "Some Game", 2020, "Synopsis", ["Action"], ["PC"], null); var reference = new VideoGameReferenceModel { - Id = "reference-1", Title = "Some Game", TitleNormalized = "some game", + Id = "reference-1", + Title = "Some Game", + TitleNormalized = "some game", ExternalIds = new Dictionary { ["rawg"] = "1" }, MatchedAliases = [new ReferenceMatchModel { Title = "some game", Year = 2020, Creator = null }] }; @@ -895,8 +928,11 @@ public async Task RefreshAlbumReferenceAsync_AlwaysRefetches_RegardlessOfLastEnr [new DiscogsTrack("1", "Intro", "0:22"), new DiscogsTrack("2", "Apocalypse Please", "4:12")]); var reference = new AlbumReferenceModel { - Id = "reference-1", Title = "Some Album", TitleNormalized = "some album", - ExternalIds = new Dictionary { ["discogs"] = "1" }, LastEnrichedAt = DateTime.UtcNow + Id = "reference-1", + Title = "Some Album", + TitleNormalized = "some album", + ExternalIds = new Dictionary { ["discogs"] = "1" }, + LastEnrichedAt = DateTime.UtcNow }; _albumReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((AlbumReferenceModel m) => m); _personReferenceRepository.Setup(r => r.UpsertAsync(It.IsAny())).ReturnsAsync((PersonReferenceModel m) => { m.Id ??= "person-1"; return m; }); From 185c123aad9c82e8be6deb03bd9dae5e1ab604f9 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 17:12:14 +0200 Subject: [PATCH 33/44] Updates --- CLAUDE.md | 16 +++--- CONTRIBUTING.md | 12 ++--- Keeptrack.slnx | 5 ++ docs/backlog.md | 3 ++ scripts/align_table.js | 35 ++++++++++++ .../Components/Shared/SvgChartHelpers.cs | 54 ++++++++++--------- 6 files changed, 85 insertions(+), 40 deletions(-) create mode 100644 docs/backlog.md create mode 100644 scripts/align_table.js diff --git a/CLAUDE.md b/CLAUDE.md index 22e389a..29f7b75 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -52,14 +52,14 @@ Integration tests also need Firebase test-user credentials and MongoDB connectio The solution follows a layered / clean-architecture style split across small, single-purpose projects (`src/*`), with `Domain` at the center and no project referencing "outward": -| Project | Depends on | Responsibility | -|---|---|---| -| `Common.System` | — | Cross-cutting primitives shared by every layer: `IHasId`, `IHasIdAndOwnerId`, `PagedRequest`, `PagedResult`. | -| `Domain` | `Common.System` | Business models (`*Model` in `Models/`) and repository interfaces (`I*Repository` in `Repositories/`). No persistence or web concerns. | -| `Infrastructure.MongoDb` | `Domain` | MongoDB implementation: BSON `Entities/` and `Repositories/` implementing the `Domain` interfaces. | -| `WebApi.Contracts` | `Common.System` | Public REST DTOs (`Dto/`), shared between `WebApi` and `BlazorApp` so the Blazor client can deserialize API responses without duplicating classes. | -| `WebApi` | `Infrastructure.MongoDb`, `Domain`, `WebApi.Contracts` | ASP.NET Web API: controllers, DTO mappers, DI wiring, JWT authentication, OpenAPI/Scalar docs. | -| `BlazorApp` | `Common.System`, `WebApi.Contracts` | Blazor Server UI. Talks to `WebApi` over HTTP using the shared DTOs; it never references `Domain` or `Infrastructure.MongoDb` directly. | +Project | Depends on | Responsibility +-------------------------|--------------------------------------------------------|--------------- +`Common.System` | — | Cross-cutting primitives shared by every layer: `IHasId`, `IHasIdAndOwnerId`, `PagedRequest`, `PagedResult`. +`Domain` | `Common.System` | Business models (`*Model` in `Models/`) and repository interfaces (`I*Repository` in `Repositories/`). No persistence or web concerns. +`Infrastructure.MongoDb` | `Domain` | MongoDB implementation: BSON `Entities/` and `Repositories/` implementing the `Domain` interfaces. +`WebApi.Contracts` | `Common.System` | Public REST DTOs (`Dto/`), shared between `WebApi` and `BlazorApp` so the Blazor client can deserialize API responses without duplicating classes. +`WebApi` | `Infrastructure.MongoDb`, `Domain`, `WebApi.Contracts` | ASP.NET Web API: controllers, DTO mappers, DI wiring, JWT authentication, OpenAPI/Scalar docs. +`BlazorApp` | `Common.System`, `WebApi.Contracts` | Blazor Server UI. Talks to `WebApi` over HTTP using the shared DTOs; it never references `Domain` or `Infrastructure.MongoDb` directly. ### Data model conventions diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index ab271d8..d2d44ca 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -139,12 +139,12 @@ Template for `src/WebApi/appsettings.Development.json`: Episode titles, synopses, cover art, and the "what should I watch next" experience are backed by shared reference collections, one per trackable type, each populated from a different external provider rather than typed in by hand: -Type | Provider | Setting | API key required? -------------|-------------------------------------------------|---------------------|------------------- -TV shows / Movies | [TMDB](https://www.themoviedb.org/) (The Movie Database) | `Tmdb:ApiKey` | Yes -Books | [Open Library](https://openlibrary.org/) | *(none)* | No -Video Games | [RAWG](https://rawg.io/apidocs) | `Rawg:ApiKey` | Yes -Albums | [Discogs](https://www.discogs.com/developers) | `Discogs:Token` | Yes (personal access token) +Type | Provider | Setting | API key required? +------------------|----------------------------------------------------------|-----------------|------------------ +TV shows / Movies | [TMDB](https://www.themoviedb.org/) (The Movie Database) | `Tmdb:ApiKey` | Yes +Books | [Open Library](https://openlibrary.org/) | *(none)* | No +Video Games | [RAWG](https://rawg.io/apidocs) | `Rawg:ApiKey` | Yes +Albums | [Discogs](https://www.discogs.com/developers) | `Discogs:Token` | Yes (personal access token) 1. **TMDB**: create a free account, then generate a v3 API key at [themoviedb.org/settings/api](https://www.themoviedb.org/settings/api). Set `Tmdb:ApiKey` (or the `Tmdb__ApiKey` environment variable) to that key. diff --git a/Keeptrack.slnx b/Keeptrack.slnx index 65f7fe4..ebaf128 100644 --- a/Keeptrack.slnx +++ b/Keeptrack.slnx @@ -13,6 +13,7 @@ + @@ -29,7 +30,11 @@ + + + + diff --git a/docs/backlog.md b/docs/backlog.md new file mode 100644 index 0000000..fef8848 --- /dev/null +++ b/docs/backlog.md @@ -0,0 +1,3 @@ +# Backlog + +- Review SvgChartHelpers to remove "pragma warning disable ASP0006". diff --git a/scripts/align_table.js b/scripts/align_table.js new file mode 100644 index 0000000..90513d9 --- /dev/null +++ b/scripts/align_table.js @@ -0,0 +1,35 @@ +// Reformats a pipe-delimited table (no leading/trailing "|") into a +// column-aligned Markdown table whose delimiter row lines up exactly with +// the header/data pipes, satisfying markdownlint's MD060 (table-column-style). +// +// Usage: node scripts/align_table.js where columns are separated +// by " | " on the first (header) line, and rows are separated by " | " too. +// Prints the reformatted table to stdout. + +function buildTable(rows) { + const ncols = rows[0].length; + const widths = new Array(ncols).fill(0); + for (const row of rows) { + for (let i = 0; i < ncols; i++) { + widths[i] = Math.max(widths[i], row[i].length); + } + } + const formatRow = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join(' | ').replace(/\s+$/, ''); + const header = formatRow(rows[0]); + const separator = header.replace(/[^|]/g, '-'); + const lines = [header, separator, ...rows.slice(1).map(formatRow)]; + return lines.join('\n'); +} + +const fs = require('fs'); +const path = process.argv[2]; +if (!path) { + console.error('Usage: node scripts/align_table.js '); + process.exit(1); +} +const rows = fs + .readFileSync(path, 'utf8') + .split('\n') + .filter((l) => l.trim().length > 0) + .map((l) => l.split(' | ').map((c) => c.trim())); +console.log(buildTable(rows)); diff --git a/src/BlazorApp/Components/Shared/SvgChartHelpers.cs b/src/BlazorApp/Components/Shared/SvgChartHelpers.cs index ce33fe4..487351a 100644 --- a/src/BlazorApp/Components/Shared/SvgChartHelpers.cs +++ b/src/BlazorApp/Components/Shared/SvgChartHelpers.cs @@ -3,36 +3,35 @@ namespace Keeptrack.BlazorApp.Components.Shared; /// -/// Shared SVG axis-drawing primitives for the app's hand-rolled charts (no charting library dependency for a -/// handful of small trend/bar charts). Extracted from CarDetail.razor so HouseDetail.razor's own -/// yearly cost chart doesn't duplicate the same axis geometry/arrow-marker/tick-label algorithm. Deliberately -/// limited to just axis/geometry, not the per-chart series-drawing code (line vs. bar, single vs. stacked -/// series) - that part differs enough between consumers that it stays with each page rather than being forced -/// into one over-generalized shared renderer. +/// Shared SVG axis-drawing primitives for the app's hand-rolled charts (no charting library dependency for a handful of small trend/bar charts). +/// Extracted from CarDetail.razor so HouseDetail.razor's own yearly cost chart doesn't duplicate the same axis geometry/arrow-marker/tick-label algorithm. +/// Deliberately limited to just axis/geometry, not the per-chart series-drawing code (line vs. bar, single vs. stacked series) - +/// that part differs enough between consumers that it stays with each page rather than being forced into one over-generalized shared renderer. /// public static class SvgChartHelpers { /// - /// Plot geometry for one chart. Not every chart shares a single fixed viewBox: a chart rendered at full - /// row width needs a proportionally wider viewBox than a half-width one - matching ViewWidth to actual - /// on-screen width keeps the rendered scale (and therefore axis text/arrow/tick size) the same across - /// every chart instead of the wider ones blowing up. + /// Plot geometry for one chart. + /// Not every chart shares a single fixed viewBox: a chart rendered at full row width needs a proportionally wider viewBox than a half-width one - + /// matching ViewWidth to actual on-screen width keeps the rendered scale (and therefore axis text/arrow/tick size) the same across every chart instead of the wider ones blowing up. /// public readonly record struct ChartGeometry(double ViewWidth, double ViewHeight, double PlotLeft, double PlotRight, double PlotTop, double PlotBottom); public static readonly ChartGeometry HalfWidthGeometry = new(ViewWidth: 300, ViewHeight: 170, PlotLeft: 40, PlotRight: 288, PlotTop: 14, PlotBottom: 132); public static readonly ChartGeometry FullWidthGeometry = new(ViewWidth: 600, ViewHeight: 170, PlotLeft: 40, PlotRight: 588, PlotTop: 14, PlotBottom: 132); - /// Draws a graduated X/Y axis pair (arrowhead, tick marks, tick labels, axis title). Ticks are - /// computed by the caller, since what counts as an evenly-spaced value differs between a continuous line - /// chart and a per-bar categorical one. The Y-axis title is a plain horizontal caption above the axis - /// rather than rotated sideways along it - fine for a multi-word label like "L/100km", but a rotated - /// single glyph like "€" reads as a completely different, garbled character, not a sideways euro sign. + /// + /// Draws a graduated X/Y axis pair (arrowhead, tick marks, tick labels, axis title). + /// Ticks are computed by the caller, since what counts as an evenly-spaced value differs between a continuous line chart and a per-bar categorical one. + /// The Y-axis title is a plain horizontal caption above the axis rather than rotated sideways along it - + /// fine for a multi-word label like "L/100km", but a rotated single glyph like "€" reads as a completely different, garbled character, not a sideways euro sign. + /// +#pragma warning disable ASP0006 public static void RenderAxes( RenderTreeBuilder builder, ref int seq, ChartGeometry geometry, string markerId, string xAxisLabel, string yAxisLabel, IReadOnlyList<(double Y, string Label)> yTicks, IReadOnlyList<(double X, string Label)> xTicks) { - const string axisColor = "var(--kt-text-muted)"; + const string AxisColor = "var(--kt-text-muted)"; var (_, viewHeight, plotLeft, plotRight, plotTop, plotBottom) = geometry; builder.OpenElement(seq++, "defs"); @@ -46,30 +45,30 @@ public static void RenderAxes( builder.AddAttribute(seq++, "orient", "auto-start-reverse"); builder.OpenElement(seq++, "path"); builder.AddAttribute(seq++, "d", "M0,0 L8,4 L0,8 Z"); - builder.AddAttribute(seq++, "fill", axisColor); + builder.AddAttribute(seq++, "fill", AxisColor); builder.CloseElement(); builder.CloseElement(); builder.CloseElement(); - // Y axis: drawn bottom-to-top so the arrowhead (marker-end) points up. + // Y-axis: drawn bottom-to-top so the arrowhead (marker-end) points up. builder.OpenElement(seq++, "line"); builder.AddAttribute(seq++, "x1", plotLeft.ToString("F1")); builder.AddAttribute(seq++, "y1", plotBottom.ToString("F1")); builder.AddAttribute(seq++, "x2", plotLeft.ToString("F1")); builder.AddAttribute(seq++, "y2", plotTop.ToString("F1")); - builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke", AxisColor); builder.AddAttribute(seq++, "stroke-width", "1"); builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); builder.AddAttribute(seq++, "marker-end", $"url(#{markerId})"); builder.CloseElement(); - // X axis: drawn left-to-right so the arrowhead points right. + // X-axis: drawn left-to-right so the arrowhead points right. builder.OpenElement(seq++, "line"); builder.AddAttribute(seq++, "x1", plotLeft.ToString("F1")); builder.AddAttribute(seq++, "y1", plotBottom.ToString("F1")); builder.AddAttribute(seq++, "x2", plotRight.ToString("F1")); builder.AddAttribute(seq++, "y2", plotBottom.ToString("F1")); - builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke", AxisColor); builder.AddAttribute(seq++, "stroke-width", "1"); builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); builder.AddAttribute(seq++, "marker-end", $"url(#{markerId})"); @@ -82,7 +81,7 @@ public static void RenderAxes( builder.AddAttribute(seq++, "y1", y.ToString("F1")); builder.AddAttribute(seq++, "x2", plotLeft.ToString("F1")); builder.AddAttribute(seq++, "y2", y.ToString("F1")); - builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke", AxisColor); builder.AddAttribute(seq++, "stroke-width", "1"); builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); builder.CloseElement(); @@ -103,7 +102,7 @@ public static void RenderAxes( builder.AddAttribute(seq++, "y1", plotBottom.ToString("F1")); builder.AddAttribute(seq++, "x2", x.ToString("F1")); builder.AddAttribute(seq++, "y2", (plotBottom + 3).ToString("F1")); - builder.AddAttribute(seq++, "stroke", axisColor); + builder.AddAttribute(seq++, "stroke", AxisColor); builder.AddAttribute(seq++, "stroke-width", "1"); builder.AddAttribute(seq++, "vector-effect", "non-scaling-stroke"); builder.CloseElement(); @@ -135,9 +134,12 @@ public static void RenderAxes( builder.AddContent(seq++, xAxisLabel); builder.CloseElement(); } - - /// Picks up to evenly-spaced indices from a 0-based range, always - /// including the first and last - shared by every chart's X-axis tick placement. +#pragma warning restore ASP0006 + + /// + /// Picks up to evenly-spaced indices from a 0-based range, always including the first and last - + /// shared by every chart's X-axis tick placement. + /// public static List EvenlySpacedIndices(int total, int count) { if (total <= 1 || count <= 1) return [0]; From 94b8a2258813364bbdfa2002c95c457fbf1f5f4e Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 17:19:41 +0200 Subject: [PATCH 34/44] Update packages --- Directory.Packages.props | 22 +++++++++---------- .../Components/Shared/SvgChartHelpers.cs | 17 ++++++++++---- 2 files changed, 24 insertions(+), 15 deletions(-) diff --git a/Directory.Packages.props b/Directory.Packages.props index b132c28..88aa2af 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -7,9 +7,9 @@ - + - + @@ -18,20 +18,20 @@ - - - - - + + + + + - + - - + + - + diff --git a/src/BlazorApp/Components/Shared/SvgChartHelpers.cs b/src/BlazorApp/Components/Shared/SvgChartHelpers.cs index 487351a..27d2a5b 100644 --- a/src/BlazorApp/Components/Shared/SvgChartHelpers.cs +++ b/src/BlazorApp/Components/Shared/SvgChartHelpers.cs @@ -15,10 +15,19 @@ public static class SvgChartHelpers /// Not every chart shares a single fixed viewBox: a chart rendered at full row width needs a proportionally wider viewBox than a half-width one - /// matching ViewWidth to actual on-screen width keeps the rendered scale (and therefore axis text/arrow/tick size) the same across every chart instead of the wider ones blowing up. /// - public readonly record struct ChartGeometry(double ViewWidth, double ViewHeight, double PlotLeft, double PlotRight, double PlotTop, double PlotBottom); + public readonly record struct ChartGeometry( + double ViewWidth, + double ViewHeight, + double PlotLeft, + double PlotRight, + double PlotTop, + double PlotBottom); - public static readonly ChartGeometry HalfWidthGeometry = new(ViewWidth: 300, ViewHeight: 170, PlotLeft: 40, PlotRight: 288, PlotTop: 14, PlotBottom: 132); - public static readonly ChartGeometry FullWidthGeometry = new(ViewWidth: 600, ViewHeight: 170, PlotLeft: 40, PlotRight: 588, PlotTop: 14, PlotBottom: 132); + public static readonly ChartGeometry HalfWidthGeometry = + new(ViewWidth: 300, ViewHeight: 170, PlotLeft: 40, PlotRight: 288, PlotTop: 14, PlotBottom: 132); + + public static readonly ChartGeometry FullWidthGeometry = + new(ViewWidth: 600, ViewHeight: 170, PlotLeft: 40, PlotRight: 588, PlotTop: 14, PlotBottom: 132); /// /// Draws a graduated X/Y axis pair (arrowhead, tick marks, tick labels, axis title). @@ -135,7 +144,7 @@ public static void RenderAxes( builder.CloseElement(); } #pragma warning restore ASP0006 - + /// /// Picks up to evenly-spaced indices from a 0-based range, always including the first and last - /// shared by every chart's X-axis tick placement. From 7a9c68b2ffc97d0dea05823c705fb8dc1975f72e Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 17:39:40 +0200 Subject: [PATCH 35/44] Fix some warnings --- Keeptrack.sln.DotSettings | 3 ++- docs/backlog.md | 2 ++ src/Domain/Services/WishlistService.cs | 8 ++++---- .../Repositories/AlbumRepository.cs | 2 +- .../Repositories/BookRepository.cs | 2 +- .../Repositories/CarHistoryRepository.cs | 2 +- .../Repositories/CarRepository.cs | 2 +- .../Repositories/EpisodeRepository.cs | 2 +- .../Repositories/HouseHistoryRepository.cs | 2 +- .../Repositories/HouseRepository.cs | 2 +- .../Repositories/MovieRepository.cs | 2 +- .../Repositories/PlaylistRepository.cs | 2 +- .../Repositories/SongRepository.cs | 2 +- .../Repositories/TvShowReferenceRepository.cs | 17 ++++++----------- .../Repositories/TvShowRepository.cs | 2 +- .../Repositories/VideoGameRepository.cs | 2 +- src/WebApi/Controllers/WishlistController.cs | 9 ++++----- .../Services/WishlistServiceTest.cs | 10 +++++----- 18 files changed, 35 insertions(+), 38 deletions(-) diff --git a/Keeptrack.sln.DotSettings b/Keeptrack.sln.DotSettings index 622f66d..ed00946 100644 --- a/Keeptrack.sln.DotSettings +++ b/Keeptrack.sln.DotSettings @@ -1,3 +1,4 @@  True - True \ No newline at end of file + True + True \ No newline at end of file diff --git a/docs/backlog.md b/docs/backlog.md index fef8848..d2423b1 100644 --- a/docs/backlog.md +++ b/docs/backlog.md @@ -1,3 +1,5 @@ # Backlog - Review SvgChartHelpers to remove "pragma warning disable ASP0006". +- Remove/replace trivial calls from WishlistService + diff --git a/src/Domain/Services/WishlistService.cs b/src/Domain/Services/WishlistService.cs index eeea154..a4931e9 100644 --- a/src/Domain/Services/WishlistService.cs +++ b/src/Domain/Services/WishlistService.cs @@ -11,15 +11,15 @@ namespace Keeptrack.Domain.Services; /// public class WishlistService { - public List SortMovies(IEnumerable movies) => + public static List SortMovies(IEnumerable movies) => movies.OrderBy(m => m.Title).ToList(); - public List SortTvShows(IEnumerable tvShows) => + public static List SortTvShows(IEnumerable tvShows) => tvShows.OrderBy(s => s.Title).ToList(); - public List SortBooks(IEnumerable books) => + public static List SortBooks(IEnumerable books) => books.OrderBy(b => b.Title).ToList(); - public List SortVideoGames(IEnumerable videoGames) => + public static List SortVideoGames(IEnumerable videoGames) => videoGames.OrderBy(g => g.Title).ToList(); } diff --git a/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs b/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs index 79f4f18..5fafb2a 100644 --- a/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/AlbumRepository.cs @@ -12,7 +12,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class AlbumRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class AlbumRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IAlbumRepository { protected override string CollectionName => "album"; diff --git a/src/Infrastructure.MongoDb/Repositories/BookRepository.cs b/src/Infrastructure.MongoDb/Repositories/BookRepository.cs index bbe335f..78a6208 100644 --- a/src/Infrastructure.MongoDb/Repositories/BookRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/BookRepository.cs @@ -12,7 +12,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class BookRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class BookRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IBookRepository { protected override string CollectionName => "book"; diff --git a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs index 038bbb1..da4a32b 100644 --- a/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/CarHistoryRepository.cs @@ -8,7 +8,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class CarHistoryRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class CarHistoryRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ICarHistoryRepository { protected override string CollectionName => "car_history"; diff --git a/src/Infrastructure.MongoDb/Repositories/CarRepository.cs b/src/Infrastructure.MongoDb/Repositories/CarRepository.cs index 4250fb3..037431b 100644 --- a/src/Infrastructure.MongoDb/Repositories/CarRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/CarRepository.cs @@ -7,7 +7,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class CarRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class CarRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ICarRepository { protected override string CollectionName => "car"; diff --git a/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs b/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs index 9243ac7..3653356 100644 --- a/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/EpisodeRepository.cs @@ -7,7 +7,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class EpisodeRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class EpisodeRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IEpisodeRepository { protected override string CollectionName => "episode"; diff --git a/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs b/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs index b7afd76..4fb6f82 100644 --- a/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/HouseHistoryRepository.cs @@ -8,7 +8,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class HouseHistoryRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class HouseHistoryRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IHouseHistoryRepository { protected override string CollectionName => "house_history"; diff --git a/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs b/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs index 75896c9..0e3e614 100644 --- a/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/HouseRepository.cs @@ -7,7 +7,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class HouseRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class HouseRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IHouseRepository { protected override string CollectionName => "house"; diff --git a/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs b/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs index c0c1477..23fdc97 100644 --- a/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/MovieRepository.cs @@ -12,7 +12,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class MovieRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class MovieRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IMovieRepository { protected override string CollectionName => "movie"; diff --git a/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs b/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs index bfb8049..e0852a6 100644 --- a/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/PlaylistRepository.cs @@ -7,7 +7,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class PlaylistRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class PlaylistRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IPlaylistRepository { protected override string CollectionName => "playlist"; diff --git a/src/Infrastructure.MongoDb/Repositories/SongRepository.cs b/src/Infrastructure.MongoDb/Repositories/SongRepository.cs index 6fed6eb..aacf697 100644 --- a/src/Infrastructure.MongoDb/Repositories/SongRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/SongRepository.cs @@ -7,7 +7,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class SongRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class SongRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ISongRepository { protected override string CollectionName => "song"; diff --git a/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs b/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs index 6ec21cf..7d4e3d8 100644 --- a/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/TvShowReferenceRepository.cs @@ -19,18 +19,15 @@ public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, TvShowRefer public async Task FindByIdAsync(string id) { var entity = await Collection.Find(x => x.Id == id).FirstOrDefaultAsync(); - // Mapperly throws on a null source rather than substituting a default instance - checking for a - // missing document must happen before mapping regardless. + // Mapperly throws on a null source rather than substituting a default instance - checking for a missing document must happen before mapping regardless. return entity is null ? null : mapper.ToModel(entity); } public async Task FindByTitleYearAsync(string title, int? year) { - // matches against every known-good (title, year) combination for this reference (see - // MatchedAliases), not just its canonical TitleNormalized/Year - ElemMatch requires both conditions - // to hold on the SAME array element, so a tenant whose recorded year genuinely differs from the - // document's own canonical Year still matches, as long as that exact (title, year) pair was - // confirmed at some point (automatic resolution or admin pick). + // matches against every known-good (title, year) combination for this reference (see MatchedAliases), not just its canonical TitleNormalized/Year - + // ElemMatch requires both conditions to hold on the SAME array element, so a tenant whose recorded year genuinely differs from the document's own canonical Year still matches, + // as long as that exact (title, year) pair was confirmed at some point (automatic resolution or admin pick). var normalized = TitleNormalizer.Normalize(title); var filter = Builders.Filter.ElemMatch(x => x.MatchedAliases, Builders.Filter.Eq(m => m.Title, normalized) & Builders.Filter.Eq(m => m.Year, year)); @@ -49,8 +46,7 @@ public class TvShowReferenceRepository(IMongoDatabase mongoDatabase, TvShowRefer public async Task FindByExternalIdAsync(string provider, string externalId) { - // a string field-path filter, not an expression indexer - the driver's expression-to-filter - // translation doesn't support indexing a Dictionary by a runtime key. + // a string field-path filter, not an expression indexer - the driver's expression-to-filter translation doesn't support indexing a Dictionary by a runtime key. var filter = Builders.Filter.Eq($"external_ids.{provider}", externalId); var entity = await Collection.Find(filter).FirstOrDefaultAsync(); return entity is null ? null : mapper.ToModel(entity); @@ -65,8 +61,7 @@ public async Task> FindAllAsync() public async Task UpsertAsync(TvShowReferenceModel model) { model.TitleNormalized = TitleNormalizer.Normalize(model.Title); - // the canonical (title, year) combination is always itself a valid match, whether or not the caller - // remembered to include it + // the canonical (title, year) combination is always itself a valid match, whether the caller remembered to include it if (!model.MatchedAliases.Any(m => m.Title == model.TitleNormalized && m.Year == model.Year)) { model.MatchedAliases.Add(new ReferenceMatchModel { Title = model.TitleNormalized, Year = model.Year }); diff --git a/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs b/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs index 75ca39f..1eb7b25 100644 --- a/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/TvShowRepository.cs @@ -12,7 +12,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class TvShowRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class TvShowRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), ITvShowRepository { protected override string CollectionName => "tvshow"; diff --git a/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs b/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs index 2ae22e7..37111de 100644 --- a/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs +++ b/src/Infrastructure.MongoDb/Repositories/VideoGameRepository.cs @@ -12,7 +12,7 @@ namespace Keeptrack.Infrastructure.MongoDb.Repositories; -public class VideoGameRepository(IMongoDatabase mongoDatabase, ILogger> logger, IStorageMapper mapper) +public class VideoGameRepository(IMongoDatabase mongoDatabase, ILogger logger, IStorageMapper mapper) : MongoDbRepositoryBase(mongoDatabase, logger, mapper), IVideoGameRepository { protected override string CollectionName => "videogame"; diff --git a/src/WebApi/Controllers/WishlistController.cs b/src/WebApi/Controllers/WishlistController.cs index ddac055..d68c683 100644 --- a/src/WebApi/Controllers/WishlistController.cs +++ b/src/WebApi/Controllers/WishlistController.cs @@ -15,7 +15,6 @@ public class WishlistController( ITvShowRepository tvShowRepository, IBookRepository bookRepository, IVideoGameRepository videoGameRepository, - WishlistService wishlistService, IDtoMapper movieMapper, IDtoMapper tvShowMapper, IDtoMapper bookMapper, @@ -39,10 +38,10 @@ public async Task> Get() return Ok(new WishlistDto { - Movies = wishlistService.SortMovies(movies.Items).Select(movieMapper.ToDto).ToList(), - TvShows = wishlistService.SortTvShows(tvShows.Items).Select(tvShowMapper.ToDto).ToList(), - Books = wishlistService.SortBooks(books.Items).Select(bookMapper.ToDto).ToList(), - VideoGames = wishlistService.SortVideoGames(videoGames.Items).Select(videoGameMapper.ToDto).ToList() + Movies = WishlistService.SortMovies(movies.Items).Select(movieMapper.ToDto).ToList(), + TvShows = WishlistService.SortTvShows(tvShows.Items).Select(tvShowMapper.ToDto).ToList(), + Books = WishlistService.SortBooks(books.Items).Select(bookMapper.ToDto).ToList(), + VideoGames = WishlistService.SortVideoGames(videoGames.Items).Select(videoGameMapper.ToDto).ToList() }); } } diff --git a/test/WebApi.UnitTests/Services/WishlistServiceTest.cs b/test/WebApi.UnitTests/Services/WishlistServiceTest.cs index d04fd3c..ec3f36e 100644 --- a/test/WebApi.UnitTests/Services/WishlistServiceTest.cs +++ b/test/WebApi.UnitTests/Services/WishlistServiceTest.cs @@ -19,7 +19,7 @@ public void SortMovies_OrdersByTitleAscending() new MovieModel { Id = "2", OwnerId = "owner", Title = "Arrival" } }; - var result = _service.SortMovies(movies); + var result = WishlistService.SortMovies(movies); result.Should().HaveCount(2); result[0].Title.Should().Be("Arrival"); @@ -35,7 +35,7 @@ public void SortTvShows_OrdersByTitleAscending() new TvShowModel { Id = "2", OwnerId = "owner", Title = "Dark" } }; - var result = _service.SortTvShows(shows); + var result = WishlistService.SortTvShows(shows); result.Should().HaveCount(2); result[0].Title.Should().Be("Dark"); @@ -51,7 +51,7 @@ public void SortBooks_OrdersByTitleAscending() new BookModel { Id = "2", OwnerId = "owner", Title = "Dune", Author = "Herbert" } }; - var result = _service.SortBooks(books); + var result = WishlistService.SortBooks(books); result.Should().HaveCount(2); result[0].Title.Should().Be("Dune"); @@ -67,7 +67,7 @@ public void SortVideoGames_OrdersByTitleAscending() new VideoGameModel { Id = "2", OwnerId = "owner", Title = "Elden Ring", Platforms = [new VideoGamePlatformModel { Platform = "PS5", State = "Available" }] } }; - var result = _service.SortVideoGames(games); + var result = WishlistService.SortVideoGames(games); result.Should().HaveCount(2); result[0].Title.Should().Be("Elden Ring"); @@ -77,7 +77,7 @@ public void SortVideoGames_OrdersByTitleAscending() [Fact] public void SortMovies_ReturnsEmptyListWhenNoMoviesWishlisted() { - var result = _service.SortMovies([]); + var result = WishlistService.SortMovies([]); result.Should().BeEmpty(); } From 47e355afd9fec0412267b35b134a1468b7183f0e Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 17:51:27 +0200 Subject: [PATCH 36/44] Update line length in editorconfig --- .editorconfig | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.editorconfig b/.editorconfig index 8fd4b9f..742fee6 100644 --- a/.editorconfig +++ b/.editorconfig @@ -6,7 +6,7 @@ root = true end_of_line = lf insert_final_newline = true indent_style = space -max_line_length = 150 +max_line_length = 180 [*.{cs,razor,sln}] indent_size = 4 @@ -19,6 +19,7 @@ trim_trailing_whitespace = true [*.md] indent_size = 2 trim_trailing_whitespace = false +max_line_length = 240 [*.cs] dotnet_sort_system_directives_first = true From f5de858822b5ffa725e00ec94f6dd6e7e7f0a036 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 18:02:22 +0200 Subject: [PATCH 37/44] Add docs/playwright-e2e-tests-plan.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit What I reviewed and how it shaped the plan: From todo-blazor — I kept the Microsoft.Playwright.Xunit.v3 PageTest + plain xunit facts style, the page-object pattern (locators/actions split, WaitForReadyAsync, chained typed navigation), and the Kestrel-factory in-process hosting. I dropped Reqnroll/Gherkin (your project has both styles side by side, and the Gherkin one is roughly double the code for the same coverage) and the Metalama screenshot aspect (xunit v3's TestContext.Current.TestState gives failure detection in DisposeAsync for free). Keeptrack-specific findings that drove the design: - The login page is OAuth-popup-only (GitHub/Google), which Playwright can't automate — but POST /auth/callback accepts any verified Firebase ID token, so auth is programmatic: REST signInWithPassword (reusing the integration tests' AccountRepository), post the token, save the cookie as Playwright storage state. Every test starts signed in. - By default the fixture creates an ephemeral admin user via the Firebase Admin SDK (Firebase__ServiceAccount is already required by the Blazor host, so no new secrets), seeds data over the REST API with the shared WebApi.Contracts DTOs, and populates references via the admin import endpoint with a synthetic in-memory fixture — the "look for a ref" smoke test then uses the "check for reference match" button, which never calls TMDB/Open Library, so the suite is fully deterministic with zero provider keys. - Hosting both apps in-process hits a real gotcha: both src/WebApi and src/BlazorApp generate a global Program class, so the test project needs extern alias on the project references. - The existing KestrelWebAppFactory gets extracted to a small test/Testing.Shared project (no duplicated logic, per the quality bar), parameterized so the e2e project can compose two instances with WebApi:BaseUrl injected. Your mid-task additions are covered: every knob is an env var (E2E_ENABLED, E2E_TARGET_URL, E2E_READONLY, E2E_HEADLESS, E2E_SLOWMO_MS, E2E_TRACE, credentials, plus the standard app config pass-throughs — full table in the doc). Rider debugging needs no extra machinery: tests are plain xunit, Local.runsettings carries the variables, and in integration mode both apps run inside the test process, so a breakpoint in BlazorApp/WebApi source hits during a browser click. The doc also covers the read-only mode semantics (mutating tests self-skip), an E2E_ENABLED guard so solution-wide dotnet test stays green, the Blazor Server prerender/circuit waiting gotcha, failure traces/screenshots, a dedicated CI job with browser caching, and a 4-phase implementation plan (foundation → smoke suite → CI → later types/admin/import). --- docs/playwright-e2e-tests-plan.md | 181 ++++++++++++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 docs/playwright-e2e-tests-plan.md diff --git a/docs/playwright-e2e-tests-plan.md b/docs/playwright-e2e-tests-plan.md new file mode 100644 index 0000000..84a9a7b --- /dev/null +++ b/docs/playwright-e2e-tests-plan.md @@ -0,0 +1,181 @@ +# Playwright end-to-end tests plan + +## Goal + +Add browser-level end-to-end (e2e) smoke tests that prove every page loads and the core user journeys work: sign in, browse every list page, add a book, link it to reference data, delete it. +The suite must run three ways from the same code: in-process against `Program` (local dev and CI), against an already-running local instance, and against a real deployed platform. +Minimal code is a hard requirement: plain xunit facts, one generic page object for all ten identical list pages, no Gherkin, no aspect framework. +Every knob is an environment variable, and a test run must be debuggable in Rider with breakpoints in both the tests and the application source. + +## What the todo-blazor review found + +`C:\Users\bthom\projects\todo-blazor\test\BlazorApp.PlaywrightTests` contains two parallel styles: Reqnroll (Gherkin features + step classes + hooks) and plain xunit smoke tests built on `Microsoft.Playwright.Xunit.v3`'s `PageTest`. +The verdict per practice: + +Practice | Verdict | Reason +--------------------------------------------------------------------|---------|------- +`PageTest` base (`Microsoft.Playwright.Xunit.v3`) + plain facts | Keep | The package owns the browser/context/page lifecycle; tests stay ordinary debuggable xunit methods +Page objects with locators/actions sections and `WaitForReadyAsync` | Keep | Readable and chainable (each action returns the next typed page); waiting is centralized so tests never sleep +`KestrelWebAppFactory` in-process hosting | Keep | Keeptrack already has its own copy in `WebApi.IntegrationTests`; it gets extracted and reused, not duplicated +Reqnroll/Gherkin (features, steps, hooks, context keys) | Drop | Doubles the code for the same coverage; the smoke scenarios read fine as plain C# methods +Metalama `ScreenshotOnFailure` aspect | Drop | xunit v3's `TestContext.Current.TestState` enables the same capture in `DisposeAsync` with no aspect framework +`data-testid` on almost every element | Soften | Prefer role/label locators; add `data-testid` only where Bootstrap markup is genuinely ambiguous + +## Keeptrack-specific constraints the design must handle + +- Two hosts: the Blazor Server app and the Web API are separate processes, so "in-process" mode means two `WebApplicationFactory` instances, with the Blazor host's `WebApi:BaseUrl` pointed at the API host's dynamic address. +- The login page is OAuth-popup-only (GitHub/Google via the Firebase JS SDK), which Playwright cannot automate reliably. +- `POST /auth/callback` accepts any verified Firebase ID token, so authentication is programmatic. + Sign in over Firebase REST `signInWithPassword` (the existing `AccountRepository` flow), post the token to `/auth/callback`, and capture the cookie as Playwright storage state. +- Admin provisioning: the `role: admin` custom claim is set with the Firebase Admin SDK. + The Blazor host already requires `Firebase:ServiceAccount`, so the e2e harness can create/claim/delete its own ephemeral user with no new secrets. +- Reference enrichment on create fires real provider calls; hosted mode simply provides no provider keys, so new items stay unresolved and no external network flakiness enters the suite. +- The deterministic "look for a ref" path is `POST /api/reference-data/import` (covers all six reference collections) followed by the user-facing "check for reference match" button, which only queries MongoDB and never calls a provider. +- Blazor Server prerenders before the circuit connects, so page objects must wait for an interactive signal (e.g. the loading state resolving into rows), never just static markup, and never `NetworkIdle` (the circuit websocket defeats it). + +## Project layout + +New projects, following the existing naming and conventions (xunit v3, `Microsoft.Testing.Platform` runner, central package versions): + +Path | Content +----------------------------|-------- +`test/Testing.Shared` | `KestrelWebAppFactory` (moved from `WebApi.IntegrationTests`), `AccountRepository`, `FirebaseConfiguration`; referenced by both integration and e2e projects so no logic is duplicated +`test/BlazorApp.E2eTests` | The Playwright suite itself + +Inside `test/BlazorApp.E2eTests`: + +Folder | Content +------------|-------- +`Hosting/` | `E2eFixture` (xunit v3 `[AssemblyFixture]`): boots both hosts (or targets live URLs), provisions the user, seeds data, exposes `BaseUrl` and an authenticated `ApiClient` +`Support/` | `E2eConfiguration` (every env var in one static class), `ReferenceFixtureZipBuilder` (synthetic in-memory reference export, same spirit as `TvTimeFixtureZipBuilder`) +`Pages/` | `PageBase`, `ListPage` (one class for all ten list pages), `BookDetailPage`, `LoginPage`, `HomePage` +`Smoke/` | `SmokeTestBase` and the test classes + +`KestrelWebAppFactory` is generalized during extraction: the env-var override name (`KESTREL_WEBAPP_URL` today) and the in-memory config overrides (the `Features:IsReferenceSyncEnabled=false` pair) become constructor parameters. +`WebApi.IntegrationTests` keeps its current behavior through a thin subclass; the e2e project composes two instances (API, then Blazor with `WebApi:BaseUrl` injected). + +**Gotcha:** both `src/WebApi` and `src/BlazorApp` generate a top-level `Program` class in the global namespace, so referencing both from one test project is ambiguous. +Fix: `` plus `extern alias WebApiHost;`, and use `WebApiHost::Program` / `BlazorHost::Program`. +`WebApi.IntegrationTests` already references the generated `Program` directly with no extra declaration, so no `public partial class Program` is needed in either app. + +Package additions to `Directory.Packages.props`: `Microsoft.Playwright` and `Microsoft.Playwright.Xunit.v3` (latest stable, kept in sync with each other). + +## Execution modes + +Mode | Trigger | Hosting | Data +------------|----------------------------------------|-------------------------------------------|----- +Integration | `E2E_ENABLED=true`, no target URL | Both apps in-process on dynamic ports | Ephemeral admin user created, data seeded, everything deleted at the end +Live | `E2E_TARGET_URL` set | Nothing hosted; browser hits the real URL | `E2E_USERNAME`/`E2E_PASSWORD` account; seeding via `E2E_WEBAPI_URL` unless read-only +Read-only | `E2E_READONLY=true` (implies live use) | Nothing hosted | No provisioning, no seeding; every mutating test self-skips + +## Configuration (environment variables only) + +Harness settings, all read by `E2eConfiguration` with the defaults below: + +Variable | Default | Purpose +----------------------------|--------------|-------- +`E2E_ENABLED` | `false` | Master switch; when unset every e2e test self-skips so a plain solution-wide `dotnet test` stays green +`E2E_TARGET_URL` | *(empty)* | Live mode: base URL of an existing BlazorApp; empty means self-host both apps in-process +`E2E_WEBAPI_URL` | *(empty)* | Live mode: base URL of the matching WebApi, required for seeding/cleanup when not read-only +`E2E_READONLY` | `false` | Skips every mutating test, user creation, and seeding +`E2E_USERNAME` | *(empty)* | Existing account email; empty triggers ephemeral admin user creation (integration mode only) +`E2E_PASSWORD` | *(empty)* | Password for `E2E_USERNAME` +`E2E_HEADLESS` | `true` | `false` shows the browser window +`E2E_SLOWMO_MS` | `0` | Milliseconds of delay injected before each Playwright action +`E2E_BROWSER` | `chromium` | `chromium`, `firefox` or `webkit` +`E2E_TRACE` | `on-failure` | `off`, `on` or `on-failure`; traces and failure screenshots land in the test output directory + +Pass-through application settings (hosted mode reuses exactly the variables the integration tests already document in `CONTRIBUTING.md`): + +- `Infrastructure__MongoDB__ConnectionString` / `Infrastructure__MongoDB__DatabaseName`, pointed at a dedicated database (e.g. `keeptrack_e2e`), never the dev one. +- `Authentication__JwtBearer__Authority` / `__TokenValidation__Issuer` / `__TokenValidation__Audience` for the hosted API. +- `FIREBASE_APIKEY` for the REST sign-in (same variable the integration tests use). +- `Firebase__ServiceAccount` and `Firebase__WebAppConfiguration__ApiKey`/`AuthDomain`/`ProjectId` for the hosted Blazor app and the Admin SDK. +- No provider keys (`Tmdb__ApiKey`, `Rawg__ApiKey`, `Discogs__Token`) on purpose; the app degrades gracefully and the suite stays deterministic. + +## Authentication and provisioning flow + +1. `E2eFixture` starts (once per run, xunit v3 assembly fixture) and resolves the mode from the variables above; if `E2E_ENABLED` is unset it marks the run skipped and every test short-circuits. +2. Integration mode with no `E2E_USERNAME`: create `e2e-@keeptrack.test` with a random password via `FirebaseAuth.CreateUserAsync`, then `SetCustomUserClaimsAsync(uid, { role: "admin" })`. +3. Sign in over Firebase REST (`AccountRepository.AuthenticateAsync` from `Testing.Shared`) to get an ID token; keep the bearer token for direct WebApi seeding calls. +4. Create a Playwright `APIRequestContext` on the Blazor base URL, `POST /auth/callback` with the ID token, and save `StorageStateAsync()` to a file. +5. `SmokeTestBase` overrides `PageTest.ContextOptions()` to supply `StorageStatePath`, `BaseURL`, viewport and `IgnoreHTTPSErrors`, so every test starts already signed in; only the dedicated auth test uses a clean context. +6. Seeding (integration mode): import the synthetic reference fixture via `POST /api/reference-data/import`, then create a handful of items per type via the REST API using the shared `WebApi.Contracts` DTOs. +7. Teardown: delete the seeded documents via the API, then delete the ephemeral Firebase user; live mode tests clean up whatever they created, same discipline as the resource tests. + +## Page objects + +- `PageBase(IPage page)`: sidebar navigation locators, `WaitForReadyAsync()` (page title + a per-page interactive signal), typed `OpenAsync()` helpers that return the next page object. +- `ListPage`: one class parameterized by route, title and item name, because `InventoryList` renders all ten list pages identically. + It covers search, paging, the add form (fill by `GetByLabel`), row lookup by text, inline edit, and delete confirmation. +- `BookDetailPage` first; other detail pages are added only when a test needs them. +- Locator strategy: `GetByRole`/`GetByLabel` first; add a `data-testid` to `InventoryList`'s few ambiguous controls (add button, save/cancel, delete-confirm modal) only if role/name lookup proves fragile in practice. +- `WaitForReadyAsync` on list pages asserts the loading state has resolved (spinner hidden, table or empty-state visible), which also guarantees the Blazor circuit is interactive before any click. + +## Smoke test scope (first iteration) + +Test class | Read-only safe | Proves +----------------------|----------------|------- +`NavigationSmokeTest` | Yes | Home, all ten list pages, wishlist and watch-next each load with their header and no error boundary +`AuthSmokeTest` | Yes | An anonymous visit to `/books` lands on `/account/login`; logout ends the session +`BookSmokeTest` | No | Add a book through the list form, see it in the list, open its detail page, edit a field, delete it +`ReferenceSmokeTest` | No | With the fixture imported, add the matching book, click "check for reference match" on the detail page, assert title/author/cover resolve + +Read-only mode runs only the first two classes; mutating tests call `Assert.Skip` when `E2E_READONLY=true`. +Admin page (`/admin/reference-data`) and import page (`/import`) journeys are explicitly deferred, as are the other item types' CRUD journeys (they exercise the same `InventoryList`/`DataCrudControllerBase` code paths as books). + +## Failure diagnostics + +- Tracing starts in `SmokeTestBase.InitializeAsync` when `E2E_TRACE` is `on` or `on-failure`. +- `DisposeAsync` checks `TestContext.Current.TestState`; on failure it saves a full-page screenshot and the trace zip, named after the test, otherwise it discards the trace. +- Trace zips open in `https://trace.playwright.dev` or via `playwright show-trace`, giving DOM snapshots and network for every failed CI run. +- CI uploads the trace/screenshot directory as a build artifact when the e2e job fails. + +## Running and debugging + +Local run (integration mode), after a one-time `pwsh test/BlazorApp.E2eTests/bin/Debug/net10.0/playwright.ps1 install chromium`: + +```bash +export E2E_ENABLED=true +# plus the same MongoDB/Firebase variables the integration tests already need +dotnet test test/BlazorApp.E2eTests/BlazorApp.E2eTests.csproj +``` + +Live run against a real platform: + +```bash +export E2E_ENABLED=true E2E_TARGET_URL=https://keeptrack.example.com E2E_READONLY=true +export E2E_USERNAME=... E2E_PASSWORD=... FIREBASE_APIKEY=... +dotnet test test/BlazorApp.E2eTests/BlazorApp.E2eTests.csproj +``` + +Rider debugging works with zero extra machinery because everything is an ordinary xunit test: + +- Add the `E2E_*` variables to the existing `Local.runsettings` (Rider reads it automatically) and debug any test from the gutter. +- In integration mode both apps run inside the test process, so breakpoints hit in `BlazorApp`/`WebApi` source during a browser click, not just in test code. +- `E2E_HEADLESS=false` plus `E2E_SLOWMO_MS=250` to watch the run; `PWDEBUG=1` opens the Playwright inspector. +- To debug the app itself under Rider's debugger instead, `dotnet run` both apps, set `E2E_TARGET_URL`/`E2E_WEBAPI_URL` to them, and run the tests as the client. + +## CI integration + +- A new `e2e` job in `.github/workflows/ci.yaml` (and later the GitLab/Azure equivalents), `needs: git-check`, gated on `app_changed` like the code-quality job. +- Steps: checkout, .NET setup, `scripts/mongodb-install.sh`, `dotnet build` the e2e project, then `playwright.ps1 install --with-deps chromium`. + Finally `dotnet test` with `E2E_ENABLED=true` and the same Firebase secrets the code-quality job already receives. +- Cache `~/.cache/ms-playwright` keyed on the `Microsoft.Playwright` package version to avoid re-downloading browsers every run. +- The existing code-quality job needs no change: it runs the whole solution, but the e2e tests self-skip there because `E2E_ENABLED` is unset. +- Upload traces/screenshots as an artifact on failure (see above). + +## Implementation phases + +1. **Foundation**: extract `Testing.Shared`, scaffold `BlazorApp.E2eTests`, `E2eConfiguration`, the dual-host `E2eFixture` with extern-alias wiring, and programmatic auth + storage state. + This phase ends with the `E2E_ENABLED` skip guard and a single trivial "home page loads" test proving the whole chain. +2. **Smoke suite**: `PageBase`/`ListPage`/`BookDetailPage`, the four test classes above, ephemeral-user provisioning, reference fixture import, read-only skips, failure diagnostics. +3. **CI**: the `e2e` GitHub Actions job, browser caching, artifact upload; update `CONTRIBUTING.md` (new variables, `Local.runsettings` template additions) and `CLAUDE.md`'s test section. +4. **Later**: remaining item types' journeys, TV show episode checklist, wishlist/watch-next with seeded data, admin and import pages, optional Gherkin layer only if ever wanted (deliberately out of scope now). + +## Open questions / accepted trade-offs + +- The suite requires a real Firebase project even in CI, same as the integration tests today; a fully offline auth fake would mean forking the auth pipeline and is not worth it for smoke coverage. +- Ephemeral user creation needs the service-account secret in CI; if that is ever unacceptable, the fallback is the existing shared test user via `E2E_USERNAME`/`E2E_PASSWORD` (at the cost of parallel-run isolation). +- One browser (Chromium) is enough for smoke; `E2E_BROWSER` exists so cross-browser runs stay a config change, not a code change. +- Watch-next/wishlist pages are only asserted to load in phase 2, because meaningful content assertions need reference-linked, partially-watched seed data (phase 4). From 914b241a5696c23a49ccf4eb0d58d082258e5258 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 18:09:19 +0200 Subject: [PATCH 38/44] Improve markdown --- CLAUDE.md | 549 +++++++++++++++++++++++++++------- CONTRIBUTING.md | 20 +- docs/code-quality-findings.md | 69 +++-- 3 files changed, 498 insertions(+), 140 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 29f7b75..092a0c1 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,7 +4,8 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co ## Project overview -Keeptrack is a source-available application (PolyForm Strict 1.0.0, see `LICENSE` - not open source) that lets users save and review everything they read, watch, listen to or play (books, movies, TV shows, music albums, video games, cars/car history). +Keeptrack is a source-available application (PolyForm Strict 1.0.0, see `LICENSE` - not open source). +It lets users save and review everything they read, watch, listen to or play (books, movies, TV shows, music albums, video games, cars/car history). It is a three-tier .NET 10 / C# solution: @@ -46,7 +47,9 @@ A local MongoDB instance is required to run the Web API or the integration tests docker run --name mongodb -d -p 27017:27017 mongo:8.2 ``` -Integration tests also need Firebase test-user credentials and MongoDB connection settings. Provide them as environment variables, or in a `Local.runsettings` file at the repository root (see `CONTRIBUTING.md` for the template). Never commit this file. +Integration tests also need Firebase test-user credentials and MongoDB connection settings. +Provide them as environment variables, or in a `Local.runsettings` file at the repository root (see `CONTRIBUTING.md` for the template). +Never commit this file. ## Architecture @@ -63,154 +66,470 @@ Project | Depends on ### Data model conventions -Every entity that belongs to a user implements `IHasIdAndOwnerId` (`Id` + `OwnerId`) at all three layers (`Domain` model, MongoDB entity, contract DTO), each with its own class. Mapping between them is generated at compile time by [Riok.Mapperly](https://github.com/riok/mapperly) (a source generator, no runtime reflection) rather than AutoMapper - see `docs/automapper-removal-plan.md` for the removal history: - -- `Infrastructure.MongoDb/Mappers/`: one `[Mapper]` partial class per entity pair (e.g. `BookStorageMapper`), implementing `IStorageMapper` (`Infrastructure.MongoDb/Mappers/IStorageMapper.cs`) - MongoDB entity <-> Domain model. Injected into `MongoDbRepositoryBase` and the six owner-less reference repositories. -- `WebApi/Mappers/`: one `[Mapper]` partial class per CRUD pair (e.g. `BookDtoMapper`), implementing `IDtoMapper` (`WebApi/Mappers/IDtoMapper.cs`) - DTO <-> Domain model. `OwnerId` is always set via `[MapValue(nameof(Model.OwnerId), "")]` (not `[MapperIgnoreTarget]` - `OwnerId` is `required` on the model, so a plain ignore would fail to compile the generated object initializer) on the DTO -> model direction; the placeholder value is immediately overwritten server-side from the authenticated user's claims in `DataCrudControllerBase`, never trusted from client input. Read-only feature controllers (`WatchNextController`, `WishlistController`, `CarController`/`HouseController`'s metrics, `ReferenceDataController`) use a small one-directional Model-to-DTO mapper class instead (e.g. `CarMetricsDtoMapper`), injected as its concrete type rather than through `IDtoMapper` - they have no DTO -> Model direction to speak of. - -Unmapped members are build errors, not a runtime assertion: `RMG012`/`RMG020` (Mapperly's unmapped-target/unmapped-source diagnostics) are escalated to `error` severity in `.editorconfig`, so a new property added to a model/entity/DTO without a matching mapping fails the build immediately - this replaced the old `AutoMapperConfigurationTest`'s runtime `AssertConfigurationIsValid()` check, now enforced at compile time instead. A source-only member each direction doesn't need (like `OwnerId` on the Model -> Dto direction, or a filter-only DTO/model field with no entity counterpart) needs an explicit `[MapperIgnoreSource]`/`[MapperIgnoreTarget]` attribute to satisfy this - don't leave a member unmapped and unignored, the build won't compile. - -An enum used in a `Domain` model (e.g. `TvShowModel.State: TvShowStatus?`) needs its own **separate** definition in `WebApi.Contracts` (`TvShowDto.State` uses `Keeptrack.WebApi.Contracts.Dto.TvShowStatus`, not the Domain one) - `WebApi.Contracts` doesn't depend on `Domain` (see the project table above), so the DTO can't reference the Domain enum directly. Keep the member names identical between the two; the DTO mapper sets `EnumMappingStrategy = EnumMappingStrategy.ByName` on its `[Mapper]` attribute so Mapperly maps enum-to-enum by name, generating a build diagnostic (rather than a silent runtime mismatch) if a member name ever drifts between the two definitions. The Mongo entity, on the other hand, *can* reuse the Domain enum directly (`Infrastructure.MongoDb` depends on `Domain`) - only the Contracts layer needs the duplicate, and storage mappers don't need the `ByName` strategy since there's only one enum type involved. - -**Gotcha:** a DTO member that's nullable while its model counterpart is `required` non-nullable (the `InventoryPageBase` `new()`-constraint gotcha two sections down - e.g. `BookDto.Title` vs. `BookModel.Title`) needs an explicit fallback on the DTO -> model direction; Mapperly refuses to compile a silent substitution the way AutoMapper used to. `CommonDtoMappings.ToRequiredString` (`WebApi/Mappers/`, a `[UserMapping]` static method attached to the affected DTO mappers via `[UseStaticMapper(typeof(CommonDtoMappings))]`) reproduces AutoMapper's old `?? string.Empty` behavior for every such string member across every mapper that needs it, for exact behavior parity - tightening this to a real 400 validation error for a missing title is a deliberate follow-up, not part of the mechanical migration. `CarDto.EnergyType` (nullable) -> `CarModel.EnergyType` (required, non-nullable, and a *different* enum type than the Dto's) needs the same treatment but can't reuse `ToRequiredString` (wrong types) - see `CarDtoMapper`'s own hand-written `[UserMapping]` for the pattern: a partial method gets the generated, drift-checked `ByName` enum conversion, wrapped by one small hand-written method that only handles the null -> `default` fallback. +Every entity that belongs to a user implements `IHasIdAndOwnerId` (`Id` + `OwnerId`) at all three layers (`Domain` model, MongoDB entity, contract DTO), each with its own class. +Mapping between them is generated at compile time by [Riok.Mapperly](https://github.com/riok/mapperly) (a source generator, no runtime reflection) rather than AutoMapper - see `docs/automapper-removal-plan.md` for the removal history: + +- `Infrastructure.MongoDb/Mappers/`: one `[Mapper]` partial class per entity pair (e.g. `BookStorageMapper`), implementing `IStorageMapper` (`Infrastructure.MongoDb/Mappers/IStorageMapper.cs`) - MongoDB entity <-> Domain model. + Injected into `MongoDbRepositoryBase` and the six owner-less reference repositories. +- `WebApi/Mappers/`: one `[Mapper]` partial class per CRUD pair (e.g. `BookDtoMapper`), implementing `IDtoMapper` (`WebApi/Mappers/IDtoMapper.cs`) - DTO <-> Domain model. + `OwnerId` is always set via `[MapValue(nameof(Model.OwnerId), "")]` on the DTO -> model direction (not `[MapperIgnoreTarget]` - `OwnerId` is `required` on the model, so a plain ignore would fail to compile the generated object initializer). + The placeholder value is immediately overwritten server-side from the authenticated user's claims in `DataCrudControllerBase`, never trusted from client input. + Read-only feature controllers (`WatchNextController`, `WishlistController`, `CarController`/`HouseController`'s metrics, `ReferenceDataController`) use a small one-directional Model-to-DTO mapper class instead (e.g. `CarMetricsDtoMapper`). + It's injected as its concrete type rather than through `IDtoMapper`, since it has no DTO -> Model direction to speak of. + +Unmapped members are build errors, not a runtime assertion: `RMG012`/`RMG020` (Mapperly's unmapped-target/unmapped-source diagnostics) are escalated to `error` severity in `.editorconfig`. +So a new property added to a model/entity/DTO without a matching mapping fails the build immediately. +This replaced the old `AutoMapperConfigurationTest`'s runtime `AssertConfigurationIsValid()` check, now enforced at compile time instead. +A source-only member each direction doesn't need (like `OwnerId` on the Model -> Dto direction, or a filter-only DTO/model field with no entity counterpart) needs an explicit `[MapperIgnoreSource]`/`[MapperIgnoreTarget]` attribute. +This satisfies the diagnostic. +Don't leave a member unmapped and unignored - the build won't compile. + +An enum used in a `Domain` model (e.g. `TvShowModel.State: TvShowStatus?`) needs its own **separate** definition in `WebApi.Contracts` (`TvShowDto.State` uses `Keeptrack.WebApi.Contracts.Dto.TvShowStatus`, not the Domain one). +`WebApi.Contracts` doesn't depend on `Domain` (see the project table above), so the DTO can't reference the Domain enum directly. +Keep the member names identical between the two; the DTO mapper sets `EnumMappingStrategy = EnumMappingStrategy.ByName` on its `[Mapper]` attribute so Mapperly maps enum-to-enum by name. +This generates a build diagnostic (rather than a silent runtime mismatch) if a member name ever drifts between the two definitions. +The Mongo entity, on the other hand, *can* reuse the Domain enum directly (`Infrastructure.MongoDb` depends on `Domain`). +Only the Contracts layer needs the duplicate, and storage mappers don't need the `ByName` strategy since there's only one enum type involved. + +**Gotcha:** a DTO member that's nullable while its model counterpart is `required` non-nullable (the `InventoryPageBase` `new()`-constraint gotcha two sections down - e.g. `BookDto.Title` vs. `BookModel.Title`). +This needs an explicit fallback on the DTO -> model direction. +Mapperly refuses to compile a silent substitution the way AutoMapper used to. +`CommonDtoMappings.ToRequiredString` (`WebApi/Mappers/`, a `[UserMapping]` static method attached to the affected DTO mappers via `[UseStaticMapper(typeof(CommonDtoMappings))]`) reproduces AutoMapper's old `?? string.Empty` behavior. +It applies for every such string member across every mapper that needs it. +This is for exact behavior parity. +Tightening this to a real 400 validation error for a missing title is a deliberate follow-up, not part of the mechanical migration. +`CarDto.EnergyType` (nullable) -> `CarModel.EnergyType` (required, non-nullable, and a *different* enum type than the Dto's) needs the same treatment but can't reuse `ToRequiredString` (wrong types). +See `CarDtoMapper`'s own hand-written `[UserMapping]` for the pattern: a partial method gets the generated, drift-checked `ByName` enum conversion, wrapped by one small hand-written method that only handles the null -> `default` fallback. ### Adding a new trackable item type -Follow the existing types (`Book`, `Movie`, `Album`, `TvShow`, `VideoGame`, `Car`/`CarHistory`) as the template. A new type touches every layer: +Follow the existing types (`Book`, `Movie`, `Album`, `TvShow`, `VideoGame`, `Car`/`CarHistory`) as the template. +A new type touches every layer: 1. `Domain/Models/Model.cs` and `Domain/Repositories/IRepository.cs` (extends `IDataRepository`). -2. `Infrastructure.MongoDb/Entities/.cs` (BSON attributes, `snake_case` element names via `[BsonElement]`) and `Infrastructure.MongoDb/Repositories/Repository.cs` (extends `MongoDbRepositoryBase`, overrides `CollectionName` and, if searchable, `GetFilter`). +2. `Infrastructure.MongoDb/Entities/.cs` (BSON attributes, `snake_case` element names via `[BsonElement]`). + `Infrastructure.MongoDb/Repositories/Repository.cs` (extends `MongoDbRepositoryBase`, overrides `CollectionName` and, if searchable, `GetFilter`). 3. `WebApi.Contracts/Dto/Dto.cs` (XML doc comments drive the generated OpenAPI spec). 4. `WebApi/Controllers/Controller.cs`: a one-line class extending `DataCrudControllerBase` — CRUD logic is never duplicated per controller. 5. Register the repository in `WebApi/DependencyInjection/InfrastructureServiceCollectionExtensions.cs`. -6. Add a storage mapper (`Infrastructure.MongoDb/Mappers/StorageMapper.cs`, implementing `IStorageMapper`, registered in `InfrastructureServiceCollectionExtensions.cs`) and a DTO mapper (`WebApi/Mappers/DtoMapper.cs`, implementing `IDtoMapper`, registered in `Program.cs`). +6. Add a storage mapper (`Infrastructure.MongoDb/Mappers/StorageMapper.cs`, implementing `IStorageMapper`, registered in `InfrastructureServiceCollectionExtensions.cs`). + Also add a DTO mapper (`WebApi/Mappers/DtoMapper.cs`, implementing `IDtoMapper`, registered in `Program.cs`). 7. `BlazorApp/Components/Inventory/Clients/ApiClient.cs` extending `InventoryApiClientBase`, plus a `Pages/.razor` / `.razor.cs` pair extending `InventoryPageBase`. -**Gotcha:** `Dto` can never have a `required` member if `Pages/.razor.cs` extends `InventoryPageBase` — that base class is constrained `where TDto : IHasId, new()`, and a type with *any* `required` member can't satisfy a bare `new()` constraint in C# (`CS9040`). This is why `BookDto.Title`, `CarDto.Name`, etc. are all nullable even though their Domain model counterpart (`BookModel.Title`, `CarModel.Name`) is `required` — it's a hard language limitation forced by the generic list-page base class, not a design inconsistency to "fix" by making the Dto match the model. A Dto with no `InventoryPageBase` usage (e.g. `CarHistoryDto`, owned-by-a-parent types managed from their parent's detail page rather than their own list page) has no such constraint and can mirror the Domain model's `required` members in full. +**Gotcha:** `Dto` can never have a `required` member if `Pages/.razor.cs` extends `InventoryPageBase` — that base class is constrained `where TDto : IHasId, new()`. +A type with *any* `required` member can't satisfy a bare `new()` constraint in C# (`CS9040`). +This is why `BookDto.Title`, `CarDto.Name`, etc. are all nullable even though their Domain model counterpart (`BookModel.Title`, `CarModel.Name`) is `required`. +It's a hard language limitation forced by the generic list-page base class, not a design inconsistency to "fix" by making the Dto match the model. +A Dto with no `InventoryPageBase` usage (e.g. `CarHistoryDto`, owned-by-a-parent types managed from their parent's detail page rather than their own list page) has no such constraint. +It can mirror the Domain model's `required` members in full. ### Child entities (1-to-many owned by another entity) -`CarHistory` (owned by `Car`) and `Episode` (owned by `TvShow`) are separate top-level collections referencing their parent by id (`car_id`, `tv_show_id`), not embedded arrays. This is deliberate MongoDB schema design, not an accident: these child collections can grow unbounded per parent over years of use, and features that need to query the child across *all* of a user's parents at once (e.g. Watch Next, below) need a plain indexed query rather than an `$unwind` aggregation. Embedding is the right call for genuinely small, always-together, never-queried-alone data; neither condition holds here. `EpisodeRepository.GetFilter`/`CarHistoryRepository.GetFilter` both filter their parent-id field (`TvShowId`/`CarId`) with `Eq`, not `Text` — an exact-id filter used `Text` in `CarHistory`'s first draft, throwing whenever a free-text `search` was also supplied (MongoDB allows only one `$text` expression per query), fixed and covered by `docs/code-quality-findings.md`. New multi-word BSON fields get an explicit `[BsonElement("snake_case_name")]`; don't rely on the `CamelCaseElementNameConvention` registered in `AddMongoDbInfrastructure` — every existing multi-word field already overrides it explicitly, so it's effectively dead configuration. Indexes for new collections are declared in `scripts/mongodb-create-index.js` (natural-key uniqueness, query-shape support, and partial indexes for sparse boolean flags like `is_favorite`/`want_to_watch`). - -`CarHistoryModel.EventType` (`CarHistoryType`: `Refuel`/`Maintenance`/`Other`) is a real discriminated enum, not free text — the same "never name a property/field bare `Type`" rule as any other discriminator in this codebase (see `TvShowModel.State`'s own rename history above): a bare `Type` reads ambiguously and collides in spirit with `object.GetType()`/`System.Type`. `Car.EnergyType` (`CarEnergyType`: `Combustion`/`Hybrid`/`Electric`) and `CarHistoryModel.EventType`/`CarId`/`HistoryDate` are all `required` on both the Domain model and the Mongo entity; `CarDto` itself can't mirror `Name`/`EnergyType` as `required`, because `Cars.razor` extends `InventoryPageBase`, which needs a bare `new()` constraint — a type with *any* `required` member can't satisfy `new()` in C#, so the Dto layer stays nullable there by hard language necessity, not by choice (`CarHistoryDto` has no such constraint, so it mirrors `required` in full). `CarHistoryModel.DeltaMileage` is real user-entered data (typically read off the car's own trip computer at refuel time), not a derived/computed field, kept specifically so `Domain/Services/CarMetricsService.cs` can cross-check it against consecutive `Mileage` readings and flag a likely typo or a skipped entry — the automated version of a manual spreadsheet cross-check, and the reason this field was kept rather than dropped as "unused" during review. `CarMetricsService` (consumption — only ever computed across a full refill/recharge, never a partial one — cost-of-ownership history, mileage warnings, next-maintenance-due) follows `WatchNextService`'s shape: a plain, `AddSingleton`-registered, unit-tested pure computation class with no persistence of its own, exposed via `CarController.GetMetrics` the same way `VideoGameController.RefreshReference` adds an extra per-item action to an entity's own CRUD controller instead of a separate cross-entity controller. - -`House`/`HouseHistory` (owned-by-a-parent, same shape as `Car`/`CarHistory` above) is a deliberately smaller sibling, not a second copy of Car's design: the priority (confirmed with the owner) is an exhaustive, browsable action log for insurance purposes plus a yearly cost review, not fuel/mileage tracking or reminders - the owner tracks recurring bills/maintenance schedules elsewhere and explicitly asked for reminders to stay out of scope ("keep it simple, not important, I manage it elsewhere"). Concretely: `HouseHistoryModel` has no `Mileage`/`DeltaMileage`/fuel fields, no location sub-fields (a house doesn't move, unlike a car's refuel stops), and `Domain/Services/HouseMetricsService.cs` has no `ComputeNextMaintenanceDue`-style due-date engine - it only computes `ComputeAnnualCostHistory` (cost per year, broken down by `HouseEventType`: `Maintenance`/`Installation`/`Rework`/`Purchase`/`Bill`/`Other`). `HouseHistoryModel.HistoryDate` stays `DateOnly` (not `DateTime` like `CarHistoryModel.HistoryDate`) - House has no Car-style same-day-multiple-entries ordering need (a road trip's several refuel stops), so it reuses `CommonStorageMappings` (`Infrastructure.MongoDb/Mappers/`), the shared `DateOnly<->DateTime` UTC-stamping conversion every other date field in the app attaches via `[UseStaticMapper(typeof(CommonStorageMappings))]`, for free instead of Car's bespoke hand-written `DateTime.SpecifyKind`/`ModalTimeText` "HH:mm" proxy machinery. `HouseHistoryModel.Provider` is a single field (contractor/technician/utility company/store name) covering every category, unlike Car's Refuel-only `StationBrandName` vs. Maintenance-only `Garage` split - House has no event type where "who was involved" doesn't apply, so one field suffices. - -`HouseDetail.razor`'s yearly cost chart is a single-series bar chart (total cost per year) plus a plain HTML breakdown table underneath (rows = years, columns = the 6 categories + total), not a 6-color stacked bar chart - a stacked chart with that many categories would be visually noisy and add real code, and the table already carries the actual per-category precision an insurance review needs at a glance. The chart's axis-drawing code (`ChartGeometry`, `RenderAxes`, `EvenlySpacedIndices`) was extracted from `CarDetail.razor` into `src/BlazorApp/Components/Shared/SvgChartHelpers.cs` specifically so House's chart wouldn't duplicate it - the CLAUDE.md "no duplicated algorithms" quality bar applies to Razor-hosted chart code the same as any other logic. Only the axis/geometry math moved; each page's own series-drawing loop (Car's stacked 2-series cost bars, Car's single-series consumption line, House's single-series year bars) stays local, since that part differs enough per chart that forcing one shared renderer would have been the over-generalization the quality bar warns against. The shared CSS these charts need (`.kt-callout*`, `.kt-chart-axis-text`/`-title`, `.kt-chart-svg`, `.kt-sheet-table`, `.kt-chart-legend`/`.kt-legend-swatch`) moved from `CarDetail.razor.css` into `app.css` as plain global rules for the same reason - and as a side benefit, no longer need `::deep` to reach into child `*Row` components' markup, since global (non-isolated) CSS was never scoped to begin with. +`CarHistory` (owned by `Car`) and `Episode` (owned by `TvShow`) are separate top-level collections referencing their parent by id (`car_id`, `tv_show_id`), not embedded arrays. +This is deliberate MongoDB schema design, not an accident: these child collections can grow unbounded per parent over years of use. +Features that need to query the child across *all* of a user's parents at once (e.g. Watch Next, below) need a plain indexed query rather than an `$unwind` aggregation. +Embedding is the right call for genuinely small, always-together, never-queried-alone data; neither condition holds here. +`EpisodeRepository.GetFilter`/`CarHistoryRepository.GetFilter` both filter their parent-id field (`TvShowId`/`CarId`) with `Eq`, not `Text`. +An exact-id filter used `Text` in `CarHistory`'s first draft, throwing whenever a free-text `search` was also supplied (MongoDB allows only one `$text` expression per query). +This was fixed and is covered by `docs/code-quality-findings.md`. +New multi-word BSON fields get an explicit `[BsonElement("snake_case_name")]`; don't rely on the `CamelCaseElementNameConvention` registered in `AddMongoDbInfrastructure`. +Every existing multi-word field already overrides it explicitly, so it's effectively dead configuration. +Indexes for new collections are declared in `scripts/mongodb-create-index.js` (natural-key uniqueness, query-shape support, and partial indexes for sparse boolean flags like `is_favorite`/`want_to_watch`). + +`CarHistoryModel.EventType` (`CarHistoryType`: `Refuel`/`Maintenance`/`Other`) is a real discriminated enum, not free text. +This follows the same "never name a property/field bare `Type`" rule as any other discriminator in this codebase (see `TvShowModel.State`'s own rename history above). +A bare `Type` reads ambiguously and collides in spirit with `object.GetType()`/`System.Type`. +`Car.EnergyType` (`CarEnergyType`: `Combustion`/`Hybrid`/`Electric`) and `CarHistoryModel.EventType`/`CarId`/`HistoryDate` are all `required` on both the Domain model and the Mongo entity. +`CarDto` itself can't mirror `Name`/`EnergyType` as `required`, because `Cars.razor` extends `InventoryPageBase`, which needs a bare `new()` constraint — a type with *any* `required` member can't satisfy `new()` in C#. +So the Dto layer stays nullable there by hard language necessity, not by choice (`CarHistoryDto` has no such constraint, so it mirrors `required` in full). +`CarHistoryModel.DeltaMileage` is real user-entered data (typically read off the car's own trip computer at refuel time), not a derived/computed field. +It's kept specifically so `Domain/Services/CarMetricsService.cs` can cross-check it against consecutive `Mileage` readings and flag a likely typo or a skipped entry. +This is the automated version of a manual spreadsheet cross-check, and the reason this field was kept rather than dropped as "unused" during review. +`CarMetricsService` (consumption — only ever computed across a full refill/recharge, never a partial one — cost-of-ownership history, mileage warnings, next-maintenance-due) follows `WatchNextService`'s shape. +It's a plain, `AddSingleton`-registered, unit-tested pure computation class with no persistence of its own. +It's exposed via `CarController.GetMetrics` the same way `VideoGameController.RefreshReference` adds an extra per-item action to an entity's own CRUD controller instead of a separate cross-entity controller. + +`House`/`HouseHistory` (owned-by-a-parent, same shape as `Car`/`CarHistory` above) is a deliberately smaller sibling, not a second copy of Car's design. +The priority (confirmed with the owner) is an exhaustive, browsable action log for insurance purposes plus a yearly cost review, not fuel/mileage tracking or reminders. +The owner tracks recurring bills/maintenance schedules elsewhere and explicitly asked for reminders to stay out of scope ("keep it simple, not important, I manage it elsewhere"). +Concretely: `HouseHistoryModel` has no `Mileage`/`DeltaMileage`/fuel fields, no location sub-fields (a house doesn't move, unlike a car's refuel stops). +`Domain/Services/HouseMetricsService.cs` has no `ComputeNextMaintenanceDue`-style due-date engine - it only computes `ComputeAnnualCostHistory` (cost per year, broken down by `HouseEventType`: `Maintenance`/`Installation`/`Rework`/`Purchase`/`Bill`/`Other`). +`HouseHistoryModel.HistoryDate` stays `DateOnly` (not `DateTime` like `CarHistoryModel.HistoryDate`) - House has no Car-style same-day-multiple-entries ordering need (a road trip's several refuel stops). +So it reuses `CommonStorageMappings` (`Infrastructure.MongoDb/Mappers/`), the shared `DateOnly<->DateTime` UTC-stamping conversion every other date field in the app attaches via `[UseStaticMapper(typeof(CommonStorageMappings))]`, for free. +This avoids Car's bespoke hand-written `DateTime.SpecifyKind`/`ModalTimeText` "HH:mm" proxy machinery. +`HouseHistoryModel.Provider` is a single field (contractor/technician/utility company/store name) covering every category, unlike Car's Refuel-only `StationBrandName` vs. Maintenance-only `Garage` split. +House has no event type where "who was involved" doesn't apply, so one field suffices. + +`HouseDetail.razor`'s yearly cost chart is a single-series bar chart (total cost per year) plus a plain HTML breakdown table underneath (rows = years, columns = the 6 categories + total), not a 6-color stacked bar chart. +A stacked chart with that many categories would be visually noisy and add real code, and the table already carries the actual per-category precision an insurance review needs at a glance. +The chart's axis-drawing code (`ChartGeometry`, `RenderAxes`, `EvenlySpacedIndices`) was extracted from `CarDetail.razor` into `src/BlazorApp/Components/Shared/SvgChartHelpers.cs` specifically so House's chart wouldn't duplicate it. +The CLAUDE.md "no duplicated algorithms" quality bar applies to Razor-hosted chart code the same as any other logic. +Only the axis/geometry math moved; each page's own series-drawing loop (Car's stacked 2-series cost bars, Car's single-series consumption line, House's single-series year bars) stays local. +That part differs enough per chart that forcing one shared renderer would have been the over-generalization the quality bar warns against. +The shared CSS these charts need (`.kt-callout*`, `.kt-chart-axis-text`/`-title`, `.kt-chart-svg`, `.kt-sheet-table`, `.kt-chart-legend`/`.kt-legend-swatch`) moved from `CarDetail.razor.css` into `app.css`. +It's now plain global rules, for the same reason. +As a side benefit, they no longer need `::deep` to reach into child `*Row` components' markup, since global (non-isolated) CSS was never scoped to begin with. ### Reference data (shared, owner-less) -`tvshow_reference` and `movie_reference` (`Domain/Models/TvShowReferenceModel.cs`/`MovieReferenceModel.cs`, `Infrastructure.MongoDb/Entities/TvShowReference.cs`/`MovieReference.cs`) hold metadata (synopsis, episode titles) fetched from TMDB. They are the one deliberate exception to "every collection has `owner_id`": this data is public facts about a real show/movie, not user content, so storing it once and pointing every tenant's `TvShowModel.ReferenceId`/`MovieModel.ReferenceId` at it avoids duplicating the same show across every user who tracks it. Matching key is normalized title + year (`TitleNormalizer.Normalize`, `Common.System/TitleNormalizer.cs` — shared with `TvTimeImportService` so the two never drift on what counts as "the same title"). The rest of this section walks through the mechanics using TV shows/movies/TMDB as the concrete example; `book_reference`/`videogame_reference`/`album_reference` (Open Library/RAWG/Discogs) follow the identical shape - see "Reference data now covers five domains" further down for what's shared versus what's provider-specific. - -These repositories (`ITvShowReferenceRepository`/`IMovieReferenceRepository`) do **not** extend `IDataRepository` or `MongoDbRepositoryBase` — both are hard-constrained to `IHasIdAndOwnerId` and owner-scoped paged CRUD, which doesn't fit a shared lookup table with a different method set (`FindByTitleYearAsync`, `UpsertAsync`). Don't force a new owner-less collection through that base; write a small purpose-built repository instead, like these two. - -`TvShowReferenceModel.Episodes` is **embedded**, the opposite choice from the per-tenant `Episode` collection. This isn't inconsistent - the access pattern is opposite too: a reference show's episode list is bounded to its real runtime, always fetched as a whole (rendering a season picker needs all of it at once), and never queried across shows. That's exactly the case CLAUDE.md already says favors embedding; the per-tenant `Episode` collection fails all three conditions (unbounded per-user growth, queried across shows for Watch Next, upserted independently), which is why that one is referenced instead. - -`WebApi/ReferenceData/ReferenceEnrichmentService.cs` is the single place that resolves a title+year to a TMDB id and propagates the result to every tenant's matching document via `ITvShowRepository.SetReferenceLinkAsync`/`IMovieRepository`'s equivalent - both the automatic best-effort match (fired from `TvShowController`/`MovieController`'s `OnCreatedAsync` hook on `DataCrudControllerBase`, and from `TvTimeImportService` after each newly-imported show/movie) and the admin's manual pick (`ReferenceDataAdminController`) call through this one method rather than duplicating the "upsert reference doc, then propagate" logic. The automatic path only ever acts on a *single, confident* TMDB search result - zero or multiple candidates leaves the item unresolved for the admin queue rather than guessing (the same "don't guess when you don't have the info" principle as Watch Next, below). `SetReferenceLinkAsync` sets `ReferenceId`, `Title` (the TMDB canonical name) and, when the reference has one, `Year` (the TMDB canonical year) in the same update - linking is meant to correct whatever title/year the tenant originally typed/imported, not just attach an id, and pre-populating `Year` from a trustworthy source beats leaving it at whatever the tenant originally guessed. `Year` stays freely editable afterward on `MovieDetail.razor`/`TvShowDetail.razor` (same as `Title` - see the paragraph on `TryLinkExistingTvShowReferenceAsync` below for why), so this is a starting value, not a lock. - -`TvShowReferenceModel`/`MovieReferenceModel.MatchedAliases` is a `List` of every (title, year) combination ever confirmed (via a TMDB resolution, automatic or admin-picked) to mean this exact show/movie - not just the document's own canonical `TitleNormalized`/`Year`. `ResolveTvShowAsync`/`ResolveMovieAsync` populate it with **both** the (TMDB canonical title, TMDB canonical year) and whatever (title, year) the tenant actually searched with (`MergeMatchedAliases`, merged with any aliases a previous resolution already contributed - never overwritten), and `TvShowReferenceRepository`/`MovieReferenceRepository.UpsertAsync` additionally guarantees the document's own (`TitleNormalized`, `Year`) is always in the list even if a caller forgot. Year travels with its specific title variant rather than living as a single top-level scalar, because a title-only alias list isn't enough on its own: two tenants (or a tenant and TMDB's own canonical data) can legitimately record different years for the same real show - a French-language tenant's "Le Fil" (2002) and an English tenant's "The Wire" (2002) are one case this handles, but so is a tenant who recorded 2003 by mistake and TMDB's canonical year of 2002 - both should still resolve to the same document once *either* variant has been confirmed. `FindByTitleYearAsync`/`FindByTitleAsync` (on both reference repositories) query `MatchedAliases` with `Builders.Filter.ElemMatch` (both the title and year condition must hold on the *same* embedded array element - a plain `AnyEq`-per-field approach would let a title match on one alias and a year match on a completely different one) instead of a plain `Eq` against `TitleNormalized`/`Year`; `scripts/mongodb-create-index.js`'s `tvshow_reference_title_year`/`movie_reference_title_year` indexes were changed to a compound multikey index over `matched_aliases.title`/`matched_aliases.year` accordingly - a single compound index over two sub-fields of the *same* array is fine, unlike trying to combine two *different* array fields in one compound index, which MongoDB disallows. - -`ReferenceEnrichmentService.TryLinkExistingTvShowReferenceAsync`/`TryLinkExistingMovieReferenceAsync` is a second, cheaper resolution path that never calls TMDB: it only checks whether a matching reference document *already exists* (title+year, falling back to title-only, against `MatchedAliases`). This backs `POST /api/tv-shows/{id}/refresh-reference`/`/api/movies/{id}/refresh-reference` - a "check for reference match" control shown **unconditionally** on both detail pages (not just when unresolved) to **any** authenticated user, not just admins, since it can never do anything beyond reusing a fact some other tenant (or an admin) already established. It's unconditional deliberately: `Title` and `Year` are both freely editable at any time, and a tenant who thinks their current link is wrong (two different real movies sharing an identical title is common - year and cast/poster are often the only way to tell them apart) needs to be able to edit either and re-check *even though something is already linked*, to replace a bad match - the method does **not** short-circuit on an existing `ReferenceId` for exactly this reason. When a match is found it updates only this tenant's own document directly (`ITvShowRepository.UpdateAsync`/`IMovieRepository`'s equivalent), setting `Year` to the reference's own canonical year alongside `Title` and `ReferenceId` (same rationale as `SetReferenceLinkAsync` above), rather than the broad cross-tenant `SetReferenceLinkAsync` (which refuses to touch already-linked documents by design, so it wouldn't fix a wrong link on this tenant's own item) - but it still also calls `SetReferenceLinkAsync` with the pre-edit title/year afterward, so any other still-unresolved tenant sharing that text benefits too. When **no** match is found for the current title/year and the document *was* linked, the link is cleared (`ReferenceId` set to `""`) rather than left pointing at something the tenant just told us, by editing the title, is wrong - clearing it is also exactly what puts the item back into the admin's unresolved queue (`FindDistinctUnresolvedTitleYearsAsync`) for a manual TMDB search. This is deliberately explicit/user-triggered rather than automatic on every page view (no `GetById` side effect), so the behavior stays visible and predictable. It's also why `Title`/`Year` are unconditionally editable on both `MovieDetail.razor`/`TvShowDetail.razor` regardless of link status - free editing is what makes "fix a typo or a wrong year (or pick a different match), then hit refresh" work, and `Year` matters here specifically because TMDB search results embedding a year into the title text (e.g. "Dune 2021") is unreliable - the tip that used to suggest doing that was wrong and has been removed; the actual matching (both this local lookup and the live TMDB search behind `InlineReferenceLinker`) always takes year as its own separate field/parameter, never parsed out of title text. The list edit modal (`Movies.razor`/`TvShows.razor`) still locks `Title` for non-admins once linked - that's a separate, intentionally stricter surface for bulk-editing, not an inconsistency to reconcile. - -**Gotcha:** the title-only fallback in `TryLinkExistingTvShowReferenceAsync`/`TryLinkExistingMovieReferenceAsync` must run unconditionally, *including* when the tenant's `Year` is `null` - an earlier version only attempted it when `Year is not null`, which is backwards: a tenant with no year recorded at all is exactly the case that needs the year-agnostic fallback most, since `FindByTitleYearAsync(title, null)` can only ever match a reference whose own `Year` is also `null`. Skipping the fallback there meant any linked item with an unset year would unlink itself the instant "check for reference match" was clicked, since neither query could succeed. Confirmed by a real user hitting this on a genuinely valid, already-linked title. - -`ResolveTvShowAsync`/`ResolveMovieAsync`'s "does a reference document already exist for this" check now looks up by TMDB id first (`ITvShowReferenceRepository`/`IMovieReferenceRepository.FindByExternalIdAsync`, same shape as `IPersonReferenceRepository`'s cast-dedup lookup), falling back to title+year/title-only only when no document has that id yet. Title-text matching alone isn't reliable enough to prevent duplicates: two tenants (or an admin resolving the same unresolved queue twice under different title text - a translation, or a typo the admin fixed) can easily resolve the *same* TMDB entry through completely different search strings, and if the existence check only compares title text, the second resolution creates a second reference document for what's genuinely the same movie/show instead of updating the first. The TMDB id is the one signal that's invariant under any title text difference, so it's checked first and is authoritative. - -`scripts/mongodb-create-index.js`'s `tvshow_reference_tmdb_id`/`movie_reference_tmdb_id`/`person_reference_tmdb_id` indexes are `unique: true` with a `partialFilterExpression: { "external_ids.tmdb": { $exists: true } }` - the application-level id-first dedup check above is what's *supposed* to prevent two documents sharing a TMDB id, but a database constraint is what actually guarantees it can never happen even if a future code path forgets to check. The partial filter (rather than a plain unique index, or the older `sparse: true` option) is required because it's only `external_ids.tmdb` that must be unique *when present* - a document from before this field existed (or any owner-less collection document that's never linked to that provider) has no such key at all, and a plain unique index would treat every one of those "missing the field" documents as colliding on the same null key. - -Reference data is meant to be portable across environments, not re-earned from TMDB one search at a time per deployment: `ReferenceDataAdminController`'s `GET/POST /api/reference-data/export`/`import` round-trip the entire `tvshow_reference`/`movie_reference`/`person_reference` collections as a zip of JSON arrays. Idempotency here is free, not new logic - every repository's existing `UpsertAsync` already replaces-by-id when the model carries one, so re-importing the same export twice is a no-op the second time by construction. `FindAllAsync()` on each of the three reference repositories exists solely to back this export; it's an unpaged full-collection read, acceptable because this data is small and shared (not per-tenant). - -`TvTimeImportService`'s per-show/per-movie reference match (`TryEnrichShowAsync`/`TryEnrichMovieAsync`) fires on its own DI scope via `IServiceScopeFactory` (same shape as `TvShowController`/`MovieController.OnCreatedAsync`) rather than being awaited inline - a bulk import creating dozens of new shows/movies must not block on a sequential chain of TMDB HTTP calls (search + details + credits, per item) before the import job itself can report "Completed". If TV Time import feels slow again, check this path before assuming it's a missing Mongo index (already fully audited once - see `docs/code-quality-findings.md`). - -**Gotcha (historical - fixed by the AutoMapper -> Mapperly migration, but old data still needs this):** "does this tenant document have no reference link yet" cannot be a plain `Eq(x => x.ReferenceId, null)` filter. Under AutoMapper, `AllowNullDestinationValues = false` made mapping a model whose string property is null store an **empty string**, never an actual BSON null; documents written that way still exist. `TvShowRepository`/`MovieRepository`'s `UnresolvedFilter()` matches null *or* empty string for exactly this reason - copy that helper's shape (not a bare null check) for any new "is this string field unset" query, even now that new writes store a real null (Mapperly preserves nulls by default). This one is easy to get wrong silently: it doesn't throw, it just quietly matches zero documents. A real-MongoDB integration test (`TvShowReferenceLinkingTest`) is what caught it originally, not the unit tests (which mock the repository and never see the actual serialization behavior). - -**Second instance of the same gotcha (also historical - see `docs/automapper-removal-plan.md`):** AutoMapper's `AllowNullDestinationValues = false` used to also change `mapper.Map(source)` when `source` itself (not just one of its properties) was `null` - instead of returning `null`, it returned a new, all-default instance of `TDestination`. Mapperly (the current mapper) takes the opposite, honest approach: it *throws* on a null source rather than fabricating a default instance, which is exactly why the `entity is null` guard below still matters, just for a different reason now. Every `Find*Async` method on `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository` does `var entity = await Collection.Find(...).FirstOrDefaultAsync();` where `entity` can legitimately be null (nothing matched) - mapping it directly would either fabricate a fake found-but-empty model (old AutoMapper behavior) or throw (current Mapperly behavior), neither of which is the `null` that `ReferenceDataController`'s `model is null` 404 check (and anything else checking `is null` on a Find result) needs. Each of those methods checks `entity is null` before calling the mapper, returning `null` directly instead. **This isn't limited to the owner-less reference repositories**: `MongoDbRepositoryBase.FindOneAsync` (the shared base every ordinary owner-scoped repository extends) has the exact same shape and needs the exact same guard - every entity's `GetById` 404 check depends on it. Copy this guard for any new Find method that can legitimately return "nothing matched," anywhere in the codebase, not just the owner-less collections - a mocked-repository unit test cannot catch a regression here, only a real MongoDB integration test can (a mock never exercises the real mapper/serialization behavior). - -The reference layer also now has `Genres`, `Cast` (embedded `CastMemberModel` list, pointing at a third owner-less collection, `person_reference` - actors are deduplicated across every show/movie that credits them, keyed by TMDB person id via `IPersonReferenceRepository.FindByExternalIdAsync`, not by name), and `PosterUrl`/`CastMemberDto.ProfileImageUrl`. Images are **hotlinked directly from TMDB's CDN** (`https://image.tmdb.org/t/p/{size}{path}`, built once in `TmdbClient` and stored as a plain URL) rather than downloaded and re-hosted - confirmed this is TMDB's own sanctioned, standard usage pattern (a separate, unauthenticated static-asset host, not the rate-limited API), so there's no local storage/volume/static-file-serving subsystem to operate. `CastMemberDto` is fully hydrated server-side (`ReferenceDataController` joins the embedded cast list against `person_reference`) specifically because that join needs repository access a generated mapper doesn't have - `TvShowReferenceDtoMapper`/`MovieReferenceDtoMapper` (`WebApi/Mappers/`) ignore `Cast` via `[MapperIgnoreTarget]` for exactly this reason; don't try to make it a plain mapped member. - -`TvShowDetail.razor`'s episode list is a full watch-through checklist (every reference episode, checkbox = watched) once the show has a `ReferenceId`, falling back to the original recorded-episodes-only view with a manual add form when it doesn't (there's no way to know the full episode count without reference data, so that fallback is a deliberate scope boundary, not a bug). Checking a box creates an `Episode` with `WatchedAt = today`; unchecking deletes it - there's no way to set an arbitrary watched date from this view once a show is resolved. - -Admin-only endpoints (`ReferenceDataAdminController`) use policy-based authorization (`[Authorize(Policy = "AdminOnly")]`, registered in both `WebApi/Program.cs` and `BlazorApp/Program.cs` as `RequireClaim("role", "admin")`), backed by a Firebase custom claim - not ASP.NET's built-in `Roles=` support, since Firebase's claim arrives as a plain `"role"` claim rather than the `ClaimTypes.Role` URI that `[Authorize(Roles=...)]`/`` expect by default. `BlazorApp/Components/Account/Controllers/AuthenticationController.cs` copies the `role` claim from the verified Firebase token into the cookie principal at sign-in - WebApi validates the bearer token's claims directly and needs no equivalent step. There's no in-app way to grant the first admin; it's a one-off `setCustomUserClaims` call via the Firebase Admin SDK (see `CONTRIBUTING.md`). - -**Gotcha:** `WebApi/Program.cs`'s `AddJwtBearer` sets `options.MapInboundClaims = false` deliberately. Without it, the token handler silently renames certain short JWT claim names to legacy `ClaimTypes.*` URIs before `HttpContext.User` ever sees them - `"role"` is one of the remapped names (to `ClaimTypes.Role`), so `RequireClaim("role", "admin")` would never match even though the raw token genuinely has a `role` claim. This is exactly why the Blazor side (whose cookie principal is built by hand in `AuthenticationController`, using the literal claim name) could show the admin nav link while the same request's bearer-token call to WebApi still 403'd - the two sides were checking different claim types for what was, on the wire, the same claim. `user_id` was never affected by this because it isn't one of the handful of short names the legacy map remaps; don't assume a new custom claim is equally safe without checking, or just leave `MapInboundClaims = false` alone. +`tvshow_reference` and `movie_reference` (`Domain/Models/TvShowReferenceModel.cs`/`MovieReferenceModel.cs`, `Infrastructure.MongoDb/Entities/TvShowReference.cs`/`MovieReference.cs`) hold metadata (synopsis, episode titles) fetched from TMDB. +They are the one deliberate exception to "every collection has `owner_id`": this data is public facts about a real show/movie, not user content. +So storing it once and pointing every tenant's `TvShowModel.ReferenceId`/`MovieModel.ReferenceId` at it avoids duplicating the same show across every user who tracks it. +Matching key is normalized title + year (`TitleNormalizer.Normalize`, `Common.System/TitleNormalizer.cs` — shared with `TvTimeImportService` so the two never drift on what counts as "the same title"). +The rest of this section walks through the mechanics using TV shows/movies/TMDB as the concrete example. +`book_reference`/`videogame_reference`/`album_reference` (Open Library/RAWG/Discogs) follow the identical shape - see "Reference data now covers five domains" further down for what's shared versus what's provider-specific. + +These repositories (`ITvShowReferenceRepository`/`IMovieReferenceRepository`) do **not** extend `IDataRepository` or `MongoDbRepositoryBase`. +Both are hard-constrained to `IHasIdAndOwnerId` and owner-scoped paged CRUD, which doesn't fit a shared lookup table with a different method set (`FindByTitleYearAsync`, `UpsertAsync`). +Don't force a new owner-less collection through that base; write a small purpose-built repository instead, like these two. + +`TvShowReferenceModel.Episodes` is **embedded**, the opposite choice from the per-tenant `Episode` collection. +This isn't inconsistent - the access pattern is opposite too: a reference show's episode list is bounded to its real runtime, always fetched as a whole (rendering a season picker needs all of it at once), and never queried across shows. +That's exactly the case CLAUDE.md already says favors embedding. +The per-tenant `Episode` collection fails all three conditions (unbounded per-user growth, queried across shows for Watch Next, upserted independently), which is why that one is referenced instead. + +`WebApi/ReferenceData/ReferenceEnrichmentService.cs` is the single place that resolves a title+year to a TMDB id. +It propagates the result to every tenant's matching document via `ITvShowRepository.SetReferenceLinkAsync`/`IMovieRepository`'s equivalent. +The automatic best-effort match is fired from `TvShowController`/`MovieController`'s `OnCreatedAsync` hook on `DataCrudControllerBase`, and from `TvTimeImportService` after each newly-imported show/movie. +Both it and the admin's manual pick (`ReferenceDataAdminController`) call through this one method. +This avoids duplicating the "upsert reference doc, then propagate" logic. +The automatic path only ever acts on a *single, confident* TMDB search result - zero or multiple candidates leaves the item unresolved for the admin queue rather than guessing. +This is the same "don't guess when you don't have the info" principle as Watch Next, below. +`SetReferenceLinkAsync` sets `ReferenceId`, `Title` (the TMDB canonical name) and, when the reference has one, `Year` (the TMDB canonical year) in the same update. +Linking is meant to correct whatever title/year the tenant originally typed/imported, not just attach an id, and pre-populating `Year` from a trustworthy source beats leaving it at whatever the tenant originally guessed. +`Year` stays freely editable afterward on `MovieDetail.razor`/`TvShowDetail.razor` (same as `Title` - see the paragraph on `TryLinkExistingTvShowReferenceAsync` below for why), so this is a starting value, not a lock. + +`TvShowReferenceModel`/`MovieReferenceModel.MatchedAliases` is a `List` of every (title, year) combination ever confirmed (via a TMDB resolution, automatic or admin-picked) to mean this exact show/movie. +This is not just the document's own canonical `TitleNormalized`/`Year`. +`ResolveTvShowAsync`/`ResolveMovieAsync` populate it with **both** the (TMDB canonical title, TMDB canonical year) and whatever (title, year) the tenant actually searched with. +This uses `MergeMatchedAliases`, merged with any aliases a previous resolution already contributed - never overwritten. +`TvShowReferenceRepository`/`MovieReferenceRepository.UpsertAsync` additionally guarantees the document's own (`TitleNormalized`, `Year`) is always in the list even if a caller forgot. +Year travels with its specific title variant rather than living as a single top-level scalar, because a title-only alias list isn't enough on its own. +Two tenants (or a tenant and TMDB's own canonical data) can legitimately record different years for the same real show. +A French-language tenant's "Le Fil" (2002) and an English tenant's "The Wire" (2002) are one case this handles. +So is a tenant who recorded 2003 by mistake and TMDB's canonical year of 2002 - both should still resolve to the same document once *either* variant has been confirmed. +`FindByTitleYearAsync`/`FindByTitleAsync` (on both reference repositories) query `MatchedAliases` with `Builders.Filter.ElemMatch` instead of a plain `Eq` against `TitleNormalized`/`Year`. +Both the title and year condition must hold on the *same* embedded array element - a plain `AnyEq`-per-field approach would let a title match on one alias and a year match on a completely different one. +`scripts/mongodb-create-index.js`'s `tvshow_reference_title_year`/`movie_reference_title_year` indexes were changed to a compound multikey index over `matched_aliases.title`/`matched_aliases.year` accordingly. +A single compound index over two sub-fields of the *same* array is fine, unlike trying to combine two *different* array fields in one compound index, which MongoDB disallows. + +`ReferenceEnrichmentService.TryLinkExistingTvShowReferenceAsync`/`TryLinkExistingMovieReferenceAsync` is a second, cheaper resolution path that never calls TMDB. +It only checks whether a matching reference document *already exists* (title+year, falling back to title-only, against `MatchedAliases`). +This backs `POST /api/tv-shows/{id}/refresh-reference`/`/api/movies/{id}/refresh-reference`. +That's a "check for reference match" control shown **unconditionally** on both detail pages (not just when unresolved) to **any** authenticated user, not just admins. +It can never do anything beyond reusing a fact some other tenant (or an admin) already established. +It's unconditional deliberately: `Title` and `Year` are both freely editable at any time. +A tenant who thinks their current link is wrong (two different real movies sharing an identical title is common - year and cast/poster are often the only way to tell them apart) needs to be able to edit either. +They need to be able to re-check *even though something is already linked*. +This is to replace a bad match. +The method does **not** short-circuit on an existing `ReferenceId` for exactly this reason. +When a match is found it updates only this tenant's own document directly (`ITvShowRepository.UpdateAsync`/`IMovieRepository`'s equivalent). +It sets `Year` to the reference's own canonical year alongside `Title` and `ReferenceId` (same rationale as `SetReferenceLinkAsync` above). +This is rather than the broad cross-tenant `SetReferenceLinkAsync` (which refuses to touch already-linked documents by design, so it wouldn't fix a wrong link on this tenant's own item). +But it still also calls `SetReferenceLinkAsync` with the pre-edit title/year afterward, so any other still-unresolved tenant sharing that text benefits too. +When **no** match is found for the current title/year and the document *was* linked, the link is cleared (`ReferenceId` set to `""`) rather than left pointing at something the tenant just told us, by editing the title, is wrong. +Clearing it is also exactly what puts the item back into the admin's unresolved queue (`FindDistinctUnresolvedTitleYearsAsync`) for a manual TMDB search. +This is deliberately explicit/user-triggered rather than automatic on every page view (no `GetById` side effect), so the behavior stays visible and predictable. +It's also why `Title`/`Year` are unconditionally editable on both `MovieDetail.razor`/`TvShowDetail.razor` regardless of link status - free editing is what makes "fix a typo or a wrong year (or pick a different match), then hit refresh" work. +`Year` matters here specifically because TMDB search results embedding a year into the title text (e.g. "Dune 2021") is unreliable - the tip that used to suggest doing that was wrong and has been removed. +The actual matching (both this local lookup and the live TMDB search behind `InlineReferenceLinker`) always takes year as its own separate field/parameter, never parsed out of title text. +The list edit modal (`Movies.razor`/`TvShows.razor`) still locks `Title` for non-admins once linked - that's a separate, intentionally stricter surface for bulk-editing, not an inconsistency to reconcile. + +**Gotcha:** the title-only fallback in `TryLinkExistingTvShowReferenceAsync`/`TryLinkExistingMovieReferenceAsync` must run unconditionally, *including* when the tenant's `Year` is `null`. +An earlier version only attempted it when `Year is not null`, which is backwards. +A tenant with no year recorded at all is exactly the case that needs the year-agnostic fallback most, since `FindByTitleYearAsync(title, null)` can only ever match a reference whose own `Year` is also `null`. +Skipping the fallback there meant any linked item with an unset year would unlink itself the instant "check for reference match" was clicked, since neither query could succeed. +Confirmed by a real user hitting this on a genuinely valid, already-linked title. + +`ResolveTvShowAsync`/`ResolveMovieAsync`'s "does a reference document already exist for this" check now looks up by TMDB id first. +This uses `ITvShowReferenceRepository`/`IMovieReferenceRepository.FindByExternalIdAsync`, same shape as `IPersonReferenceRepository`'s cast-dedup lookup. +It falls back to title+year/title-only only when no document has that id yet. +Title-text matching alone isn't reliable enough to prevent duplicates. +Two tenants (or an admin resolving the same unresolved queue twice under different title text - a translation, or a typo the admin fixed) can easily resolve the *same* TMDB entry through completely different search strings. +If the existence check only compares title text, the second resolution creates a second reference document for what's genuinely the same movie/show instead of updating the first. +The TMDB id is the one signal that's invariant under any title text difference, so it's checked first and is authoritative. + +`scripts/mongodb-create-index.js`'s `tvshow_reference_tmdb_id`/`movie_reference_tmdb_id`/`person_reference_tmdb_id` indexes are `unique: true` with a `partialFilterExpression: { "external_ids.tmdb": { $exists: true } }`. +The application-level id-first dedup check above is what's *supposed* to prevent two documents sharing a TMDB id, but a database constraint is what actually guarantees it can never happen even if a future code path forgets to check. +The partial filter (rather than a plain unique index, or the older `sparse: true` option) is required because it's only `external_ids.tmdb` that must be unique *when present*. +A document from before this field existed (or any owner-less collection document that's never linked to that provider) has no such key at all. +A plain unique index would treat every one of those "missing the field" documents as colliding on the same null key. + +Reference data is meant to be portable across environments, not re-earned from TMDB one search at a time per deployment. +`ReferenceDataAdminController`'s `GET/POST /api/reference-data/export`/`import` round-trip the entire `tvshow_reference`/`movie_reference`/`person_reference` collections as a zip of JSON arrays. +Idempotency here is free, not new logic - every repository's existing `UpsertAsync` already replaces-by-id when the model carries one, so re-importing the same export twice is a no-op the second time by construction. +`FindAllAsync()` on each of the three reference repositories exists solely to back this export; it's an unpaged full-collection read, acceptable because this data is small and shared (not per-tenant). + +`TvTimeImportService`'s per-show/per-movie reference match (`TryEnrichShowAsync`/`TryEnrichMovieAsync`) fires on its own DI scope via `IServiceScopeFactory`, same shape as `TvShowController`/`MovieController.OnCreatedAsync`. +It's not awaited inline. +A bulk import creating dozens of new shows/movies must not block on a sequential chain of TMDB HTTP calls (search + details + credits, per item) before the import job itself can report "Completed". +If TV Time import feels slow again, check this path before assuming it's a missing Mongo index (already fully audited once - see `docs/code-quality-findings.md`). + +**Gotcha (historical - fixed by the AutoMapper -> Mapperly migration, but old data still needs this):** "does this tenant document have no reference link yet" cannot be a plain `Eq(x => x.ReferenceId, null)` filter. +Under AutoMapper, `AllowNullDestinationValues = false` made mapping a model whose string property is null store an **empty string**, never an actual BSON null; documents written that way still exist. +`TvShowRepository`/`MovieRepository`'s `UnresolvedFilter()` matches null *or* empty string for exactly this reason. +Copy that helper's shape (not a bare null check) for any new "is this string field unset" query, even now that new writes store a real null (Mapperly preserves nulls by default). +This one is easy to get wrong silently: it doesn't throw, it just quietly matches zero documents. +A real-MongoDB integration test (`TvShowReferenceLinkingTest`) is what caught it originally, not the unit tests (which mock the repository and never see the actual serialization behavior). + +**Second instance of the same gotcha (also historical - see `docs/automapper-removal-plan.md`):** AutoMapper's `AllowNullDestinationValues = false` used to also change `mapper.Map(source)`. +This happened even when `source` itself (not just one of its properties) was `null`. +Instead of returning `null`, it returned a new, all-default instance of `TDestination`. +Mapperly (the current mapper) takes the opposite, honest approach: it *throws* on a null source rather than fabricating a default instance, which is exactly why the `entity is null` guard below still matters, just for a different reason now. +Every `Find*Async` method on `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository` does `var entity = await Collection.Find(...).FirstOrDefaultAsync();`. +`entity` can legitimately be null (nothing matched). +Mapping it directly would either fabricate a fake found-but-empty model (old AutoMapper behavior) or throw (current Mapperly behavior). +Neither of those is the `null` that `ReferenceDataController`'s `model is null` 404 check (and anything else checking `is null` on a Find result) needs. +Each of those methods checks `entity is null` before calling the mapper, returning `null` directly instead. +**This isn't limited to the owner-less reference repositories**: `MongoDbRepositoryBase.FindOneAsync` (the shared base every ordinary owner-scoped repository extends) has the exact same shape and needs the exact same guard. +Every entity's `GetById` 404 check depends on it. +Copy this guard for any new Find method that can legitimately return "nothing matched," anywhere in the codebase, not just the owner-less collections. +A mocked-repository unit test cannot catch a regression here, only a real MongoDB integration test can (a mock never exercises the real mapper/serialization behavior). + +The reference layer also now has `Genres`, `Cast` (embedded `CastMemberModel` list, pointing at a third owner-less collection, `person_reference`), and `PosterUrl`/`CastMemberDto.ProfileImageUrl`. +Actors are deduplicated across every show/movie that credits them, keyed by TMDB person id via `IPersonReferenceRepository.FindByExternalIdAsync`, not by name. +Images are **hotlinked directly from TMDB's CDN** (`https://image.tmdb.org/t/p/{size}{path}`, built once in `TmdbClient` and stored as a plain URL) rather than downloaded and re-hosted. +This is confirmed to be TMDB's own sanctioned, standard usage pattern (a separate, unauthenticated static-asset host, not the rate-limited API), so there's no local storage/volume/static-file-serving subsystem to operate. +`CastMemberDto` is fully hydrated server-side (`ReferenceDataController` joins the embedded cast list against `person_reference`) specifically because that join needs repository access a generated mapper doesn't have. +`TvShowReferenceDtoMapper`/`MovieReferenceDtoMapper` (`WebApi/Mappers/`) ignore `Cast` via `[MapperIgnoreTarget]` for exactly this reason; don't try to make it a plain mapped member. + +`TvShowDetail.razor`'s episode list is a full watch-through checklist (every reference episode, checkbox = watched) once the show has a `ReferenceId`, falling back to the original recorded-episodes-only view with a manual add form when it doesn't. +There's no way to know the full episode count without reference data, so that fallback is a deliberate scope boundary, not a bug. +Checking a box creates an `Episode` with `WatchedAt = today`; unchecking deletes it - there's no way to set an arbitrary watched date from this view once a show is resolved. + +Admin-only endpoints (`ReferenceDataAdminController`) use policy-based authorization (`[Authorize(Policy = "AdminOnly")]`, registered in both `WebApi/Program.cs` and `BlazorApp/Program.cs`). +The policy is `RequireClaim("role", "admin")`, backed by a Firebase custom claim. +This is not ASP.NET's built-in `Roles=` support. +Firebase's claim arrives as a plain `"role"` claim rather than the `ClaimTypes.Role` URI that `[Authorize(Roles=...)]`/`` expect by default. +`BlazorApp/Components/Account/Controllers/AuthenticationController.cs` copies the `role` claim from the verified Firebase token into the cookie principal at sign-in. +WebApi validates the bearer token's claims directly and needs no equivalent step. +There's no in-app way to grant the first admin; it's a one-off `setCustomUserClaims` call via the Firebase Admin SDK (see `CONTRIBUTING.md`). + +**Gotcha:** `WebApi/Program.cs`'s `AddJwtBearer` sets `options.MapInboundClaims = false` deliberately. +Without it, the token handler silently renames certain short JWT claim names to legacy `ClaimTypes.*` URIs before `HttpContext.User` ever sees them. +`"role"` is one of the remapped names (to `ClaimTypes.Role`), so `RequireClaim("role", "admin")` would never match even though the raw token genuinely has a `role` claim. +This is exactly why the Blazor side (whose cookie principal is built by hand in `AuthenticationController`, using the literal claim name) could show the admin nav link while the same request's bearer-token call to WebApi still 403'd. +The two sides were checking different claim types for what was, on the wire, the same claim. +`user_id` was never affected by this because it isn't one of the handful of short names the legacy map remaps; don't assume a new custom claim is equally safe without checking, or just leave `MapInboundClaims = false` alone. ### Web API request flow -`DataCrudControllerBase` (`WebApi/Controllers/DataCrudControllerBase.cs`) implements the full CRUD surface (`GET`, `GET/{id}`, `POST`, `PUT/{id}`, `DELETE/{id}`) once, generically. It calls the shared `ControllerBaseExtensions.GetUserId()` extension (`WebApi/Controllers/ControllerBaseExtensions.cs`) to read the caller's `user_id` claim, scope every query, and stamp `OwnerId` on writes, so per-type controllers only need routing and generic type arguments — any new controller (CRUD or not) should call the same extension rather than re-reading the claim. Unhandled exceptions are converted to JSON error responses by `ApiExceptionFilterAttribute` (`ArgumentException`/`ArgumentNullException` -> 400, everything else -> 500), which also logs every caught exception via `ILogger` before converting it - a 500 leaves a server-side trail to diagnose, not just an opaque error in the browser. - -**Resilience against failing external providers.** TMDB/RAWG/Open Library/Discogs (`WebApi/ReferenceData/`'s `TmdbClient`/`RawgClient`/`OpenLibraryClient`/`DiscogsClient`) are third-party APIs outside Keeptrack's control - slow, rate-limited, or briefly down is a "when," not an "if." Each of their four `AddHttpClient<...>()` registrations in `Program.cs` chains `.AddStandardResilienceHandler()` (`Microsoft.Extensions.Http.Resilience`), giving every call automatic retry, a per-attempt timeout, a total-request timeout, and a circuit breaker - a transient failure is retried and recovered without the caller ever seeing it, and a provider that's genuinely down fails with a normal exception (mapped to a clean JSON 500 by `ApiExceptionFilterAttribute` above) instead of hanging a request thread indefinitely or degrading the whole app under concurrent load. Give any future outbound HTTP client to a third-party service the same treatment - `.AddStandardResilienceHandler()` is a one-line addition to the `AddHttpClient<...>()` chain, not something to hand-roll per client. Covered by `ExternalProviderResilienceTest` (`test/WebApi.UnitTests/ReferenceData/`), which builds the exact same wiring against a stub `HttpMessageHandler` (no real network) and asserts both halves: a transient failure is retried and recovered, and a provider that stays down fails cleanly rather than hanging - tested once against `RawgClient` as a representative example, since the wiring is identical for all four and duplicating the same test four times would add nothing. - -`builder.Services.Configure(opts => opts.BackgroundServiceExceptionBehavior = BackgroundServiceExceptionBehavior.Ignore)` in `Program.cs` is a separate, systemic safety net: by default, an unhandled exception escaping any hosted `BackgroundService.ExecuteAsync` (like `ReferenceSyncBackgroundService`) stops the *entire host*, taking every other endpoint down with it, not just the background job. `ReferenceSyncBackgroundService`/`ReferenceSyncService` already catch and log everything they can anticipate (see "Keeping reference data fresh" below), but this setting is the backstop for whatever a future background service's own error handling misses - `Ignore` logs the failure and keeps the rest of the app serving requests instead of crashing the process. Apply the same reasoning before adding a new `AddHostedService<...>()`: its own `ExecuteAsync` should still catch what it can anticipate (this global setting isn't a substitute for that), but a bug in it should never be able to take down unrelated endpoints. - -Not every endpoint is per-item CRUD. `WatchNextController`/`WishlistController` (read-only cross-entity aggregations) live in `WebApi/Controllers/` like every other controller, with a plain `ControllerBase` rather than being force-fit into `DataCrudControllerBase`; their computation lives in `Domain/Services/` (`WatchNextService`, `WishlistService`) since it's pure logic over Domain models with no persistence or web dependency - Domain's stated charter from the project-overview table above. `WebApi/Import/` (the TV Time GDPR-export upsert, using `CsvHelper` for parsing) and `WebApi/ReferenceData/` still follow the older feature-folder shape (a `ControllerBase` and service class colocated under `WebApi//`) - this is now recognized as the same misplacement `WatchNext` had, but migrating them is deliberately deferred to a separate change to limit regression surface and manual-testing burden. Don't extend the older feature-folder shape to new code; follow `WatchNextController`/`WishlistController`'s split instead (controller in `Controllers/`, pure computation in `Domain/Services/` when there is any). - -`seen_episode_source.csv` alone is a drastically incomplete picture of a user's episode history (it's only written when an episode is marked watched via TV Time's episode-detail screen) - confirmed against real export data, not assumed. `TvTimeImportService` also reads `tracking-prod-records.csv` and `tracking-prod-records-v2.csv`, TV Time's generic event logs, which capture episodes marked watched any other way (bulk/season actions). All three are merged and de-duplicated per (show, season, episode), earliest date wins, before upserting `Episode`s. If a future TV Time export field looks suspiciously sparse, check the raw export files directly (`grep` the show name across every `*.csv`) before assuming the current parser set is complete - this is exactly how the tracking files were found. - -`followed_tv_show.csv` is not a complete list of shows either - confirmed with a real show ("The Pitt") that has genuine watch history in the tracking files but no row in `followed_tv_show.csv` at all. `ImportEpisodesAsync` creates a show on the fly from watch-event data (title, plus the show's TV Time id when the source file has one, applying the same rating/favorite/notes enrichment a normally-followed show gets) rather than skipping shows that aren't already known. Don't reintroduce a "skip if not already followed" check here. +`DataCrudControllerBase` (`WebApi/Controllers/DataCrudControllerBase.cs`) implements the full CRUD surface (`GET`, `GET/{id}`, `POST`, `PUT/{id}`, `DELETE/{id}`) once, generically. +It calls the shared `ControllerBaseExtensions.GetUserId()` extension (`WebApi/Controllers/ControllerBaseExtensions.cs`) to read the caller's `user_id` claim, scope every query, and stamp `OwnerId` on writes. +Per-type controllers only need routing and generic type arguments — any new controller (CRUD or not) should call the same extension rather than re-reading the claim. +Unhandled exceptions are converted to JSON error responses by `ApiExceptionFilterAttribute` (`ArgumentException`/`ArgumentNullException` -> 400, everything else -> 500). +It also logs every caught exception via `ILogger` before converting it - a 500 leaves a server-side trail to diagnose, not just an opaque error in the browser. + +**Resilience against failing external providers.** TMDB/RAWG/Open Library/Discogs (`WebApi/ReferenceData/`'s `TmdbClient`/`RawgClient`/`OpenLibraryClient`/`DiscogsClient`) are third-party APIs outside Keeptrack's control. +Slow, rate-limited, or briefly down is a "when," not an "if." +Each of their four `AddHttpClient<...>()` registrations in `Program.cs` chains `.AddStandardResilienceHandler()` (`Microsoft.Extensions.Http.Resilience`). +This gives every call automatic retry, a per-attempt timeout, a total-request timeout, and a circuit breaker. +A transient failure is retried and recovered without the caller ever seeing it. +A provider that's genuinely down fails with a normal exception (mapped to a clean JSON 500 by `ApiExceptionFilterAttribute` above) instead of hanging a request thread indefinitely or degrading the whole app under concurrent load. +Give any future outbound HTTP client to a third-party service the same treatment. +`.AddStandardResilienceHandler()` is a one-line addition to the `AddHttpClient<...>()` chain, not something to hand-roll per client. +Covered by `ExternalProviderResilienceTest` (`test/WebApi.UnitTests/ReferenceData/`), which builds the exact same wiring against a stub `HttpMessageHandler` (no real network). +It asserts both halves: a transient failure is retried and recovered, and a provider that stays down fails cleanly rather than hanging. +This was tested once against `RawgClient` as a representative example, since the wiring is identical for all four and duplicating the same test four times would add nothing. + +`builder.Services.Configure(opts => opts.BackgroundServiceExceptionBehavior = BackgroundServiceExceptionBehavior.Ignore)` in `Program.cs` is a separate, systemic safety net. +By default, an unhandled exception escaping any hosted `BackgroundService.ExecuteAsync` (like `ReferenceSyncBackgroundService`) stops the *entire host*, taking every other endpoint down with it, not just the background job. +`ReferenceSyncBackgroundService`/`ReferenceSyncService` already catch and log everything they can anticipate (see "Keeping reference data fresh" below). +This setting is the backstop for whatever a future background service's own error handling misses. +`Ignore` logs the failure and keeps the rest of the app serving requests instead of crashing the process. +Apply the same reasoning before adding a new `AddHostedService<...>()`: its own `ExecuteAsync` should still catch what it can anticipate (this global setting isn't a substitute for that). +A bug in it should never be able to take down unrelated endpoints. + +Not every endpoint is per-item CRUD. +`WatchNextController`/`WishlistController` (read-only cross-entity aggregations) live in `WebApi/Controllers/` like every other controller, with a plain `ControllerBase` rather than being force-fit into `DataCrudControllerBase`. +Their computation lives in `Domain/Services/` (`WatchNextService`, `WishlistService`) since it's pure logic over Domain models with no persistence or web dependency - Domain's stated charter from the project-overview table above. +`WebApi/Import/` (the TV Time GDPR-export upsert, using `CsvHelper` for parsing) and `WebApi/ReferenceData/` still follow the older feature-folder shape (a `ControllerBase` and service class colocated under `WebApi//`). +This is now recognized as the same misplacement `WatchNext` had, but migrating them is deliberately deferred to a separate change to limit regression surface and manual-testing burden. +Don't extend the older feature-folder shape to new code; follow `WatchNextController`/`WishlistController`'s split instead (controller in `Controllers/`, pure computation in `Domain/Services/` when there is any). + +`seen_episode_source.csv` alone is a drastically incomplete picture of a user's episode history (it's only written when an episode is marked watched via TV Time's episode-detail screen) - confirmed against real export data, not assumed. +`TvTimeImportService` also reads `tracking-prod-records.csv` and `tracking-prod-records-v2.csv`, TV Time's generic event logs, which capture episodes marked watched any other way (bulk/season actions). +All three are merged and de-duplicated per (show, season, episode), earliest date wins, before upserting `Episode`s. +If a future TV Time export field looks suspiciously sparse, check the raw export files directly (`grep` the show name across every `*.csv`) before assuming the current parser set is complete - this is exactly how the tracking files were found. + +`followed_tv_show.csv` is not a complete list of shows either - confirmed with a real show ("The Pitt") that has genuine watch history in the tracking files but no row in `followed_tv_show.csv` at all. +`ImportEpisodesAsync` creates a show on the fly from watch-event data (title, plus the show's TV Time id when the source file has one) rather than skipping shows that aren't already known. +This applies the same rating/favorite/notes enrichment a normally-followed show gets. +Don't reintroduce a "skip if not already followed" check here. The import is idempotent by matching on a stable, enrichment-immutable id, **not** by title. -Re-running an import used to duplicate every show/movie (and, via the new show id, all their episodes): shows/movies were matched by normalized `Title`, but reference enrichment rewrites `Title` to the provider's canonical name after the first import (`SetReferenceLinkAsync`), so on the second import the export's original title no longer matched and a duplicate was created - confirmed by a real re-import. -The fix stamps every imported show/movie with `TvTimeId` (`IHasTvTimeId`, a real Domain field on `TvShowModel`/`MovieModel` carried through entity/DTO like `ReferenceId`, and round-tripped on edits since `UpdateAsync` is a full `ReplaceOneAsync`): TV Time's own show id for shows (`followed_tv_show.csv`/the tracking logs), and the per-movie tracking `uuid` for movies (every follow/watch/towatch row for one movie shares it - movies do have a stable id after all, contrary to the older "movies have no stable id" note, which was only ever true of the per-vote uuid in the rating files). -When the export carries no id for a title (a movie known only from the vote files; a show seen only in `seen_episode_source.csv`), `ResolveTvTimeId` synthesizes a deterministic `tvtime_title:` fallback from the **export** title, which enrichment never touches. -`BuildIdByTitle` first maps every title to its id across the id-bearing files so the title-only files resolve to the *same* id as their id-bearing counterpart (this is why an id-less `seen_episode_source.csv` episode still attaches to the followed show it belongs to, even after that show's stored title was enrichment-renamed). -`UpsertIndex` matches an incoming item by `TvTimeId` first; a title fallback fires only for a pre-existing record that has **no** `TvTimeId` yet (created by an import predating this feature), which is then adopted and back-filled exactly once (`BackfillTvTimeIdAsync`) rather than duplicated - a record already carrying a *different* id is left alone, so two genuinely different items sharing a title are never collapsed. -On a match the record is **left untouched** - not merely honoring the "if it already exists, do nothing" rule, but because a re-import must never clobber edits the user made *in the app* after the initial import (rating, notes, favorite, a corrected title/year); re-applying the export's values on every re-import would silently erase those. So don't reintroduce an update-on-existing path here. Only genuinely new items are created, and the result counts `*Created`/`*Skipped` (deduped by reference identity so a show touched in both the followed-shows and episodes phases counts once). +Re-running an import used to duplicate every show/movie (and, via the new show id, all their episodes). +Shows/movies were matched by normalized `Title`, but reference enrichment rewrites `Title` to the provider's canonical name after the first import (`SetReferenceLinkAsync`). +So on the second import the export's original title no longer matched and a duplicate was created - confirmed by a real re-import. +The fix stamps every imported show/movie with `TvTimeId` (`IHasTvTimeId`, a real Domain field on `TvShowModel`/`MovieModel` carried through entity/DTO like `ReferenceId`, and round-tripped on edits since `UpdateAsync` is a full `ReplaceOneAsync`). +This is TV Time's own show id for shows (`followed_tv_show.csv`/the tracking logs), and the per-movie tracking `uuid` for movies (every follow/watch/towatch row for one movie shares it). +Movies do have a stable id after all, contrary to the older "movies have no stable id" note, which was only ever true of the per-vote uuid in the rating files. +When the export carries no id for a title (a movie known only from the vote files; a show seen only in `seen_episode_source.csv`), `ResolveTvTimeId` synthesizes a fallback. +It's a deterministic `tvtime_title:` fallback from the **export** title. +This fallback title is one that enrichment never touches. +`BuildIdByTitle` first maps every title to its id across the id-bearing files, so the title-only files resolve to the *same* id as their id-bearing counterpart. +This is why an id-less `seen_episode_source.csv` episode still attaches to the followed show it belongs to, even after that show's stored title was enrichment-renamed. +`UpsertIndex` matches an incoming item by `TvTimeId` first. +A title fallback fires only for a pre-existing record that has **no** `TvTimeId` yet (created by an import predating this feature), which is then adopted and back-filled exactly once (`BackfillTvTimeIdAsync`) rather than duplicated. +A record already carrying a *different* id is left alone, so two genuinely different items sharing a title are never collapsed. +On a match the record is **left untouched** - not merely honoring the "if it already exists, do nothing" rule. +This is because a re-import must never clobber edits the user made *in the app* after the initial import (rating, notes, favorite, a corrected title/year). +Re-applying the export's values on every re-import would silently erase those. +So don't reintroduce an update-on-existing path here. +Only genuinely new items are created, and the result counts `*Created`/`*Skipped` (deduped by reference identity so a show touched in both the followed-shows and episodes phases counts once). Covered by `TvTimeImportServiceIdempotencyTest` (unit, in-memory repos, re-imports after mutating the stored titles to prove no duplication) and the re-import half of `TvTimeImportResourceTest` (integration). Note this fixes *future* imports; pre-existing duplicates from earlier buggy runs need a one-off cleanup (a `scripts/*.js` dedupe in the same run-once style as `migrate-poster-url-to-image-url.js`), not yet written. -When a `SeenEpisodeRecord`-shaped property is only present in *some* of the three source files' headers (like `TvShowId`, absent from `seen_episode_source.csv`), it needs `[Optional]` from `CsvHelper.Configuration.Attributes` in addition to not being C#'s `required` - CsvHelper's header validation throws on a missing column for any `[Name]`-decorated property regardless of C# nullability unless that attribute is present. This only surfaces at runtime against a real file missing the column, not at compile time - a unit test with a realistic fixture (matching `seen_episode_source.csv`'s actual header) is what caught it. - -Movies were originally believed to have no watch date anywhere in the export ("import movies without a watch date" was the confirmed scope decision) - that turned out to be wrong the same way the episode-history gaps were: `tracking-prod-records.csv`'s generic event log carries `entity_type == "movie"` rows too, with `type` "watch" (an individually dated watch event - `Movie.FirstSeenAt`), "towatch" (`Movie.WantToWatch`, only applied when there's no watched event, so a since-watched movie doesn't stay flagged as still-to-watch), and "follow" (existence only, same role as `followed_tv_show.csv` for shows). `MovieTrackingEventsCsvParser` reads these; `tracking-prod-records-v2.csv` (the newer-generation log) carries no movie data at all - confirmed against a real export, not assumed. If a future TV Time field looks suspiciously absent, re-check the real export before documenting it as a limitation - this is the second time an "unrecoverable" gap turned out to just be unparsed. - -The import runs as a background job rather than a single request/response, so the UI can show real progress: `POST /api/import/tv-time` buffers the upload, kicks off the work via `IServiceScopeFactory.CreateScope()` (the request's own DI scope is gone by the time the background work runs), and returns a job id immediately; `GET /api/import/tv-time/{jobId}` reports the current `ImportStage`. `ImportJobStore` is an in-memory singleton keyed by job id and checks the caller's owner id on every read, so a job is only ever visible to the user who started it. Follow this shape (buffer input, background `Task` via a fresh scope, pollable status keyed by owner) for any other future long-running action - don't block a request on multi-second server work just because the current single-endpoint pattern is simpler to write. - -Watch Next originally reported only the *last watched* episode per in-progress show, deliberately never guessing a "next" one, because Keeptrack had no episode-guide data to confirm a further episode actually existed. That constraint is gone now that `TvShowReferenceModel.Episodes` carries a real TMDB episode list: `WatchNextService.ComputeInProgressShows` now takes a third parameter, `referencesByShowId`, and only reports a show if (a) its `Status` is `TvShowStatus.Current` (not merely "not Finished/Stopped" as before) and (b) its linked reference's episode list has an entry after the last one watched (compared by `(SeasonNumber, EpisodeNumber)`, not by title or air-date order) whose `AirDate` has already passed (or is unset). A show with no `ReferenceId`, or no matching reference document, is excluded rather than guessed at - the same "don't guess when you don't have the info" principle as before, just enforced by data instead of by omission. `WatchNextController` only fetches the (small, bounded) reference document for shows that are `Current` and linked, since those are the only ones that can possibly appear in the result. The DTO now also reports the confirmed next episode's season/episode/title (`InProgressShowDto.Next*`) - this was withheld before purely for lack of data, not by design preference, so surfacing it once the data is trustworthy is not a reintroduction of the old "+1" heuristic that shipped a confirmed-wrong result; that heuristic guessed without confirming an episode existed; this checks a real episode-guide. - -`WatchNextService.FilterMoviesToWatch` excludes a movie from the "movies to watch" list once it's marked seen (`FirstSeenAt` set), even though it's still flagged `WantToWatch` - toggling that flag on a movie's own detail page doesn't clear it on watch (unlike the TV Time import's "towatch" event handling, which never flags an already-watched movie in the first place), so the exclusion has to happen at read time here instead of relying on the flag never going stale. - -`TvShowDetail.razor`'s episode checklist filters `_reference.Episodes` to `AirDate is null || AirDate <= today` before grouping into seasons, the same air-date filter `WatchNextService` already applies for its "next episode" calc. An episode TMDB lists with a future air date (a confirmed-but-unaired next season, e.g. a renewal announced months ahead) hasn't happened yet from the viewer's perspective - it shouldn't appear as a checkbox to mark watched, and an entirely future season simply doesn't appear in the season picker at all once every one of its episodes is filtered out. +When a `SeenEpisodeRecord`-shaped property is only present in *some* of the three source files' headers (like `TvShowId`, absent from `seen_episode_source.csv`), it needs a special attribute. +It needs `[Optional]` from `CsvHelper.Configuration.Attributes` in addition to not being C#'s `required`. +CsvHelper's header validation throws on a missing column for any `[Name]`-decorated property regardless of C# nullability unless that attribute is present. +This only surfaces at runtime against a real file missing the column, not at compile time - a unit test with a realistic fixture (matching `seen_episode_source.csv`'s actual header) is what caught it. + +Movies were originally believed to have no watch date anywhere in the export ("import movies without a watch date" was the confirmed scope decision). +That turned out to be wrong the same way the episode-history gaps were: `tracking-prod-records.csv`'s generic event log carries `entity_type == "movie"` rows too. +These have `type` "watch" (an individually dated watch event - `Movie.FirstSeenAt`), "towatch" (`Movie.WantToWatch`, only applied when there's no watched event, so a since-watched movie doesn't stay flagged as still-to-watch). +They also have "follow" (existence only, same role as `followed_tv_show.csv` for shows). +`MovieTrackingEventsCsvParser` reads these; `tracking-prod-records-v2.csv` (the newer-generation log) carries no movie data at all - confirmed against a real export, not assumed. +If a future TV Time field looks suspiciously absent, re-check the real export before documenting it as a limitation - this is the second time an "unrecoverable" gap turned out to just be unparsed. + +The import runs as a background job rather than a single request/response, so the UI can show real progress. +`POST /api/import/tv-time` buffers the upload, kicks off the work via `IServiceScopeFactory.CreateScope()` (the request's own DI scope is gone by the time the background work runs), and returns a job id immediately. +`GET /api/import/tv-time/{jobId}` reports the current `ImportStage`. +`ImportJobStore` is an in-memory singleton keyed by job id and checks the caller's owner id on every read, so a job is only ever visible to the user who started it. +Follow this shape (buffer input, background `Task` via a fresh scope, pollable status keyed by owner) for any other future long-running action. +Don't block a request on multi-second server work just because the current single-endpoint pattern is simpler to write. + +Watch Next originally reported only the *last watched* episode per in-progress show, deliberately never guessing a "next" one, because Keeptrack had no episode-guide data to confirm a further episode actually existed. +That constraint is gone now that `TvShowReferenceModel.Episodes` carries a real TMDB episode list. +`WatchNextService.ComputeInProgressShows` now takes a third parameter, `referencesByShowId`. +It only reports a show if (a) its `Status` is `TvShowStatus.Current` (not merely "not Finished/Stopped" as before) and (b) its linked reference's episode list has an entry after the last one watched. +That entry is compared by `(SeasonNumber, EpisodeNumber)`, not by title or air-date order, and its `AirDate` must have already passed (or be unset). +A show with no `ReferenceId`, or no matching reference document, is excluded rather than guessed at - the same "don't guess when you don't have the info" principle as before, just enforced by data instead of by omission. +`WatchNextController` only fetches the (small, bounded) reference document for shows that are `Current` and linked, since those are the only ones that can possibly appear in the result. +The DTO now also reports the confirmed next episode's season/episode/title (`InProgressShowDto.Next*`). +This was withheld before purely for lack of data, not by design preference, so surfacing it once the data is trustworthy is not a reintroduction of the old "+1" heuristic that shipped a confirmed-wrong result. +That heuristic guessed without confirming an episode existed; this checks a real episode-guide. + +`WatchNextService.FilterMoviesToWatch` excludes a movie from the "movies to watch" list once it's marked seen (`FirstSeenAt` set), even though it's still flagged `WantToWatch`. +Toggling that flag on a movie's own detail page doesn't clear it on watch (unlike the TV Time import's "towatch" event handling, which never flags an already-watched movie in the first place). +So the exclusion has to happen at read time here instead of relying on the flag never going stale. + +`TvShowDetail.razor`'s episode checklist filters `_reference.Episodes` to `AirDate is null || AirDate <= today` before grouping into seasons. +This is the same air-date filter `WatchNextService` already applies for its "next episode" calc. +An episode TMDB lists with a future air date (a confirmed-but-unaired next season, e.g. a renewal announced months ahead) hasn't happened yet from the viewer's perspective - it shouldn't appear as a checkbox to mark watched. +An entirely future season simply doesn't appear in the season picker at all once every one of its episodes is filtered out. ### Keeping reference data fresh: periodic + on-demand TMDB sync -TMDB's own data (episode air dates as seasons progress, genres, posters, cast) drifts out of date after the initial resolution - a show resolved months ago needs re-checking, not just a one-time fetch. `ReferenceSyncBackgroundService` (`WebApi/ReferenceData/`) is a plain in-process `BackgroundService` running a `PeriodicTimer` (24h interval, does an initial pass immediately on startup too) - deliberately **not** a Kubernetes CronJob or separate worker process: a second scheduled workload is real operational overhead (another manifest, another thing that can silently stop running) for a job that's cheap enough to run inside the existing API process. `ReferenceSyncService.SyncStaleReferencesAsync(staleAfter, ...)` (shared by both the periodic loop and the admin's on-demand trigger, so there's exactly one sync algorithm) skips any reference document whose `LastEnrichedAt` is more recent than `staleAfter` (3 days for the periodic pass; `TimeSpan.Zero` for the admin's forced "sync now", which therefore re-checks everything regardless of recency) and never lets one failing document (a TMDB id that's since been removed, a transient network error) abort the rest of the run - each is caught and logged individually. - -`ReferenceEnrichmentService.RefreshTvShowReferenceAsync`/`RefreshMovieReferenceAsync` do the actual per-document work, and lead with a cheap pre-check before the expensive full re-fetch: `ITmdbClient.HasTvShowChangedSinceAsync`/`HasMovieChangedSinceAsync` call TMDB's per-id `/{tv,movie}/{id}/changes?start_date=...` endpoint (one call, no season fan-out) to ask "has anything changed since this was last enriched" - this is the "if TMDB provides the last updated date... check with `last_enriched_at`" idea, implemented via TMDB's changes endpoint since TMDB doesn't expose a plain last-modified field on the show/movie details response itself. If nothing changed, only `LastEnrichedAt` is bumped (so the next periodic pass doesn't re-check an already-current document) and the costly `GetTvShowDetailsAsync` + per-season `GetTvShowCastAsync` calls are skipped entirely; a reference with no `LastEnrichedAt` yet always does the full fetch (nothing to compare against, and the changes-check would be meaningless anyway). - -An admin can force an immediate full re-check via `POST /api/reference-data/sync-now` (`ReferenceDataAdminController`, admin-only) instead of waiting for the next scheduled pass - the same "Reference data" admin page that already has export/import gets a "Sync now" button reporting checked/updated counts for both collections. - -**Gotcha:** the periodic background service is registered unconditionally in `Program.cs`, but only actually does work when `Features:IsReferenceSyncEnabled` (`AppConfiguration.IsReferenceSyncEnabled`, default `true`) is true - checked fresh on every tick, not once at startup. The integration test host (`KestrelWebAppFactory`) overrides this to `false` via `ConfigureAppConfiguration` (an in-memory source added last, so it wins over `appsettings.json`); `UseSetting` was tried first and silently didn't work for a top-level-statement minimal-hosting `Program.cs` like this one - it's loaded too early relative to the rest of configuration and gets overridden back by `appsettings.json`. Without this, every integration test run spun up its own in-process Kestrel host (one per `IClassFixture>` test class) and each one immediately fired real TMDB HTTP calls against whatever reference data the shared test MongoDB happened to hold - noisy and non-deterministic, not a real regression to chase. Any integration test using a bare `WebApplicationFactory` instead of `KestrelWebAppFactory` bypasses this override (this already bit `AuxiliaryResourceTest` once) - use `KestrelWebAppFactory` for any new integration test fixture, even one that doesn't need real Kestrel networking, specifically so it inherits this override for free instead of re-solving it. +TMDB's own data (episode air dates as seasons progress, genres, posters, cast) drifts out of date after the initial resolution - a show resolved months ago needs re-checking, not just a one-time fetch. +`ReferenceSyncBackgroundService` (`WebApi/ReferenceData/`) is a plain in-process `BackgroundService` running a `PeriodicTimer` (24h interval, does an initial pass immediately on startup too). +It's deliberately **not** a Kubernetes CronJob or separate worker process. +A second scheduled workload is real operational overhead (another manifest, another thing that can silently stop running) for a job that's cheap enough to run inside the existing API process. +`ReferenceSyncService.SyncStaleReferencesAsync(staleAfter, ...)` is shared by both the periodic loop and the admin's on-demand trigger, so there's exactly one sync algorithm. +It skips any reference document whose `LastEnrichedAt` is more recent than `staleAfter` (3 days for the periodic pass; `TimeSpan.Zero` for the admin's forced "sync now", which therefore re-checks everything regardless of recency). +It never lets one failing document (a TMDB id that's since been removed, a transient network error) abort the rest of the run - each is caught and logged individually. + +`ReferenceEnrichmentService.RefreshTvShowReferenceAsync`/`RefreshMovieReferenceAsync` do the actual per-document work, and lead with a cheap pre-check before the expensive full re-fetch. +`ITmdbClient.HasTvShowChangedSinceAsync`/`HasMovieChangedSinceAsync` call TMDB's per-id `/{tv,movie}/{id}/changes?start_date=...` endpoint (one call, no season fan-out) to ask "has anything changed since this was last enriched". +This is the "if TMDB provides the last updated date... check with `last_enriched_at`" idea, implemented via TMDB's changes endpoint since TMDB doesn't expose a plain last-modified field on the show/movie details response itself. +If nothing changed, only `LastEnrichedAt` is bumped (so the next periodic pass doesn't re-check an already-current document) and the costly `GetTvShowDetailsAsync` + per-season `GetTvShowCastAsync` calls are skipped entirely. +A reference with no `LastEnrichedAt` yet always does the full fetch (nothing to compare against, and the changes-check would be meaningless anyway). + +An admin can force an immediate full re-check via `POST /api/reference-data/sync-now` (`ReferenceDataAdminController`, admin-only) instead of waiting for the next scheduled pass. +The same "Reference data" admin page that already has export/import gets a "Sync now" button reporting checked/updated counts for both collections. + +**Gotcha:** the periodic background service is registered unconditionally in `Program.cs`, but only actually does work when `Features:IsReferenceSyncEnabled` (`AppConfiguration.IsReferenceSyncEnabled`, default `true`) is true. +This is checked fresh on every tick, not once at startup. +The integration test host (`KestrelWebAppFactory`) overrides this to `false` via `ConfigureAppConfiguration` (an in-memory source added last, so it wins over `appsettings.json`). +`UseSetting` was tried first and silently didn't work for a top-level-statement minimal-hosting `Program.cs` like this one - it's loaded too early relative to the rest of configuration and gets overridden back by `appsettings.json`. +Without this, every integration test run spun up its own in-process Kestrel host (one per `IClassFixture>` test class). +Each one immediately fired real TMDB HTTP calls against whatever reference data the shared test MongoDB happened to hold - noisy and non-deterministic, not a real regression to chase. +Any integration test using a bare `WebApplicationFactory` instead of `KestrelWebAppFactory` bypasses this override (this already bit `AuxiliaryResourceTest` once). +Use `KestrelWebAppFactory` for any new integration test fixture, even one that doesn't need real Kestrel networking, specifically so it inherits this override for free instead of re-solving it. ### Reference data now covers five domains (Book, VideoGame, Album) -The TMDB-backed pattern above (shared `*_reference` collection, admin unresolved queue, user-triggered "check for reference match", periodic + on-demand sync, export/import) is no longer TV-show/movie-only. `Book`/`VideoGame`/`Album` (the last renamed from `MusicAlbum` for consistency with `Episode`/`CarHistory`-style short names) each get their own external source and reference collection: +The TMDB-backed pattern above (shared `*_reference` collection, admin unresolved queue, user-triggered "check for reference match", periodic + on-demand sync, export/import) is no longer TV-show/movie-only. +`Book`/`VideoGame`/`Album` (the last renamed from `MusicAlbum` for consistency with `Episode`/`CarHistory`-style short names) each get their own external source and reference collection: - **Books** → Open Library (`IBookReferenceClient`/`OpenLibraryClient`, `WebApi/ReferenceData/`), no API key, `book_reference` collection with an extra `AuthorReferenceId` field. -- **Video Games** → RAWG (`IRawgClient`/`RawgClient`), a single API key appended as a query param (same convention as TMDB's `api_key`), `videogame_reference` with an extra `Platforms` list. `VideoGameModel.Platform`/`State` are deliberately never overwritten by a reference link - they describe this tenant's own copy/progress, not the canonical release, unlike `Title`/`Year` which do get set on link the same way Movie/TvShow already do. -- **Albums** → Discogs (`IDiscogsClient`/`DiscogsClient`), a personal access token appended as a query param plus a required descriptive `User-Agent` header (Discogs API policy), `album_reference` with an extra `ArtistReferenceId` field. Discogs search results title a release as `"Artist - Album Title"` in one string; `DiscogsClient` splits on the first `" - "` to populate `Artist`/`Title` separately. - -**Divergence from TMDB:** none of these three APIs expose a TMDB-style per-id `/changes` endpoint, so `RefreshReferenceAsync` for these three domains has no cheap "has this changed" pre-check - it always does a full re-fetch once a document is past its staleness cutoff (the cutoff check itself, in `ReferenceSyncService`, is unchanged). `ReferenceSyncResultDto`'s `Books/VideoGames/AlbumsUpdated` counts are therefore always equal to their matching `*Checked` counts. - -**Author/artist matter for search precision, not just display.** A common book/album title alone (e.g. "Killing Floor") returns many unrelated candidates from Open Library/Discogs - `IBookReferenceClient.SearchBooksAsync`/`IDiscogsClient.SearchAlbumsAsync` both take an optional `author`/`artist` parameter (the provider's own query field for it) precisely to narrow this, threaded through `TryAutoResolveBookAsync`/`TryAutoResolveAlbumAsync` (captured from `BookModel.Author`/`AlbumModel.Artist` in `BookController`/`AlbumController.OnCreatedAsync`) and through the admin's manual search (`ReferenceDataAdminController.Search`'s `creator` query param, surfaced as a free-text box in `ReferenceDataAdminPage.razor` and as `InlineReferenceLinker`'s `Creator` parameter, populated from the tenant's own Author/Artist field on `BookDetail.razor`/`AlbumDetail.razor`). `ReferenceSearchResultDto.Creator` (book author or album artist; null for TV/movie/game) surfaces this on every search candidate the admin sees - without it, an admin looking at otherwise-identical title+year+cover candidates has no way to tell them apart. - -**Gotcha:** `OpenLibraryClient.SearchBooksAsync` deliberately never sends `year` as a server-side query filter (unlike TMDB/RAWG/Discogs, which do). Open Library's `first_publish_year` is a book's ORIGINAL publication year, not whatever edition/printing year a tenant happened to record - searching "Killing Floor" (Lee Child, first published 1997) with `first_publish_year=2016` (a tenant's 2016 reprint) returns zero relevant results, since Open Library filters the *work* by that exact year server-side and no edition of that work was first published in 2016. `year` is still returned per candidate for display/tie-breaking, just never used to narrow the query itself - confirmed against the real API (searching `title=Killing+Floor&first_publish_year=2016` returns an unrelated 2016 book; dropping the year filter and adding `author=Lee+Child` finds the real one). This is a book-specific problem (one canonical release date doesn't generalize to "the book was first published once, but every reader owns some edition"); RAWG/Discogs keep their year filters since no equivalent bug has been found for games/albums. - -Book authors and album artists are deduplicated the same way TV/movie cast is: `PersonReferenceModel`/`person_reference` was kept as-is (no rename) and reused, rather than adding two more near-duplicate lookup tables - "Person" already meant "a named individual or group identified by an external provider id," not "actor" specifically, so extending it to a book's author (Open Library author id) or an album's artist (Discogs artist id, which can be a group/band) needed no rename, just reuse. `BookReferenceModel.AuthorReferenceId`/`AlbumReferenceModel.ArtistReferenceId` point at a `PersonReferenceModel` document instead of embedding a plain name string - `ReferenceEnrichmentService.ResolvePersonReferenceIdAsync` (shared helper in the core partial-class file) is the single dedup-by-external-id path used by cast resolution (`ResolveCastAsync`, refactored to call it per member) and by `ResolveBookAsync`/`ResolveAlbumAsync`. `BookReferenceDto.AuthorName`/`AlbumReferenceDto.ArtistName` are hydrated by `ReferenceDataController` joining `person_reference` by id (same `[MapperIgnoreTarget]` + manual join pattern as `Cast`) - the model only carries the id, never a denormalized name, so there's nothing to keep in sync. When linking (`TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync`), the tenant's own plain-string `BookModel.Author`/`AlbumModel.Artist` is still populated by resolving the reference's `*ReferenceId` to a name at link time (`ResolvePersonNameAsync`) - the tenant-facing field stays a free-text string editable like `Title`, only the shared reference document uses the dedup'd id. - -`ReferenceEnrichmentService` is a single `partial class` split across `.TvShowsAndMovies.cs`/`.Books.cs`/`.VideoGames.cs`/`.Albums.cs` files (one class, same constructor, same five-method-per-domain template: `TryLinkExistingReferenceAsync`/`TryAutoResolveAsync`/`ResolveAsync`/`RefreshReferenceAsync`) - splitting by file rather than by class keeps the shared helpers (`MergeMatchedAliases`, `TitleNormalizer.Normalize`) in one place without one file growing to cover six domains' worth of logic. `ReferenceMatchModel`/`MatchedAliases` needed no changes at all to support the new domains - it was already generic, not TMDB-specific, per its original naming decision. - -`PosterUrl` was renamed to `ImageUrl` on `TvShowReferenceModel`/`MovieReferenceModel` (and their entities/DTOs/Razor bindings) as part of this - "poster" only made sense for movies/TV, and the field is now shared across all five reference types. Similarly, the admin search/link DTOs' `TmdbId` field was renamed to `ExternalId` (`ReferenceSearchResultDto`, `LinkReferenceRequestDto`) since `ReferenceDataAdminController`'s `Search`/`Link`/`GetUnresolved` endpoints now switch over a 5-way `ReferenceItemType` enum instead of a TV-show/movie ternary, and hardcoding a TMDB-specific name in a request DTO shared by Open Library/RAWG/Discogs would have been misleading. - -`Book`/`VideoGame`/`Album` detail pages (`BookDetail.razor`, `VideoGameDetail.razor`, `AlbumDetail.razor`) follow `MovieDetail.razor`'s exact shape (own route, own load/save methods, no `InventoryPageBase` inheritance) - cover art, synopsis and genres render when linked, plus the same refresh-reference icon button and admin `InlineReferenceLinker`. None of the three have a cast/credits concept, so there's no `CastGrid` equivalent for them. - -**Gotcha:** `OpenLibraryClient.GetBookDetailsAsync` fetches a work's year from `first_publish_date` on `/works/{id}.json`, but that field is routinely absent from the work document itself - confirmed against the real API for a book as well-known as Lee Child's "Killing Floor" (`/works/OL24477958W.json` has no `first_publish_date` at all), while the search index's computed `first_publish_year` for the same work is reliable. `GetBookDetailsAsync` falls back to `FindPublishYearViaSearchAsync` (a single-document `q=key:{workKey}` search re-query) whenever the work-level parse comes back null, rather than silently leaving `BookReferenceModel.Year`/the tenant's own `BookModel.Year` unset after a link. - -**No reliable "series" field exists in Open Library.** Checked directly against the real API (work JSON, edition JSON, and a `fields=*` search query for "Killing Floor") - none expose a `series` field. The closest available signal is the search index's `person`/`subject_people` facet (a recurring fictional character, e.g. `"person": ["Jack Reacher"]` for "Killing Floor"), but that's a character-name facet, not a series title, and doesn't generalize (many series aren't named after - or don't have - a recurring eponymous character, and a standalone book can still feature a named character). Not wired up to `BookModel.Series`/`BookReferenceModel` for that reason - auto-filling `Series` from it would be right by coincidence for character-titled franchises and wrong or absent otherwise. +- **Video Games** → RAWG (`IRawgClient`/`RawgClient`), a single API key appended as a query param (same convention as TMDB's `api_key`), `videogame_reference` with an extra `Platforms` list. + `VideoGameModel.Platform`/`State` are deliberately never overwritten by a reference link - they describe this tenant's own copy/progress, not the canonical release. + This is unlike `Title`/`Year`, which do get set on link the same way Movie/TvShow already do. +- **Albums** → Discogs (`IDiscogsClient`/`DiscogsClient`), a personal access token appended as a query param plus a required descriptive `User-Agent` header (Discogs API policy), `album_reference` with an extra `ArtistReferenceId` field. + Discogs search results title a release as `"Artist - Album Title"` in one string; `DiscogsClient` splits on the first `" - "` to populate `Artist`/`Title` separately. + +**Divergence from TMDB:** none of these three APIs expose a TMDB-style per-id `/changes` endpoint, so `RefreshReferenceAsync` for these three domains has no cheap "has this changed" pre-check. +It always does a full re-fetch once a document is past its staleness cutoff (the cutoff check itself, in `ReferenceSyncService`, is unchanged). +`ReferenceSyncResultDto`'s `Books/VideoGames/AlbumsUpdated` counts are therefore always equal to their matching `*Checked` counts. + +**Author/artist matter for search precision, not just display.** A common book/album title alone (e.g. "Killing Floor") returns many unrelated candidates from Open Library/Discogs. +`IBookReferenceClient.SearchBooksAsync`/`IDiscogsClient.SearchAlbumsAsync` both take an optional `author`/`artist` parameter (the provider's own query field for it) precisely to narrow this. +This is threaded through `TryAutoResolveBookAsync`/`TryAutoResolveAlbumAsync` (captured from `BookModel.Author`/`AlbumModel.Artist` in `BookController`/`AlbumController.OnCreatedAsync`) and through the admin's manual search. +The admin's manual search is `ReferenceDataAdminController.Search`'s `creator` query param, surfaced as a free-text box in `ReferenceDataAdminPage.razor`. +It's also `InlineReferenceLinker`'s `Creator` parameter, populated from the tenant's own Author/Artist field on `BookDetail.razor`/`AlbumDetail.razor`. +`ReferenceSearchResultDto.Creator` (book author or album artist; null for TV/movie/game) surfaces this on every search candidate the admin sees. +Without it, an admin looking at otherwise-identical title+year+cover candidates has no way to tell them apart. + +**Gotcha:** `OpenLibraryClient.SearchBooksAsync` deliberately never sends `year` as a server-side query filter (unlike TMDB/RAWG/Discogs, which do). +Open Library's `first_publish_year` is a book's ORIGINAL publication year, not whatever edition/printing year a tenant happened to record. +Searching "Killing Floor" (Lee Child, first published 1997) with `first_publish_year=2016` (a tenant's 2016 reprint) returns zero relevant results. +This is because Open Library filters the *work* by that exact year server-side and no edition of that work was first published in 2016. +`year` is still returned per candidate for display/tie-breaking, just never used to narrow the query itself. +This was confirmed against the real API (searching `title=Killing+Floor&first_publish_year=2016` returns an unrelated 2016 book; dropping the year filter and adding `author=Lee+Child` finds the real one). +This is a book-specific problem (one canonical release date doesn't generalize to "the book was first published once, but every reader owns some edition"). +RAWG/Discogs keep their year filters since no equivalent bug has been found for games/albums. + +Book authors and album artists are deduplicated the same way TV/movie cast is: `PersonReferenceModel`/`person_reference` was kept as-is (no rename) and reused, rather than adding two more near-duplicate lookup tables. +"Person" already meant "a named individual or group identified by an external provider id," not "actor" specifically. +So extending it to a book's author (Open Library author id) or an album's artist (Discogs artist id, which can be a group/band) needed no rename, just reuse. +`BookReferenceModel.AuthorReferenceId`/`AlbumReferenceModel.ArtistReferenceId` point at a `PersonReferenceModel` document instead of embedding a plain name string. +`ReferenceEnrichmentService.ResolvePersonReferenceIdAsync` (shared helper in the core partial-class file) is the single dedup-by-external-id path used by cast resolution (`ResolveCastAsync`, refactored to call it per member) and by `ResolveBookAsync`/`ResolveAlbumAsync`. +`BookReferenceDto.AuthorName`/`AlbumReferenceDto.ArtistName` are hydrated by `ReferenceDataController` joining `person_reference` by id (same `[MapperIgnoreTarget]` + manual join pattern as `Cast`). +The model only carries the id, never a denormalized name, so there's nothing to keep in sync. +When linking (`TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync`), the tenant's own plain-string `BookModel.Author`/`AlbumModel.Artist` is still populated. +This works by resolving the reference's `*ReferenceId` to a name at link time (`ResolvePersonNameAsync`). +The tenant-facing field stays a free-text string editable like `Title`, only the shared reference document uses the dedup'd id. + +`ReferenceEnrichmentService` is a single `partial class` split across `.TvShowsAndMovies.cs`/`.Books.cs`/`.VideoGames.cs`/`.Albums.cs` files (one class, same constructor, same five-method-per-domain template: `TryLinkExistingReferenceAsync`/`TryAutoResolveAsync`/`ResolveAsync`/`RefreshReferenceAsync`). +Splitting by file rather than by class keeps the shared helpers (`MergeMatchedAliases`, `TitleNormalizer.Normalize`) in one place without one file growing to cover six domains' worth of logic. +`ReferenceMatchModel`/`MatchedAliases` needed no changes at all to support the new domains - it was already generic, not TMDB-specific, per its original naming decision. + +`PosterUrl` was renamed to `ImageUrl` on `TvShowReferenceModel`/`MovieReferenceModel` (and their entities/DTOs/Razor bindings) as part of this. +"Poster" only made sense for movies/TV, and the field is now shared across all five reference types. +Similarly, the admin search/link DTOs' `TmdbId` field was renamed to `ExternalId` (`ReferenceSearchResultDto`, `LinkReferenceRequestDto`). +This is because `ReferenceDataAdminController`'s `Search`/`Link`/`GetUnresolved` endpoints now switch over a 5-way `ReferenceItemType` enum instead of a TV-show/movie ternary. +Hardcoding a TMDB-specific name in a request DTO shared by Open Library/RAWG/Discogs would have been misleading. + +`Book`/`VideoGame`/`Album` detail pages (`BookDetail.razor`, `VideoGameDetail.razor`, `AlbumDetail.razor`) follow `MovieDetail.razor`'s exact shape (own route, own load/save methods, no `InventoryPageBase` inheritance). +Cover art, synopsis and genres render when linked, plus the same refresh-reference icon button and admin `InlineReferenceLinker`. +None of the three have a cast/credits concept, so there's no `CastGrid` equivalent for them. + +**Gotcha:** `OpenLibraryClient.GetBookDetailsAsync` fetches a work's year from `first_publish_date` on `/works/{id}.json`, but that field is routinely absent from the work document itself. +This was confirmed against the real API for a book as well-known as Lee Child's "Killing Floor" (`/works/OL24477958W.json` has no `first_publish_date` at all), while the search index's computed `first_publish_year` for the same work is reliable. +`GetBookDetailsAsync` falls back to `FindPublishYearViaSearchAsync` (a single-document `q=key:{workKey}` search re-query) whenever the work-level parse comes back null. +This is rather than silently leaving `BookReferenceModel.Year`/the tenant's own `BookModel.Year` unset after a link. + +**No reliable "series" field exists in Open Library.** Checked directly against the real API (work JSON, edition JSON, and a `fields=*` search query for "Killing Floor") - none expose a `series` field. +The closest available signal is the search index's `person`/`subject_people` facet (a recurring fictional character, e.g. `"person": ["Jack Reacher"]` for "Killing Floor"), but that's a character-name facet, not a series title. +It doesn't generalize (many series aren't named after - or don't have - a recurring eponymous character, and a standalone book can still feature a named character). +It's not wired up to `BookModel.Series`/`BookReferenceModel` for that reason - auto-filling `Series` from it would be right by coincidence for character-titled franchises and wrong or absent otherwise. `Album`/`Book` gained `IsFavorite` (`AlbumModel`/`Album`/`AlbumDto`, `BookModel`/`Book`/`BookDto`), same shape as `Movie`/`TvShow`'s existing flag: a partial Mongo index (`album_favorite`/`book_favorite`, `scripts/mongodb-create-index.js`), a `Favorites` filter button in each list page's `Filters` slot, and a toggle button on `AlbumDetail.razor`/`BookDetail.razor`'s page header (same `kt-toggle-btn`/`active` pattern as `MovieDetail.razor`). -`VideoGameModel.State` stays a plain free-text string (not an enum like `TvShowModel.State`) deliberately - real tenant data already has values like `"To resume"`/`"On-hold"` that aren't valid C# enum member names, and MongoDB's `EnumRepresentationConvention(BsonType.String)` deserializes by matching the enum member name exactly, so converting would require a data migration with real breakage risk for existing documents. Filtering by state (`VideoGameRepository.GetFilter` already supported exact-match filtering by `input.State`) is instead exposed as list-page filter buttons (`VideoGames.razor`'s `Filters` slot, same visual pattern as `TvShows.razor`'s `TvShowStatus` filter buttons) over the existing string values, and the Add/Edit forms' State `` was replaced with a button group (`VideoGames.VideoGameStates`, the shared array both the filter and the form buttons iterate over) for the same reason TvShow's own state buttons exist - clicking a value is faster than a dropdown for a small fixed set. +`FinishedAt` is a plain, always-visible date field on `VideoGameDetail.razor`'s card (not a corner-flag toggle like `MovieDetail.razor`'s "Mark as watched"/`BookDetail.razor`'s "Mark as read"). +It was previously only editable once already set elsewhere, with no way to set it from scratch on the detail page. +Unlike Movie/Book, "finished" already has its own explicit `State` value ("Completed") to toggle, so `FinishedAt` doesn't need a second boolean-flag affordance layered on top. + +**`VideoGameDetail.razor`'s own State editor follows `TvShowDetail.razor`'s per-item State pattern exactly, not the list page's filter-button pattern.** These look superficially similar (both are button rows) but behave differently, and the two were conflated once already. +The per-item editor buttons live in their own row directly below the page header (not inside the `kt-form-card` next to Year/Rating). +Clicking the already-active value clears it back to unset (`SetStateAsync`: `_game.State = _game.State == state ? "" : state`, mirroring `TvShowDetail.razor`'s own `SetStateAsync`). +The list page's filter buttons are a different control with different semantics (an explicit "All" option to clear, since a filter and a per-item value aren't the same kind of state). **`TvShowModel.Status` was renamed to `TvShowModel.State`** for naming parity with `VideoGameModel.State` (`TvShowDto.State`, `TvShow.State` entity property, `TvShowRepository.GetFilter`'s `input.State`, `TvShows.razor`'s `_stateFilter`/`SetStateFilterAsync`/`ExtraQuery["State"]`, `TvShowDetail.razor`'s `SetStateAsync` all renamed to match). The enum type itself keeps its `TvShowStatus` name - only the property that holds it moved to `State`, since `VideoGameModel.State` has no equivalent enum to rename against. Unlike the `PosterUrl`→`ImageUrl` rename below, this one needed **no** data migration: `TvShow`'s entity property kept an explicit `[BsonElement("status")]` pointing at the unchanged storage name, so existing documents (confirmed directly against the real dev database - `status: 'Finished'` reads back correctly through the renamed `State` property) deserialize with no script required. `TvTimeImportService`/`ShowStatusCsvParser`'s `ShowStatusRecord.Status` is a same-named but *entirely unrelated* field - TV Time's own CSV column for favorite/for_later, mapped to `IsFavorite`/`WantToWatch`, never to this enum - so the import pipeline needed no changes at all for this rename; verified by tracing every consumer before renaming, not just running the test suite. `WatchNextService`/`WatchNextController`'s `Status == TvShowStatus.Current` checks were updated to `State == TvShowStatus.Current` and covered by `WatchNextServiceTest`, which still passes. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d2d44ca..a420611 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -157,9 +157,12 @@ Albums | [Discogs](https://www.discogs.com/developers) | ` Without a key/token for a given provider, new items of that type simply stay unresolved (no synopsis, no cover art) instead of erroring. The app degrades gracefully per type - it just won't auto-match that type until the corresponding setting is provided. -Unlike the other three, books are resolved through a provider-agnostic `IBookReferenceClient` interface (`src/WebApi/ReferenceData/`), so which book provider is active is itself a setting: `ReferenceData:BookProvider` (or the `ReferenceData__BookProvider` environment variable), defaulting to `OpenLibrary`. +Unlike the other three, books are resolved through a provider-agnostic `IBookReferenceClient` interface (`src/WebApi/ReferenceData/`). +Which book provider is active is itself a setting: `ReferenceData:BookProvider` (or the `ReferenceData__BookProvider` environment variable), defaulting to `OpenLibrary`. `src/WebApi/Program.cs` switches on this value to decide which implementation to register - `OpenLibrary` is the only one that ships today. -To add a new book provider, implement `IBookReferenceClient` (a new client class alongside `OpenLibraryClient.cs`, plus its own settings class if it needs an API key, following `RawgSettings`/`DiscogsSettings`) and add a matching `case` to that switch; nothing else in the app needs to change, since `ReferenceEnrichmentService`/`ReferenceDataAdminController` only depend on the interface and read the active provider's key from `IBookReferenceClient.ProviderKey`. +To add a new book provider, implement `IBookReferenceClient` (a new client class alongside `OpenLibraryClient.cs`, plus its own settings class if it needs an API key, following `RawgSettings`/`DiscogsSettings`). +Also add a matching `case` to that switch. +Nothing else in the app needs to change, since `ReferenceEnrichmentService`/`ReferenceDataAdminController` only depend on the interface and read the active provider's key from `IBookReferenceClient.ProviderKey`. ### Admin role @@ -240,7 +243,9 @@ Run a single test by fully qualified name (works for either project): dotnet test --filter-method "Keeptrack.WebApi.UnitTests.Services.WatchNextServiceTest.ComputeInProgressShows_IncludesShowWithAConfirmedAiredUnwatchedNextEpisode" ``` -`--filter-method` also accepts a wildcard, e.g. `--filter-method "*CarResourceTest*"` to run every test in a class - but it's a single glob pattern, not a real filter expression: it does not support `|`/`,` alternation to combine multiple patterns in one run (that just prints the CLI help instead of running anything), so run each pattern as its own `dotnet test` invocation. +`--filter-method` also accepts a wildcard, e.g. `--filter-method "*CarResourceTest*"` to run every test in a class. +It's a single glob pattern, not a real filter expression: it does not support `|`/`,` alternation to combine multiple patterns in one run (that just prints the CLI help instead of running anything). +So run each pattern as its own `dotnet test` invocation. This project's test runner is `Microsoft.Testing.Platform` (`UseMicrosoftTestingPlatformRunner`, xunit v3), which does **not** understand the classic VSTest `--settings .runsettings` flag - passing it also just prints the help. `Local.runsettings` (below) is read automatically by Rider/Visual Studio for IDE-driven runs; for a CLI run, export the same values as environment variables instead (see "Integration tests" below). @@ -254,7 +259,8 @@ These need two things configured before they'll pass: 1. **A MongoDB instance** (see [Requirements](#requirements) above), pointed at by `Infrastructure__MongoDB__ConnectionString`/`Infrastructure__MongoDB__DatabaseName`. Use a dedicated database (e.g. `keeptrack_integrationtests`), not your dev database - tests create and delete real documents. - Running `scripts/mongodb-create-index.js` against it first is recommended (keeps behavior closest to production) but not required for the tests themselves to pass - see [Requirements](#requirements) above for the exact `mongosh` command (swap in `keeptrack_integrationtests` for the database name). + Running `scripts/mongodb-create-index.js` against it first is recommended (keeps behavior closest to production) but not required for the tests themselves to pass. + See [Requirements](#requirements) above for the exact `mongosh` command (swap in `keeptrack_integrationtests` for the database name). 2. **A Firebase test user**, since `ResourceTestBase.Authenticate()` performs a real Firebase sign-in to obtain a bearer token: - `FIREBASE_APIKEY`: the Firebase project's Web API key (Firebase Console → Project settings → General → Web API Key). - `FIREBASE_USERNAME` / `FIREBASE_PASSWORD`: the email/password of a real user created in that project (Firebase Console → Authentication → Users → Add user). @@ -305,7 +311,11 @@ Or in Rider, in "File | Settings | Build, Execution, Deployment | Unit Testing | Set `KESTREL_WEBAPP_URL` to target a specific already-running instance instead of letting the tests spin up their own. -The standard test user above now carries the `role: admin` custom claim (set via `scripts/firebase-set-admin.js`, see [Admin role](#admin-role) above), so `ReferenceDataAdminResourceTest` and any other admin-gated endpoint can be exercised end-to-end over HTTP with the same single test account - there's no separate non-admin test account, so there's no automated coverage of the "AdminOnly" policy actually rejecting a non-admin caller; that would need a second Firebase test user without the claim. The underlying Mongo query logic (`SetReferenceIdForTitleYearAsync`, `FindDistinctUnresolvedTitleYearsAsync`) is still covered directly against a real database in `TvShowReferenceLinkingTest`, which resolves repositories from the test host's DI container instead of going over HTTP. +The standard test user above now carries the `role: admin` custom claim (set via `scripts/firebase-set-admin.js`, see [Admin role](#admin-role) above). +So `ReferenceDataAdminResourceTest` and any other admin-gated endpoint can be exercised end-to-end over HTTP with the same single test account. +There's no separate non-admin test account, so there's no automated coverage of the "AdminOnly" policy actually rejecting a non-admin caller; that would need a second Firebase test user without the claim. +The underlying Mongo query logic (`SetReferenceIdForTitleYearAsync`, `FindDistinctUnresolvedTitleYearsAsync`) is still covered directly against a real database in `TvShowReferenceLinkingTest`. +This test resolves repositories from the test host's DI container instead of going over HTTP. ## Container images diff --git a/docs/code-quality-findings.md b/docs/code-quality-findings.md index d72689e..29a9cd4 100644 --- a/docs/code-quality-findings.md +++ b/docs/code-quality-findings.md @@ -7,22 +7,30 @@ Update this file as items are fixed or as new reviews are performed. ## Fixed Several findings below trace back to AutoMapper's profile-wide `AllowNullDestinationValues = false` (a null source string/collection/object silently substituted with `""`/an empty collection/a blank instance). -AutoMapper itself was removed in favor of Riok.Mapperly (see `docs/automapper-removal-plan.md`), which preserves nulls by default - the entire class of gotcha these findings patched around is now structurally impossible, not just individually fixed. +AutoMapper itself was removed in favor of Riok.Mapperly (see `docs/automapper-removal-plan.md`), which preserves nulls by default. +The entire class of gotcha these findings patched around is now structurally impossible, not just individually fixed. The `entity is null` guards these findings added stay in place regardless: Mapperly throws on a null source, so checking before mapping is still the only correct way to turn "no document matched" into a `null` return value. ### `mapper.Map(null)` returned a fake empty object instead of null - also affected the shared base repository, not just the reference-data ones -Found again on 2026-07-09 while building the Car/CarHistory feature and its `CarResourceTest` integration coverage: `MongoDbRepositoryBase.FindOneAsync` (the base class every entity's repository extends) had the exact same shape as the bug described just below - `Mapper.Map(await entities.FirstOrDefaultAsync())` - and hit the exact same `AllowNullDestinationValues = false` gotcha, silently returning a blank default model instead of `null` for a nonexistent id. -This meant `DataCrudControllerBase.GetById`'s `model == null` 404 check was broken for **every** entity type in the app (Book, Movie, TvShow, VideoGame, Album, Song, Playlist, Episode - not just the newly-added Car), returning 200 with an empty object instead of 404. -A mocked-repository unit test can't catch this (a mock never exercises real AutoMapper config); confirmed via a real MongoDB integration test (`CarResourceTest.CarResourceMetrics_ReturnsNotFound_ForACarThatDoesNotExist`) and cross-checked against `Book` directly. +Found again on 2026-07-09 while building the Car/CarHistory feature and its `CarResourceTest` integration coverage. +`MongoDbRepositoryBase.FindOneAsync` (the base class every entity's repository extends) had the exact same shape as the bug described just below - `Mapper.Map(await entities.FirstOrDefaultAsync())`. +It hit the exact same `AllowNullDestinationValues = false` gotcha, silently returning a blank default model instead of `null` for a nonexistent id. +This meant `DataCrudControllerBase.GetById`'s `model == null` 404 check was broken for **every** entity type in the app (Book, Movie, TvShow, VideoGame, Album, Song, Playlist, Episode - not just the newly-added Car). +It returned 200 with an empty object instead of 404. +A mocked-repository unit test can't catch this (a mock never exercises real AutoMapper config). +Confirmed via a real MongoDB integration test (`CarResourceTest.CarResourceMetrics_ReturnsNotFound_ForACarThatDoesNotExist`) and cross-checked against `Book` directly. Fixed the same way as the reference repositories below: check `entity is null` before calling `mapper.Map`, in the one shared base method rather than per-repository. File: `src/Infrastructure.MongoDb/Repositories/MongoDbRepositoryBase.cs` ### `AllowNullDestinationValues = false` also substitutes an empty collection for a null reference-type member, not just an empty string -Found on 2026-07-09 while adding `CarHistoryResourceTest`: `CarHistoryModel -> CarHistory`'s `Coordinates` (`List`) `ForMember` mapped to `null` when `Longitude`/`Latitude` were unset, but `AllowNullDestinationValues = false` substituted a new **empty list** instead - the same class of bug as the `Creator`/empty-string gotchas already documented here and in CLAUDE.md, just for a `List` member instead of `string`. -The reverse mapping (`CarHistory -> CarHistoryModel`) read it back with `x.Coordinates != null ? x.Coordinates[0] : null`, which an empty-but-non-null list defeats - `x.Coordinates[0]` threw `IndexOutOfRangeException` on every `POST`/`PUT` of a `CarHistory` entry with no location set. +Found on 2026-07-09 while adding `CarHistoryResourceTest`: `CarHistoryModel -> CarHistory`'s `Coordinates` (`List`) `ForMember` mapped to `null` when `Longitude`/`Latitude` were unset. +But `AllowNullDestinationValues = false` substituted a new **empty list** instead. +This was the same class of bug as the `Creator`/empty-string gotchas already documented here and in CLAUDE.md, just for a `List` member instead of `string`. +The reverse mapping (`CarHistory -> CarHistoryModel`) read it back with `x.Coordinates != null ? x.Coordinates[0] : null`, which an empty-but-non-null list defeats. +`x.Coordinates[0]` threw `IndexOutOfRangeException` on every `POST`/`PUT` of a `CarHistory` entry with no location set. Fixed with `.AllowNull()` on that `ForMember`, same fix shape as the `Creator` case in CLAUDE.md. The `AllowNull()` opt-out itself no longer exists - the AutoMapper -> Mapperly migration deleted `CarDataStorageMappingProfile` entirely; the same null-vs-empty-list handling now lives, hand-written, in `CarHistoryStorageMapper.BuildLocation`. @@ -31,7 +39,9 @@ File (at the time of the fix): `src/WebApi/MappingProfiles/CarDataStorageMapping ### `mapper.Map(null)` returned a fake empty object instead of null Found on 2026-07-06 while adding the cast/actors integration test (`PersonReferenceRepositoryTest`), in `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository`'s `Find*Async` methods. -Each did `var entity = await Collection.Find(...).FirstOrDefaultAsync(); return mapper.Map(entity);` - when nothing matched, `entity` is `null`, and the same `AllowNullDestinationValues = false` AutoMapper setting behind the previous finding also changes `Map(null)`: instead of returning `null`, it returns a new, all-default `TDestination` instance. +Each did `var entity = await Collection.Find(...).FirstOrDefaultAsync(); return mapper.Map(entity);`. +When nothing matched, `entity` is `null`, and the same `AllowNullDestinationValues = false` AutoMapper setting behind the previous finding also changes `Map(null)`. +Instead of returning `null`, it returns a new, all-default `TDestination` instance. The integration test's `found.Should().BeNull()` assertion caught it directly (`found` was a non-null `PersonReferenceModel` with every property null). This silently broke "not found" handling anywhere these methods were used with an `is null` check, including `ReferenceDataController`'s 404 responses. Fixed by checking `entity is null` before calling `mapper.Map` in all three repositories, returning `null` directly instead. @@ -49,7 +59,8 @@ The filter checked `Builders.Filter.Eq(f => f.ReferenceId, null)`, expec It matched zero documents, because `AddAutoMapper` is configured with `AllowNullDestinationValues = false` (`WebApi/Program.cs`) - mapping a model whose string property is null stores an **empty string** in MongoDB, never an actual BSON null. Every "is this string field unset" filter in the codebase needs to check for null *or* empty string, not just null. Fixed by adding a shared `UnresolvedFilter()` helper (in both `TvShowRepository` and `MovieRepository`) that matches either. -This is a real-database-only bug: it doesn't throw, so a unit test against a mocked repository can't catch it - only `TvShowReferenceLinkingTest`, which runs the actual query against a real MongoDB instance, caught it (the assertion literally saw `"reference_id": ""` in the raw document via a diagnostic dump, not `null`). +This is a real-database-only bug: it doesn't throw, so a unit test against a mocked repository can't catch it. +Only `TvShowReferenceLinkingTest`, which runs the actual query against a real MongoDB instance, caught it (the assertion literally saw `"reference_id": ""` in the raw document via a diagnostic dump, not `null`). Files: @@ -61,20 +72,28 @@ Files: Found on 2026-07-06 during a review of `scripts/mongodb-create-index.js` requested directly against the actual repository query code (grepped every repository for `.Text(` usage rather than assuming the script matched). Three separate problems, all in the same file: -1. `book_text`/`movie_text`/`tvshow_text`/`videogame_text` were dead. `Book`/`Movie`/`Album`/`TvShow`/`VideoGame` all search via `builder.Where(f => f.Title.Contains(...))`, a regex filter that a MongoDB `text` index never accelerates. The only two repositories that call `builder.Text(...)` at all are `CarRepository` (via the base class default) and `CarHistoryRepository` - confirmed by grep, not assumption. -2. Following directly from (1): `car`/`car_history` had **no** index at all despite being the only two collections whose queries actually need one - this is the other half of "Car and CarHistory search relies on a `$text` index that does not exist" below, now fixed at the index level (the `CarHistoryRepository` code bug tracked separately below is not). -3. Beyond text search: almost every tenant-scoped collection (`book`, `car`, `car_history`, `movie`, `album`, `tvshow`, `videogame`) had no plain `{ owner_id: 1 }` index, even though every list/search request filters on `owner_id` first. The `movie_favorite`/`tvshow_favorite` partial indexes don't help a plain "all movies for this owner" query either - a partial index only accelerates queries the planner can prove only match documents inside its partial filter, and a plain list query has no `is_favorite` condition to prove that with. +1. `book_text`/`movie_text`/`tvshow_text`/`videogame_text` were dead. + `Book`/`Movie`/`Album`/`TvShow`/`VideoGame` all search via `builder.Where(f => f.Title.Contains(...))`, a regex filter that a MongoDB `text` index never accelerates. + The only two repositories that call `builder.Text(...)` at all are `CarRepository` (via the base class default) and `CarHistoryRepository` - confirmed by grep, not assumption. +2. Following directly from (1): `car`/`car_history` had **no** index at all despite being the only two collections whose queries actually need one. + This is the other half of "Car and CarHistory search relies on a `$text` index that does not exist" below, now fixed at the index level (the `CarHistoryRepository` code bug tracked separately below is not). +3. Beyond text search: almost every tenant-scoped collection (`book`, `car`, `car_history`, `movie`, `album`, `tvshow`, `videogame`) had no plain `{ owner_id: 1 }` index, even though every list/search request filters on `owner_id` first. + The `movie_favorite`/`tvshow_favorite` partial indexes don't help a plain "all movies for this owner" query either. + A partial index only accelerates queries the planner can prove only match documents inside its partial filter, and a plain list query has no `is_favorite` condition to prove that with. -Fixed by removing the four dead text indexes, adding `car_text`/`car_history_text`, and adding a plain `owner_id` index for every collection that lacked one (`episode` and the two favorite/want-to-watch pairs already had owner_id-prefixed indexes covering it). +Fixed by removing the four dead text indexes, adding `car_text`/`car_history_text`, and adding a plain `owner_id` index for every collection that lacked one. +`episode` and the two favorite/want-to-watch pairs already had owner_id-prefixed indexes covering it, so those were left alone. File: `scripts/mongodb-create-index.js` ### Search was a no-op for Movie and Album Fixed on 2026-07-06 while building the TV Time import feature (both repositories were touched anyway to add the `IsFavorite`/`WantToWatch` filters). -`MovieRepository.GetFilter` and `MusicAlbumRepository.GetFilter` (renamed `AlbumRepository` on 2026-07-07, see "Reference data now covers five domains" below) built a MongoDB filter with `builder.Where(...)` but never combined the result back into the returned `filter`. +`MovieRepository.GetFilter` and `MusicAlbumRepository.GetFilter` (renamed `AlbumRepository` on 2026-07-07, see "Reference data now covers five domains" below) built a MongoDB filter with `builder.Where(...)`. +But it never combined the result back into the returned `filter`. Both now do `filter &= builder.Where(...)`. -A regression test (`MovieResourceTest.MovieResourceSearch_FiltersToMatchingTitle_IsOk`) locks in the Movie fix; `AlbumResourceTest.AlbumResourceSearch_FiltersToMatchingTitleOrArtist_IsOk` (added 2026-07-07) now locks in the Album fix too, closing the gap this finding originally flagged. +A regression test (`MovieResourceTest.MovieResourceSearch_FiltersToMatchingTitle_IsOk`) locks in the Movie fix. +`AlbumResourceTest.AlbumResourceSearch_FiltersToMatchingTitleOrArtist_IsOk` (added 2026-07-07) now locks in the Album fix too, closing the gap this finding originally flagged. Files: @@ -86,10 +105,16 @@ Files: Fixed on 2026-07-09 while building the full Car/CarHistory feature (controller, Blazor pages, metrics, tests). Two related bugs, both in search: -1. `CarHistoryRepository.GetFilter` called `builder.Text(input.CarId)` - a car ID is an exact identifier, not a free-text search term, and MongoDB only allows one `$text` expression per query, so supplying both `CarId` and a free-text `search` at the same time threw ("only one $text expression allowed per query"). -2. `CarRepository` had no `GetFilter` override at all, so it fell back to `MongoDbRepositoryBase`'s default `builder.Text(search)`, which queried the `car_text` index (`{ title: "text" }`) - but `Car`'s BSON field is `commercial_name` (`[BsonElement("commercial_name")]` on `Name`), not `title`. The index never covered the field that exists on the document, so `Car` search had silently never worked at all, on top of (1) never being documented before this session. +1. `CarHistoryRepository.GetFilter` called `builder.Text(input.CarId)`. + A car ID is an exact identifier, not a free-text search term, and MongoDB only allows one `$text` expression per query. + So supplying both `CarId` and a free-text `search` at the same time threw ("only one $text expression allowed per query"). +2. `CarRepository` had no `GetFilter` override at all, so it fell back to `MongoDbRepositoryBase`'s default `builder.Text(search)`, which queried the `car_text` index (`{ title: "text" }`). + But `Car`'s BSON field is `commercial_name` (`[BsonElement("commercial_name")]` on `Name`), not `title`. + The index never covered the field that exists on the document, so `Car` search had silently never worked at all, on top of (1) never being documented before this session. -Fixed by moving both repositories to the same `builder.Where(f => f.X.Contains(search, ...))` regex-search approach already used by Book/Movie/TvShow/VideoGame (`CarRepository` on `Name`, `CarHistoryRepository` on `Description`), filtering `CarId` with a plain `Eq`, and removing the now-unused `car_text`/`car_history_text` indexes from `scripts/mongodb-create-index.js` - closing out the last two exceptions that script's own comments used to call out. +Fixed by moving both repositories to the same `builder.Where(f => f.X.Contains(search, ...))` regex-search approach already used by Book/Movie/TvShow/VideoGame (`CarRepository` on `Name`, `CarHistoryRepository` on `Description`). +This also included filtering `CarId` with a plain `Eq`, and removing the now-unused `car_text`/`car_history_text` indexes from `scripts/mongodb-create-index.js`. +This closed out the last two exceptions that script's own comments used to call out. Regression-tested against a real MongoDB instance: `CarHistoryResourceTest.CarHistoryResourceFilter_ByCarIdAndSearch_DoesNotThrow_IsOk` (the specific dual-filter case) and `CarResourceTest.CarResourceSearch_FiltersByName_IsOk`. Files: @@ -129,8 +154,12 @@ A very large `PageSize` forces an unbounded fetch. `Book` and `Movie` have integration tests (`BookResourceTest`, `MovieResourceTest`); `Movie`'s now also covers `?search=`. `Episode` and `TvShow` gained partial coverage as a side effect of `TvTimeImportResourceTest` (create/upsert/search paths, plus `Episode`'s `TvShowId` filter), but neither has a dedicated full CRUD test of its own yet. -`Album` and `VideoGame` gained full CRUD integration tests (`AlbumResourceTest`, `VideoGameResourceTest`) on 2026-07-07 while their controllers/repositories were touched anyway to add reference-data support - closing this finding for both. `Car` and `CarHistory` gained full CRUD integration tests (`CarResourceTest`, `CarHistoryResourceTest`) plus dedicated unit coverage for `CarMetricsService` on 2026-07-09, when the whole Car/CarHistory feature was built out (controller, Blazor pages, metrics) - closing this finding for both as well. +`Album` and `VideoGame` gained full CRUD integration tests (`AlbumResourceTest`, `VideoGameResourceTest`) on 2026-07-07 while their controllers/repositories were touched anyway to add reference-data support, closing this finding for both. +`Car` and `CarHistory` gained full CRUD integration tests (`CarResourceTest`, `CarHistoryResourceTest`) plus dedicated unit coverage for `CarMetricsService` on 2026-07-09. +This was when the whole Car/CarHistory feature was built out (controller, Blazor pages, metrics), closing this finding for both as well. No test asserts ownership isolation (that user A cannot read, update, or delete user B's record). There is no test project for `BlazorApp` - `AuthenticationController`'s Firebase-custom-claim-to-cookie-claim copy (added for the admin role) has no automated coverage as a result, only manual verification. -The reference-data admin endpoints have integration coverage for the non-admin-rejected (403) path and for the underlying Mongo queries directly (`TvShowReferenceLinkingTest`), but not for the admin-succeeds path over HTTP end-to-end, since that needs a second Firebase test user with the `role: admin` claim pre-set (see `CONTRIBUTING.md`). -`BookResourceTest` and `MovieResourceTest` are also close to copy-pasted; a generic/parameterized test base (mirroring `DataCrudControllerBase` on the production side) would cover all resources without duplicating the test code per type. +The reference-data admin endpoints have integration coverage for the non-admin-rejected (403) path and for the underlying Mongo queries directly (`TvShowReferenceLinkingTest`). +But there's no coverage for the admin-succeeds path over HTTP end-to-end, since that needs a second Firebase test user with the `role: admin` claim pre-set (see `CONTRIBUTING.md`). +`BookResourceTest` and `MovieResourceTest` are also close to copy-pasted. +A generic/parameterized test base (mirroring `DataCrudControllerBase` on the production side) would cover all resources without duplicating the test code per type. From 86646a2a0675f19aa6765a6215e1917bd17051e0 Mon Sep 17 00:00:00 2001 From: Bertrand THOMAS Date: Tue, 14 Jul 2026 18:22:50 +0200 Subject: [PATCH 39/44] Fix line length --- CLAUDE.md | 235 ++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 182 insertions(+), 53 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 092a0c1..2d95db7 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -69,12 +69,14 @@ Project | Depends on Every entity that belongs to a user implements `IHasIdAndOwnerId` (`Id` + `OwnerId`) at all three layers (`Domain` model, MongoDB entity, contract DTO), each with its own class. Mapping between them is generated at compile time by [Riok.Mapperly](https://github.com/riok/mapperly) (a source generator, no runtime reflection) rather than AutoMapper - see `docs/automapper-removal-plan.md` for the removal history: -- `Infrastructure.MongoDb/Mappers/`: one `[Mapper]` partial class per entity pair (e.g. `BookStorageMapper`), implementing `IStorageMapper` (`Infrastructure.MongoDb/Mappers/IStorageMapper.cs`) - MongoDB entity <-> Domain model. +- `Infrastructure.MongoDb/Mappers/`: one `[Mapper]` partial class per entity pair (e.g. `BookStorageMapper`), implementing `IStorageMapper` (`Infrastructure.MongoDb/Mappers/IStorageMapper.cs`) - + MongoDB entity <-> Domain model. Injected into `MongoDbRepositoryBase` and the six owner-less reference repositories. - `WebApi/Mappers/`: one `[Mapper]` partial class per CRUD pair (e.g. `BookDtoMapper`), implementing `IDtoMapper` (`WebApi/Mappers/IDtoMapper.cs`) - DTO <-> Domain model. - `OwnerId` is always set via `[MapValue(nameof(Model.OwnerId), "")]` on the DTO -> model direction (not `[MapperIgnoreTarget]` - `OwnerId` is `required` on the model, so a plain ignore would fail to compile the generated object initializer). + `OwnerId` is always set via `[MapValue(nameof(Model.OwnerId), "")]` on the DTO -> model direction (not `[MapperIgnoreTarget]` - + `OwnerId` is `required` on the model, so a plain ignore would fail to compile the generated object initializer). The placeholder value is immediately overwritten server-side from the authenticated user's claims in `DataCrudControllerBase`, never trusted from client input. - Read-only feature controllers (`WatchNextController`, `WishlistController`, `CarController`/`HouseController`'s metrics, `ReferenceDataController`) use a small one-directional Model-to-DTO mapper class instead (e.g. `CarMetricsDtoMapper`). + Read-only feature controllers (`WatchNextController`, `WishlistController`, `CarController`/`HouseController`'s metrics, `ReferenceDataController`) use a small one-directional Model-to-DTO mapper class instead. It's injected as its concrete type rather than through `IDtoMapper`, since it has no DTO -> Model direction to speak of. Unmapped members are build errors, not a runtime assertion: `RMG012`/`RMG020` (Mapperly's unmapped-target/unmapped-source diagnostics) are escalated to `error` severity in `.editorconfig`. @@ -153,7 +155,7 @@ It's exposed via `CarController.GetMetrics` the same way `VideoGameController.Re The priority (confirmed with the owner) is an exhaustive, browsable action log for insurance purposes plus a yearly cost review, not fuel/mileage tracking or reminders. The owner tracks recurring bills/maintenance schedules elsewhere and explicitly asked for reminders to stay out of scope ("keep it simple, not important, I manage it elsewhere"). Concretely: `HouseHistoryModel` has no `Mileage`/`DeltaMileage`/fuel fields, no location sub-fields (a house doesn't move, unlike a car's refuel stops). -`Domain/Services/HouseMetricsService.cs` has no `ComputeNextMaintenanceDue`-style due-date engine - it only computes `ComputeAnnualCostHistory` (cost per year, broken down by `HouseEventType`: `Maintenance`/`Installation`/`Rework`/`Purchase`/`Bill`/`Other`). +`Domain/Services/HouseMetricsService.cs` has no `ComputeNextMaintenanceDue`-style due-date engine - it only computes `ComputeAnnualCostHistory` (cost per year, broken down by `HouseEventType`). `HouseHistoryModel.HistoryDate` stays `DateOnly` (not `DateTime` like `CarHistoryModel.HistoryDate`) - House has no Car-style same-day-multiple-entries ordering need (a road trip's several refuel stops). So it reuses `CommonStorageMappings` (`Infrastructure.MongoDb/Mappers/`), the shared `DateOnly<->DateTime` UTC-stamping conversion every other date field in the app attaches via `[UseStaticMapper(typeof(CommonStorageMappings))]`, for free. This avoids Car's bespoke hand-written `DateTime.SpecifyKind`/`ModalTimeText` "HH:mm" proxy machinery. @@ -172,7 +174,7 @@ As a side benefit, they no longer need `::deep` to reach into child `*Row` compo ### Reference data (shared, owner-less) -`tvshow_reference` and `movie_reference` (`Domain/Models/TvShowReferenceModel.cs`/`MovieReferenceModel.cs`, `Infrastructure.MongoDb/Entities/TvShowReference.cs`/`MovieReference.cs`) hold metadata (synopsis, episode titles) fetched from TMDB. +`tvshow_reference` and `movie_reference` (`MovieReferenceModel.cs`, `MovieReference.cs`) hold metadata (synopsis, episode titles) fetched from TMDB. They are the one deliberate exception to "every collection has `owner_id`": this data is public facts about a real show/movie, not user content. So storing it once and pointing every tenant's `TvShowModel.ReferenceId`/`MovieModel.ReferenceId` at it avoids duplicating the same show across every user who tracks it. Matching key is normalized title + year (`TitleNormalizer.Normalize`, `Common.System/TitleNormalizer.cs` — shared with `TvTimeImportService` so the two never drift on what counts as "the same title"). @@ -230,7 +232,8 @@ But it still also calls `SetReferenceLinkAsync` with the pre-edit title/year aft When **no** match is found for the current title/year and the document *was* linked, the link is cleared (`ReferenceId` set to `""`) rather than left pointing at something the tenant just told us, by editing the title, is wrong. Clearing it is also exactly what puts the item back into the admin's unresolved queue (`FindDistinctUnresolvedTitleYearsAsync`) for a manual TMDB search. This is deliberately explicit/user-triggered rather than automatic on every page view (no `GetById` side effect), so the behavior stays visible and predictable. -It's also why `Title`/`Year` are unconditionally editable on both `MovieDetail.razor`/`TvShowDetail.razor` regardless of link status - free editing is what makes "fix a typo or a wrong year (or pick a different match), then hit refresh" work. +It's also why `Title`/`Year` are unconditionally editable on both `MovieDetail.razor`/`TvShowDetail.razor` regardless of link status - +free editing is what makes "fix a typo or a wrong year (or pick a different match), then hit refresh" work. `Year` matters here specifically because TMDB search results embedding a year into the title text (e.g. "Dune 2021") is unreliable - the tip that used to suggest doing that was wrong and has been removed. The actual matching (both this local lookup and the live TMDB search behind `InlineReferenceLinker`) always takes year as its own separate field/parameter, never parsed out of title text. The list edit modal (`Movies.razor`/`TvShows.razor`) still locks `Title` for non-admins once linked - that's a separate, intentionally stricter surface for bulk-editing, not an inconsistency to reconcile. @@ -275,7 +278,8 @@ A real-MongoDB integration test (`TvShowReferenceLinkingTest`) is what caught it **Second instance of the same gotcha (also historical - see `docs/automapper-removal-plan.md`):** AutoMapper's `AllowNullDestinationValues = false` used to also change `mapper.Map(source)`. This happened even when `source` itself (not just one of its properties) was `null`. Instead of returning `null`, it returned a new, all-default instance of `TDestination`. -Mapperly (the current mapper) takes the opposite, honest approach: it *throws* on a null source rather than fabricating a default instance, which is exactly why the `entity is null` guard below still matters, just for a different reason now. +Mapperly (the current mapper) takes the opposite, honest approach: it *throws* on a null source rather than fabricating a default instance, which is exactly why the `entity is null` guard below still matters, +just for a different reason now. Every `Find*Async` method on `TvShowReferenceRepository`/`MovieReferenceRepository`/`PersonReferenceRepository` does `var entity = await Collection.Find(...).FirstOrDefaultAsync();`. `entity` can legitimately be null (nothing matched). Mapping it directly would either fabricate a fake found-but-empty model (old AutoMapper behavior) or throw (current Mapperly behavior). @@ -293,7 +297,8 @@ This is confirmed to be TMDB's own sanctioned, standard usage pattern (a separat `CastMemberDto` is fully hydrated server-side (`ReferenceDataController` joins the embedded cast list against `person_reference`) specifically because that join needs repository access a generated mapper doesn't have. `TvShowReferenceDtoMapper`/`MovieReferenceDtoMapper` (`WebApi/Mappers/`) ignore `Cast` via `[MapperIgnoreTarget]` for exactly this reason; don't try to make it a plain mapped member. -`TvShowDetail.razor`'s episode list is a full watch-through checklist (every reference episode, checkbox = watched) once the show has a `ReferenceId`, falling back to the original recorded-episodes-only view with a manual add form when it doesn't. +`TvShowDetail.razor`'s episode list is a full watch-through checklist (every reference episode, checkbox = watched) once the show has a `ReferenceId`, +falling back to the original recorded-episodes-only view with a manual add form when it doesn't. There's no way to know the full episode count without reference data, so that fallback is a deliberate scope boundary, not a bug. Checking a box creates an `Episode` with `WatchedAt = today`; unchecking deletes it - there's no way to set an arbitrary watched date from this view once a show is resolved. @@ -350,7 +355,8 @@ Don't extend the older feature-folder shape to new code; follow `WatchNextContro `seen_episode_source.csv` alone is a drastically incomplete picture of a user's episode history (it's only written when an episode is marked watched via TV Time's episode-detail screen) - confirmed against real export data, not assumed. `TvTimeImportService` also reads `tracking-prod-records.csv` and `tracking-prod-records-v2.csv`, TV Time's generic event logs, which capture episodes marked watched any other way (bulk/season actions). All three are merged and de-duplicated per (show, season, episode), earliest date wins, before upserting `Episode`s. -If a future TV Time export field looks suspiciously sparse, check the raw export files directly (`grep` the show name across every `*.csv`) before assuming the current parser set is complete - this is exactly how the tracking files were found. +If a future TV Time export field looks suspiciously sparse, check the raw export files directly (`grep` the show name across every `*.csv`) before assuming the current parser set is complete - +this is exactly how the tracking files were found. `followed_tv_show.csv` is not a complete list of shows either - confirmed with a real show ("The Pitt") that has genuine watch history in the tracking files but no row in `followed_tv_show.csv` at all. `ImportEpisodesAsync` creates a show on the fly from watch-event data (title, plus the show's TV Time id when the source file has one) rather than skipping shows that aren't already known. @@ -361,7 +367,8 @@ The import is idempotent by matching on a stable, enrichment-immutable id, **not Re-running an import used to duplicate every show/movie (and, via the new show id, all their episodes). Shows/movies were matched by normalized `Title`, but reference enrichment rewrites `Title` to the provider's canonical name after the first import (`SetReferenceLinkAsync`). So on the second import the export's original title no longer matched and a duplicate was created - confirmed by a real re-import. -The fix stamps every imported show/movie with `TvTimeId` (`IHasTvTimeId`, a real Domain field on `TvShowModel`/`MovieModel` carried through entity/DTO like `ReferenceId`, and round-tripped on edits since `UpdateAsync` is a full `ReplaceOneAsync`). +The fix stamps every imported show/movie with `TvTimeId` (`IHasTvTimeId`, a real Domain field on `TvShowModel`/`MovieModel` carried through entity/DTO like `ReferenceId`, +and round-tripped on edits since `UpdateAsync` is a full `ReplaceOneAsync`). This is TV Time's own show id for shows (`followed_tv_show.csv`/the tracking logs), and the per-movie tracking `uuid` for movies (every follow/watch/towatch row for one movie shares it). Movies do have a stable id after all, contrary to the older "movies have no stable id" note, which was only ever true of the per-vote uuid in the rating files. When the export carries no id for a title (a movie known only from the vote files; a show seen only in `seen_episode_source.csv`), `ResolveTvTimeId` synthesizes a fallback. @@ -484,14 +491,16 @@ Book authors and album artists are deduplicated the same way TV/movie cast is: ` "Person" already meant "a named individual or group identified by an external provider id," not "actor" specifically. So extending it to a book's author (Open Library author id) or an album's artist (Discogs artist id, which can be a group/band) needed no rename, just reuse. `BookReferenceModel.AuthorReferenceId`/`AlbumReferenceModel.ArtistReferenceId` point at a `PersonReferenceModel` document instead of embedding a plain name string. -`ReferenceEnrichmentService.ResolvePersonReferenceIdAsync` (shared helper in the core partial-class file) is the single dedup-by-external-id path used by cast resolution (`ResolveCastAsync`, refactored to call it per member) and by `ResolveBookAsync`/`ResolveAlbumAsync`. +`ReferenceEnrichmentService.ResolvePersonReferenceIdAsync` (shared helper in the core partial-class file) is the single dedup-by-external-id path used by cast resolution (`ResolveCastAsync`, refactored to call it per member) +and by `ResolveBookAsync`/`ResolveAlbumAsync`. `BookReferenceDto.AuthorName`/`AlbumReferenceDto.ArtistName` are hydrated by `ReferenceDataController` joining `person_reference` by id (same `[MapperIgnoreTarget]` + manual join pattern as `Cast`). The model only carries the id, never a denormalized name, so there's nothing to keep in sync. When linking (`TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync`), the tenant's own plain-string `BookModel.Author`/`AlbumModel.Artist` is still populated. This works by resolving the reference's `*ReferenceId` to a name at link time (`ResolvePersonNameAsync`). The tenant-facing field stays a free-text string editable like `Title`, only the shared reference document uses the dedup'd id. -`ReferenceEnrichmentService` is a single `partial class` split across `.TvShowsAndMovies.cs`/`.Books.cs`/`.VideoGames.cs`/`.Albums.cs` files (one class, same constructor, same five-method-per-domain template: `TryLinkExistingReferenceAsync`/`TryAutoResolveAsync`/`ResolveAsync`/`RefreshReferenceAsync`). +`ReferenceEnrichmentService` is a single `partial class` split across `.TvShowsAndMovies.cs`/`.Books.cs`/`.VideoGames.cs`/`.Albums.cs` files (one class, same constructor, same five-method-per-domain template: +`TryLinkExistingReferenceAsync`/`TryAutoResolveAsync`/`ResolveAsync`/`RefreshReferenceAsync`). Splitting by file rather than by class keeps the shared helpers (`MergeMatchedAliases`, `TitleNormalizer.Normalize`) in one place without one file growing to cover six domains' worth of logic. `ReferenceMatchModel`/`MatchedAliases` needed no changes at all to support the new domains - it was already generic, not TMDB-specific, per its original naming decision. @@ -506,7 +515,8 @@ Cover art, synopsis and genres render when linked, plus the same refresh-referen None of the three have a cast/credits concept, so there's no `CastGrid` equivalent for them. **Gotcha:** `OpenLibraryClient.GetBookDetailsAsync` fetches a work's year from `first_publish_date` on `/works/{id}.json`, but that field is routinely absent from the work document itself. -This was confirmed against the real API for a book as well-known as Lee Child's "Killing Floor" (`/works/OL24477958W.json` has no `first_publish_date` at all), while the search index's computed `first_publish_year` for the same work is reliable. +This was confirmed against the real API for a book as well-known as Lee Child's "Killing Floor" (`/works/OL24477958W.json` has no `first_publish_date` at all), +while the search index's computed `first_publish_year` for the same work is reliable. `GetBookDetailsAsync` falls back to `FindPublishYearViaSearchAsync` (a single-document `q=key:{workKey}` search re-query) whenever the work-level parse comes back null. This is rather than silently leaving `BookReferenceModel.Year`/the tenant's own `BookModel.Year` unset after a link. @@ -515,81 +525,200 @@ The closest available signal is the search index's `person`/`subject_people` fac It doesn't generalize (many series aren't named after - or don't have - a recurring eponymous character, and a standalone book can still feature a named character). It's not wired up to `BookModel.Series`/`BookReferenceModel` for that reason - auto-filling `Series` from it would be right by coincidence for character-titled franchises and wrong or absent otherwise. -`Album`/`Book` gained `IsFavorite` (`AlbumModel`/`Album`/`AlbumDto`, `BookModel`/`Book`/`BookDto`), same shape as `Movie`/`TvShow`'s existing flag: a partial Mongo index (`album_favorite`/`book_favorite`, `scripts/mongodb-create-index.js`), a `Favorites` filter button in each list page's `Filters` slot, and a toggle button on `AlbumDetail.razor`/`BookDetail.razor`'s page header (same `kt-toggle-btn`/`active` pattern as `MovieDetail.razor`). +`Album`/`Book` gained `IsFavorite` (`AlbumModel`/`Album`/`AlbumDto`, `BookModel`/`Book`/`BookDto`), same shape as `Movie`/`TvShow`'s existing flag: +a partial Mongo index (`album_favorite`/`book_favorite`, `scripts/mongodb-create-index.js`), a `Favorites` filter button in each list page's `Filters` slot, +and a toggle button on `AlbumDetail.razor`/`BookDetail.razor`'s page header (same `kt-toggle-btn`/`active` pattern as `MovieDetail.razor`). `VideoGameModel.State` stays a plain free-text string (not an enum like `TvShowModel.State`) deliberately. Real tenant data already has values like `"To resume"`/`"On-hold"` that aren't valid C# enum member names, and MongoDB's `EnumRepresentationConvention(BsonType.String)` deserializes by matching the enum member name exactly. So converting would require a data migration with real breakage risk for existing documents. -Filtering by state (`VideoGameRepository.GetFilter` already supported exact-match filtering by `input.State`) is instead exposed as list-page filter buttons (`VideoGames.razor`'s `Filters` slot, same visual pattern as `TvShows.razor`'s `TvShowStatus` filter buttons) over the existing string values. -The Add/Edit forms' State `` was replaced with a button group (`VideoGames.VideoGameStates`, the shared array both the filter and the form buttons iterate over) for the same reason TvShow's own state buttons exist - +clicking a value is faster than a dropdown for a small fixed set. `FinishedAt` is a plain, always-visible date field on `VideoGameDetail.razor`'s card (not a corner-flag toggle like `MovieDetail.razor`'s "Mark as watched"/`BookDetail.razor`'s "Mark as read"). It was previously only editable once already set elsewhere, with no way to set it from scratch on the detail page. Unlike Movie/Book, "finished" already has its own explicit `State` value ("Completed") to toggle, so `FinishedAt` doesn't need a second boolean-flag affordance layered on top. -**`VideoGameDetail.razor`'s own State editor follows `TvShowDetail.razor`'s per-item State pattern exactly, not the list page's filter-button pattern.** These look superficially similar (both are button rows) but behave differently, and the two were conflated once already. +**`VideoGameDetail.razor`'s own State editor follows `TvShowDetail.razor`'s per-item State pattern exactly, not the list page's filter-button pattern.** These look superficially similar (both are button rows) but behave differently, +and the two were conflated once already. The per-item editor buttons live in their own row directly below the page header (not inside the `kt-form-card` next to Year/Rating). Clicking the already-active value clears it back to unset (`SetStateAsync`: `_game.State = _game.State == state ? "" : state`, mirroring `TvShowDetail.razor`'s own `SetStateAsync`). The list page's filter buttons are a different control with different semantics (an explicit "All" option to clear, since a filter and a per-item value aren't the same kind of state). -**`TvShowModel.Status` was renamed to `TvShowModel.State`** for naming parity with `VideoGameModel.State` (`TvShowDto.State`, `TvShow.State` entity property, `TvShowRepository.GetFilter`'s `input.State`, `TvShows.razor`'s `_stateFilter`/`SetStateFilterAsync`/`ExtraQuery["State"]`, `TvShowDetail.razor`'s `SetStateAsync` all renamed to match). The enum type itself keeps its `TvShowStatus` name - only the property that holds it moved to `State`, since `VideoGameModel.State` has no equivalent enum to rename against. Unlike the `PosterUrl`→`ImageUrl` rename below, this one needed **no** data migration: `TvShow`'s entity property kept an explicit `[BsonElement("status")]` pointing at the unchanged storage name, so existing documents (confirmed directly against the real dev database - `status: 'Finished'` reads back correctly through the renamed `State` property) deserialize with no script required. `TvTimeImportService`/`ShowStatusCsvParser`'s `ShowStatusRecord.Status` is a same-named but *entirely unrelated* field - TV Time's own CSV column for favorite/for_later, mapped to `IsFavorite`/`WantToWatch`, never to this enum - so the import pipeline needed no changes at all for this rename; verified by tracing every consumer before renaming, not just running the test suite. `WatchNextService`/`WatchNextController`'s `Status == TvShowStatus.Current` checks were updated to `State == TvShowStatus.Current` and covered by `WatchNextServiceTest`, which still passes. - -**Gotcha:** an optional narrowing parameter on an external search must never be allowed to silently zero out results that a broader search would find - this bit both the Open Library year filter (see above) and, separately, `IDiscogsClient.SearchAlbumsAsync`'s `artist` parameter: a tenant's own `AlbumModel.Artist` text passed straight through as Discogs' `artist=` query field can fail to match Discogs' own exact indexing (a disambiguation suffix like `"Artist (2)"`, different capitalization/formatting), returning zero candidates even though the title alone finds the album - confirmed with a real title ("Born Pink") that returned nothing via `AlbumDetail.razor`'s `InlineReferenceLinker` (which always passes the tracked album's own `Artist`) but succeeded via the admin page (whose first search per selected item always passes no creator). Both `DiscogsClient.SearchAlbumsAsync` and `OpenLibraryClient.SearchBooksAsync` now retry once without the narrowing author/artist parameter whenever the constrained search comes back empty, rather than reporting a false "not found." - -**Gotcha:** `OpenLibraryClient` searched via `search.json?title=...` (a field-scoped exact match against the work's own canonical title), which misses regional title variants entirely - confirmed against the real API that "Harry Potter and the Sorcerer's Stone" (the US title) only matches a handful of near-empty, 1-edition work stubs this way, because Open Library's actual canonical work for this book is titled "Harry Potter and the Philosopher's Stone" (the UK title) and carries 398 editions. Switched to `search.json?q=...` (a general relevance-ranked query across title, alternate titles, etc.), which correctly surfaces the well-populated canonical work first in this case while still returning the same top result as before for titles that don't have this regional-variant problem (e.g. "The Return of the King"). This also explains why some resolved covers can look like a plain, uninteresting library rebinding rather than an illustrated dust jacket even once the *correct* work is matched (confirmed for "The Return of the King", `OL27455W`) - Open Library's own `covers` array for a work is whatever has been scanned/contributed, not curated by "which looks best," and the first entry there is already identical to the search index's own `cover_i` in the cases checked; there's no metadata signal (short of actual image content analysis, out of scope here) to pick a nicer-looking alternative from the same array. - -**Gotcha:** when `PosterUrl` was renamed to `ImageUrl` on `TvShowReferenceModel`/`MovieReferenceModel`, existing `tvshow_reference`/`movie_reference` documents created before the rename kept their data under the old `poster_url` BSON field - the new entity class only ever reads `image_url`, so every pre-existing reference document silently lost its cover image (confirmed against a real dev database: 72/87 TV show references and 343/353 movie references still had the old field name). Fixed with a one-off migration, `scripts/migrate-poster-url-to-image-url.js` (idempotent `$rename`, safe to re-run) - run it once against any environment with reference data older than the rename. This is the same class of risk as the earlier `music-album` → `album` collection rename (see "Reference data now covers five domains" above): a data-shape rename in code needs an explicit, documented migration step for whatever already exists in Mongo, not just updated `[BsonElement]` attributes. - -`ReferenceMatchModel.Creator` (nullable `string`) extends the `MatchedAliases` match key beyond just (title, year) - a title+year match alone risks silently linking a tenant's book/album to a *different* tenant's unrelated one that happens to share a common title and year (a generic name re-published/re-released the same year is common; TV/movie titles almost never collide this hard, which is why they don't need this). `IBookReferenceRepository`/`IAlbumReferenceRepository`'s `FindByTitleYearAsync`/`FindByTitleAsync` now take a required `author`/`artist` parameter and add a `Creator` equality condition to the same `ElemMatch` filter (both title and creator normalized via `TitleNormalizer.Normalize`) - `Creator` is always derived from the **canonical** resolved `details.Author`/`details.Artist` (the external API's own response), never from whatever text the tenant/admin originally typed, since that let the design avoid adding a new parameter to `ResolveBookAsync`/`ResolveAlbumAsync`, `LinkReferenceRequestDto`, or the admin linking UI. TvShow/Movie/VideoGame's `MergeMatchedAliases` calls all pass `null` for `Creator` (no creator dimension in those domains' match key) - the shared helper's third tuple element is `null` for them, not omitted, since `ReferenceMatchModel` stays one generic shape across every domain rather than growing a Book/Album-only subtype. `BookReferenceRepository`/`AlbumReferenceRepository.UpsertAsync`'s defensive "always include the canonical title/year alias" safety net can't set `Creator` (the model only carries `AuthorReferenceId`/`ArtistReferenceId`, a dedup'd link, not denormalized text) - that alias is simply unreachable via the creator-required find methods, which is harmless (the normal Resolve/Refresh path always adds a proper creator-bearing alias first) rather than a false-positive risk; a real-MongoDB integration test (`BookReferenceRepositoryTest`/`AlbumReferenceRepositoryTest`) asserts on the stored alias directly for this specific case rather than through the creator-required lookup, since that lookup can no longer find it by design. - -**Gotcha (historical - structurally fixed by the AutoMapper -> Mapperly migration):** `MergeMatchedAliases`' dedup check compares a freshly-computed `Creator` against an existing alias's `Creator` (`m.Creator == normalizedCreator`), which used to silently duplicate aliases on every re-resolve/re-refresh for TV show/movie/video game (the three domains that always pass `null` for `Creator`, having no creator dimension). The reason: `AllowNullDestinationValues = false` (a profile-wide AutoMapper default, since removed along with AutoMapper itself) substituted `""` for a null *string* member during model → entity mapping - so a freshly-built alias with `Creator = null` got persisted as `Creator = ""`, and on the *next* resolve/refresh the freshly computed `normalizedCreator` (still literally `null`) never equalled that already-persisted `""`, so the dedup check saw no existing match and appended an exact duplicate `{title, year, creator: ""}` entry. Confirmed against a real video game reference (RAWG's "God of War", resolved/refreshed more than once) that had accumulated a literal duplicate alias this way. - -The fix belonged at the mapping/entity layer, not as a comparison workaround in `MergeMatchedAliases` (an `(m.Creator ?? "") == (normalizedCreator ?? "")` patch was tried first and reverted) - at the time, `DataStorageMappingProfile`'s `ReferenceMatchModel` → `ReferenceMatch` map opted `Creator` out of the profile-wide default with `.ForMember(x => x.Creator, opt => opt.AllowNull())`, so a null `Creator` reached Mongo as an actual null again, and `MergeMatchedAliases` stayed a plain, honest `m.Creator == normalizedCreator`. That per-member opt-out is gone now, not just moved: Mapperly (the current mapper) preserves nulls by default, so every storage mapper's `Creator` mapping is a real null with no configuration needed at all - this entire class of bug is structurally impossible today, not merely patched. From there, the *already-registered*, codebase-wide `IgnoreIfNullConvention(true)` (`InfrastructureServiceCollectionExtensions.AddMongoDbInfrastructure`) does the rest for free - it omits any null property from the stored document, which is why `Year` (also nullable on `ReferenceMatch`) was never affected by this bug in the first place and needed no equivalent per-property `[BsonIgnoreIfNull]` fix; that attribute doesn't appear anywhere in this codebase, and shouldn't - "is this field omitted when unset" is a driver-convention-level answer here, not a per-entity one. Was covered by `RefreshVideoGameReferenceAsync_DoesNotDuplicateAnAliasAlreadyPersistedWithANullCreator` (unit, mocked) and `TvShowReferenceRepositoryTest.UpsertAsync_PersistsANullCreator_AsAnActualBsonNullNotAnEmptyString` (integration, real MongoDB - the only way to actually catch a serialization-level regression like this one); both still pass under Mapperly as a regression guard, even though the bug they were written for can no longer occur. A scan of the real dev database found only the one "God of War" document actually duplicated, cleaned up with the idempotent `scripts/dedupe-matched-aliases.js` (same "run once per environment" pattern as `migrate-poster-url-to-image-url.js`). - -`BookModel`/`AlbumModel.Genre` (a single free-text field, not a list - it predates the reference-data feature, same as `Author`/`Artist` before `PersonReferenceModel` existed) is now propagated on link the same way `Title`/`Year`/`Author`/`Artist` already are: `TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync` and `ResolveBookAsync`/`ResolveAlbumAsync` join the reference's `Genres` list (`JoinGenres`, a shared helper in `ReferenceEnrichmentService.cs`) into that single field, both on the tenant's own document and via `IBookRepository`/`IAlbumRepository.SetReferenceLinkAsync`'s new `canonicalGenre` parameter (cross-tenant propagation, same incremental-parameter pattern already used for `canonicalAuthor`/`canonicalArtist`) - null (not overwritten) when the reference has no genres, same "don't overwrite with nothing" rule the other propagated fields already follow. `BookDetail.razor`/`AlbumDetail.razor` previously displayed the *reference's* raw `Genres` list directly (a read-only comma-joined paragraph) but never touched the tenant's own `Genre` field at all - that display was replaced with a plain editable `Genre` input (same shape as `Author`/`Series`/`Artist`), matching how `Author`/`Artist` already work: the reference data flows into the one tenant-owned field on link, there's no separate "raw reference value" display once linked. - -Books are the one reference domain behind a provider-agnostic interface rather than a provider-named one: `IBookReferenceClient` (`BookSearchResult`/`BookDetails` DTOs, an `IBookReferenceClient.ProviderKey` string) instead of `IOpenLibraryClient`. TV show/movie/video game/album stay hard-wired to TMDB/RAWG/Discogs directly (their DTOs and hardcoded `"tmdb"`/`"rawg"`/`"discogs"` `ExternalIds` keys are provider-named on purpose - swapping any of those would be a bigger redesign, not a config change). Which implementation of `IBookReferenceClient` is registered is a deployment-time choice, `ReferenceData:BookProvider` (`ReferenceData__BookProvider` as an environment variable, `Program.cs` switches on it), defaulting to `OpenLibrary` - the only implementation that ships today. `ReferenceEnrichmentService.Books.cs` never hardcodes a provider name; every `ExternalIds`/person-reference lookup keys off the injected `IBookReferenceClient.ProviderKey` instead, so a second implementation only needs its own class (`OpenLibraryClient`-shaped: base address, optional settings class, `ProviderKey`) plus one new `case` in `Program.cs` - no changes to the enrichment service or admin controller. +**`TvShowModel.Status` was renamed to `TvShowModel.State`** for naming parity with `VideoGameModel.State` +(`TvShowDto.State`, `TvShow.State` entity property, `TvShowRepository.GetFilter`'s `input.State`, `TvShows.razor`'s `_stateFilter`/`SetStateFilterAsync`/`ExtraQuery["State"]`, `TvShowDetail.razor`'s `SetStateAsync` all renamed to match). +The enum type itself keeps its `TvShowStatus` name - only the property that holds it moved to `State`, since `VideoGameModel.State` has no equivalent enum to rename against. +Unlike the `PosterUrl`→`ImageUrl` rename below, this one needed **no** data migration: `TvShow`'s entity property kept an explicit `[BsonElement("status")]` pointing at the unchanged storage name, +so existing documents (confirmed directly against the real dev database - `status: 'Finished'` reads back correctly through the renamed `State` property) deserialize with no script required. +`TvTimeImportService`/`ShowStatusCsvParser`'s `ShowStatusRecord.Status` is a same-named but *entirely unrelated* field - TV Time's own CSV column for favorite/for_later, mapped to `IsFavorite`/`WantToWatch`,never to this enum - +so the import pipeline needed no changes at all for this rename; verified by tracing every consumer before renaming, not just running the test suite. +`WatchNextService`/`WatchNextController`'s `Status == TvShowStatus.Current` checks were updated to `State == TvShowStatus.Current` and covered by `WatchNextServiceTest`, which still passes. + +**Gotcha:** an optional narrowing parameter on an external search must never be allowed to silently zero out results that a broader search would find - +this bit both the Open Library year filter (see above) and, separately, `IDiscogsClient.SearchAlbumsAsync`'s `artist` parameter: +a tenant's own `AlbumModel.Artist` text passed straight through as Discogs' `artist=` query field can fail to match Discogs' own exact indexing (a disambiguation suffix like `"Artist (2)"`, different capitalization/formatting), +returning zero candidates even though the title alone finds the album - confirmed with a real title ("Born Pink") that returned nothing via `AlbumDetail.razor`'s `InlineReferenceLinker` +(which always passes the tracked album's own `Artist`) but succeeded via the admin page (whose first search per selected item always passes no creator). +Both `DiscogsClient.SearchAlbumsAsync` and `OpenLibraryClient.SearchBooksAsync` now retry once without the narrowing author/artist parameter whenever the constrained search comes back empty, rather than reporting a false "not found." + +**Gotcha:** `OpenLibraryClient` searched via `search.json?title=...` (a field-scoped exact match against the work's own canonical title), which misses regional title variants entirely - +confirmed against the real API that "Harry Potter and the Sorcerer's Stone" (the US title) only matches a handful of near-empty, 1-edition work stubs this way, +because Open Library's actual canonical work for this book is titled "Harry Potter and the Philosopher's Stone" (the UK title) and carries 398 editions. +Switched to `search.json?q=...` (a general relevance-ranked query across title, alternate titles, etc.), +which correctly surfaces the well-populated canonical work first in this case while still returning the same top result as before for titles that don't have this regional-variant problem (e.g. "The Return of the King"). +This also explains why some resolved covers can look like a plain, uninteresting library rebinding rather than an illustrated dust jacket even once the *correct* work is matched (confirmed for "The Return of the King", `OL27455W`) - +Open Library's own `covers` array for a work is whatever has been scanned/contributed, not curated by "which looks best," and the first entry there is already identical to the search index's own `cover_i` in the cases checked; +there's no metadata signal (short of actual image content analysis, out of scope here) to pick a nicer-looking alternative from the same array. + +**Gotcha:** when `PosterUrl` was renamed to `ImageUrl` on `TvShowReferenceModel`/`MovieReferenceModel`, +existing `tvshow_reference`/`movie_reference` documents created before the rename kept their data under the old `poster_url` BSON field - the new entity class only ever reads `image_url`, +so every pre-existing reference document silently lost its cover image (confirmed against a real dev database: 72/87 TV show references and 343/353 movie references still had the old field name). +Fixed with a one-off migration, `scripts/migrate-poster-url-to-image-url.js` (idempotent `$rename`, safe to re-run) - run it once against any environment with reference data older than the rename. +This is the same class of risk as the earlier `music-album` → `album` collection rename (see "Reference data now covers five domains" above): +a data-shape rename in code needs an explicit, documented migration step for whatever already exists in Mongo, not just updated `[BsonElement]` attributes. + +`ReferenceMatchModel.Creator` (nullable `string`) extends the `MatchedAliases` match key beyond just (title, year) - +a title+year match alone risks silently linking a tenant's book/album to a *different* tenant's unrelated one that happens to share a common title and year +(a generic name re-published/re-released the same year is common; TV/movie titles almost never collide this hard, which is why they don't need this). +`IBookReferenceRepository`/`IAlbumReferenceRepository`'s `FindByTitleYearAsync`/`FindByTitleAsync` now take a required `author`/`artist` parameter and add a `Creator` equality condition to the same `ElemMatch` filter +(both title and creator normalized via `TitleNormalizer.Normalize`) - `Creator` is always derived from the **canonical** resolved `details.Author`/`details.Artist` (the external API's own response), +never from whatever text the tenant/admin originally typed, since that let the design avoid adding a new parameter to `ResolveBookAsync`/`ResolveAlbumAsync`, `LinkReferenceRequestDto`, or the admin linking UI. +TvShow/Movie/VideoGame's `MergeMatchedAliases` calls all pass `null` for `Creator` (no creator dimension in those domains' match key) - the shared helper's third tuple element is `null` for them, not omitted, +since `ReferenceMatchModel` stays one generic shape across every domain rather than growing a Book/Album-only subtype. +`BookReferenceRepository`/`AlbumReferenceRepository.UpsertAsync`'s defensive "always include the canonical title/year alias" safety net can't set `Creator` (the model only carries `AuthorReferenceId`/`ArtistReferenceId`, a dedup'd link, +not denormalized text) - that alias is simply unreachable via the creator-required find methods, which is harmless (the normal Resolve/Refresh path always adds a proper creator-bearing alias first) rather than a false-positive risk; +a real-MongoDB integration test (`BookReferenceRepositoryTest`/`AlbumReferenceRepositoryTest`) asserts on the stored alias directly for this specific case rather than through the creator-required lookup, +since that lookup can no longer find it by design. + +**Gotcha (historical - structurally fixed by the AutoMapper -> Mapperly migration):** `MergeMatchedAliases`' dedup check compares a freshly-computed `Creator` against an existing alias's `Creator` (`m.Creator == normalizedCreator`), +which used to silently duplicate aliases on every re-resolve/re-refresh for TV show/movie/video game (the three domains that always pass `null` for `Creator`, having no creator dimension). +The reason: `AllowNullDestinationValues = false` (a profile-wide AutoMapper default, since removed along with AutoMapper itself) substituted `""` for a null *string* member during model → entity mapping - +so a freshly-built alias with `Creator = null` got persisted as `Creator = ""`, and on the *next* resolve/refresh the freshly computed `normalizedCreator` (still literally `null`) never equalled that already-persisted `""`, +so the dedup check saw no existing match and appended an exact duplicate `{title, year, creator: ""}` entry. +Confirmed against a real video game reference (RAWG's "God of War", resolved/refreshed more than once) that had accumulated a literal duplicate alias this way. + +The fix belonged at the mapping/entity layer, not as a comparison workaround in `MergeMatchedAliases` (an `(m.Creator ?? "") == (normalizedCreator ?? "")` patch was tried first and reverted) - +at the time, `DataStorageMappingProfile`'s `ReferenceMatchModel` → `ReferenceMatch` map opted `Creator` out of the profile-wide default with `.ForMember(x => x.Creator, opt => opt.AllowNull())`, +so a null `Creator` reached Mongo as an actual null again, and `MergeMatchedAliases` stayed a plain, honest `m.Creator == normalizedCreator`. +That per-member opt-out is gone now, not just moved: Mapperly (the current mapper) preserves nulls by default, so every storage mapper's `Creator` mapping is a real null with no configuration needed at all - +this entire class of bug is structurally impossible today, not merely patched. +From there, the *already-registered*, codebase-wide `IgnoreIfNullConvention(true)` (`InfrastructureServiceCollectionExtensions.AddMongoDbInfrastructure`) does the rest for free - +it omits any null property from the stored document, which is why `Year` (also nullable on `ReferenceMatch`) was never affected by this bug in the first place and needed no equivalent per-property `[BsonIgnoreIfNull]` fix; +that attribute doesn't appear anywhere in this codebase, and shouldn't - "is this field omitted when unset" is a driver-convention-level answer here, not a per-entity one. +Was covered by `RefreshVideoGameReferenceAsync_DoesNotDuplicateAnAliasAlreadyPersistedWithANullCreator` (unit, mocked) and `TvShowReferenceRepositoryTest.UpsertAsync_PersistsANullCreator_AsAnActualBsonNullNotAnEmptyString` +(integration, real MongoDB - the only way to actually catch a serialization-level regression like this one); both still pass under Mapperly as a regression guard, even though the bug they were written for can no longer occur. +A scan of the real dev database found only the one "God of War" document actually duplicated, cleaned up with the idempotent `scripts/dedupe-matched-aliases.js` +(same "run once per environment" pattern as `migrate-poster-url-to-image-url.js`). + +`BookModel`/`AlbumModel.Genre` (a single free-text field, not a list - +it predates the reference-data feature, same as `Author`/`Artist` before `PersonReferenceModel` existed) is now propagated on link the same way `Title`/`Year`/`Author`/`Artist` already are: +`TryLinkExistingBookReferenceAsync`/`TryLinkExistingAlbumReferenceAsync` and `ResolveBookAsync`/`ResolveAlbumAsync` join the reference's `Genres` list +(`JoinGenres`, a shared helper in `ReferenceEnrichmentService.cs`) into that single field, +both on the tenant's own document and via `IBookRepository`/`IAlbumRepository.SetReferenceLinkAsync`'s new `canonicalenre` parameter +(cross-tenant propagation, same incremental-parameter pattern already used for `canonicalAuthor`/`canonicalArtist`) - +null (not overwritten) when the reference has no genres, same "don't overwrite with nothing" rule the other propagated fields already follow. +`BookDetail.razor`/`AlbumDetail.razor` previously displayed the *reference's* raw `Genres` list directly (a read-only comma-joined paragraph) but never touched the tenant's own `Genre` field at all - +that display was replaced with a plain editable `Genre` input (same shape as `Author`/`Series`/`Artist`), matching how `Author`/`Artist` already work: the reference data flows into the one tenant-owned field on link, +there's no separate "raw reference value" display once linked. + +Books are the one reference domain behind a provider-agnostic interface rather than a provider-named one: `IBookReferenceClient` (`BookSearchResult`/`BookDetails` DTOs, +an `IBookReferenceClient.ProviderKey` string) instead of `IOpenLibraryClient`. +TV show/movie/video game/album stay hard-wired to TMDB/RAWG/Discogs directly (their DTOs and hardcoded `"tmdb"`/`"rawg"`/`"discogs"` `ExternalIds` keys are provider-named on purpose - +swapping any of those would be a bigger redesign, not a config change). +Which implementation of `IBookReferenceClient` is registered is a deployment-time choice, `ReferenceData:BookProvider` (`ReferenceData__BookProvider` as an environment variable, `Program.cs` switches on it), defaulting to `OpenLibrary` - +the only implementation that ships today. +`ReferenceEnrichmentService.Books.cs` never hardcodes a provider name; every `ExternalIds`/person-reference lookup keys off the injected `IBookReferenceClient.ProviderKey` instead, +so a second implementation only needs its own class (`OpenLibraryClient`-shaped: base address, optional settings class, `ProviderKey`) plus one new `case` in `Program.cs` - no changes to the enrichment service or admin controller. ### Blazor app -`InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, which wraps the typed `HttpClient` calls to the Web API (its `GetAsync` takes an optional extra-query-parameters dictionary, used by features that filter on more than search/page/pageSize). Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. A page that needs its own filter beyond search (e.g. `TvShows.razor.cs`'s state filter) overrides the base's `protected virtual ExtraQuery` property instead of reimplementing paging/search - `LoadAsync` is `protected` for exactly this reason, so the page can trigger a reload after changing its own filter state. Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. +`InventoryPageBase` (`BlazorApp/Components/Inventory/InventoryPageBase.cs`) centralizes list/paging/search/inline-edit state and calls into `InventoryApiClientBase`, +which wraps the typed `HttpClient` calls to the Web API (its `GetAsync` takes an optional extra-query-parameters dictionary, used by features that filter on more than search/page/pageSize). +Each concrete page (`Books.razor.cs`, `Movies.razor.cs`, ...) only supplies its `Api` instance and `CloneItem`. +A page that needs its own filter beyond search (e.g. `TvShows.razor.cs`'s state filter) overrides the base's `protected virtual ExtraQuery` property instead of reimplementing paging/search - +`LoadAsync` is `protected` for exactly this reason, so the page can trigger a reload after changing its own filter state. +Authentication uses Firebase (cookie auth in the Blazor app, JWT bearer validated against Firebase in the Web API); `AuthenticationTokenHandler` attaches the bearer token to outgoing API calls. -Pages that aren't a generic CRUD list (`TvShowDetail.razor`, `WatchNext/WatchNextPage.razor`, `Import/ImportPage.razor`) don't extend `InventoryPageBase`/`InventoryList` — they're free to build their own layout on top of the shared `kt-*` CSS classes in `app.css`. Their API clients live next to them in a feature folder rather than in `Inventory/Clients/`. +Pages that aren't a generic CRUD list (`TvShowDetail.razor`, `WatchNext/WatchNextPage.razor`, `Import/ImportPage.razor`) don't extend `InventoryPageBase`/`InventoryList` — +they're free to build their own layout on top of the shared `kt-*` CSS classes in `app.css`. +Their API clients live next to them in a feature folder rather than in `Inventory/Clients/`. -**Gotcha:** passing a field to a `string`-typed component `[Parameter]` needs the `@` prefix - `Title="_movie.Title"` binds the **literal text** `"_movie.Title"`, not the property's value. Razor only auto-detects that an attribute value must be C# code when the parameter's type couldn't otherwise accept a string literal (e.g. `Year="_movie.Year"` on an `int?` parameter works unprefixed, because a bare identifier can't type-check as one); a `string` parameter can always accept a literal, so Razor takes it at face value instead. This compiles and renders with no error - the bug only shows up in the *data*, not the markup - which is exactly what happened when `InlineReferenceLinker`'s `Title="_movie.Title"` sent the literal string `_movie.Title` to TMDB's search instead of the movie's actual title, returning an unrelated result. Always write `Title="@_movie.Title"` for string parameters bound to a field/property. +**Gotcha:** passing a field to a `string`-typed component `[Parameter]` needs the `@` prefix - `Title="_movie.Title"` binds the **literal text** `"_movie.Title"`, not the property's value. +Razor only auto-detects that an attribute value must be C# code when the parameter's type couldn't otherwise accept a string literal +(e.g. `Year="_movie.Year"` on an `int?` parameter works unprefixed, because a bare identifier can't type-check as one); a `string` parameter can always accept a literal, so Razor takes it at face value instead. +This compiles and renders with no error - the bug only shows up in the *data*, not the markup - +which is exactly what happened when `InlineReferenceLinker`'s `Title="_movie.Title"` sent the literal string `_movie.Title` to TMDB's search instead of the movie's actual title, returning an unrelated result. +Always write `Title="@_movie.Title"` for string parameters bound to a field/property. ### Theme -`app.css` is a light+dark theme driven by `data-bs-theme` on `` (Bootstrap 5.3's native color-mode support), with Keeptrack's own `--kt-*` tokens layered on top for custom components (sidebar, `kt-table-wrap`, `kt-modal`, etc.). `wwwroot/theme.js` sets the initial theme from `localStorage`/`prefers-color-scheme` before first paint (avoiding a flash of the wrong theme) and exposes `ktToggleTheme()`, called directly from a plain button in `NavMenu.razor` — no Blazor/JS interop needed for the toggle itself. Use system-ui fonts only; no decorative/display webfonts. - -Icons throughout the app are plain Unicode symbols with no default emoji presentation (`◈`, `✓`, `✕`, `★`, `▶`, `↻`, `⌂`, `⚙`, `♪`, and the Geometric Shapes block generally: `◼ ▭ ▬ ◆`), never a codepoint whose default rendering is a full-color emoji glyph (`⭐`, `👁`, `🔄`, `⏳`, `🏠`, `📚`, `🎬`, ...) - a color emoji reads as an inconsistent, slightly unpolished note among otherwise monochrome UI that follows `--kt-text`/`--kt-accent` like everything else. **Gotcha:** a codepoint isn't safe just because it "looks like" a plain symbol - `⭐` (U+2B50) and `👁` (U+1F441) were originally used as the "Best of"/"Want to watch" icons on the assumption they were plain stars/eyes, but both have `Emoji_Presentation=Yes` by default (Unicode's `emoji-data.txt`) and render as full-color glyphs on every mainstream platform; they were replaced with `★` (U+2605, Black Star, default text presentation) and `▶` (U+25B6, default text presentation) respectively. Before adding a new symbol, check whether its default presentation is text or emoji - don't assume from how it looks in this file. Appending a trailing variation selector (`️`, U+FE0F) forces emoji presentation even on an otherwise-safe codepoint, so never add one; some codepoints (`🌙`, `🚪`, `🔑`, `👤`, `📦`) have no text-presentation form at all and were simply dropped rather than replaced with an approximate glyph, since a semantically-forced match is worse than no icon when the row's label text already carries the meaning. `.kt-icon-spin` (reuses the same `spin` keyframes as `.kt-spinner`) makes a plain glyph rotate in place for a small inline action's "in progress" state, instead of swapping to an hourglass emoji. - -Enhanced navigation re-fetches and diffs the whole document on every in-app link click; anything set on ``/`` by client-side JS rather than server-rendered markup (like `data-bs-theme`) gets stripped back out unless it's explicitly re-applied. `wwwroot/Keeptrack.BlazorApp.lib.module.js` is a JS initializer (auto-loaded by Blazor because its name matches the assembly - don't add a manual `