MossPiglets/WizardWorldAPI

WizardWorldApi is a .NET 9 RESTful API service that manages a fantasy-themed database of magical entities, including spells, wizards, houses, elixirs, ingredients, and creatures. It exposes read-only endpoints to retrieve and filter this data, alongside a feedback submission feature that sends emails via Mailgun. The system is built on a clean architecture using MediatR and Entity Framework Core with a PostgreSQL backend.

Users can now retrieve a list of spells by providing a name prefix, an incantation prefix, and/or a specific spell type. The new GetSpellsQuery and its handler support filtering by these three fields, allowing for more precise spell searches within the application.

WizardWorldApi/WizardWorld.Application/Requests/Spells/Queries/GetSpells · high confidence

A new MagicalCreatureDto was introduced to represent magical creature data, containing fields for Id, Name, Description, Classification, Status, DangerousnessLevel, CreatureRelations, and NativeTo. A corresponding AutoMapper mapping profile was added to map from the MagicalCreature persistence model to this new DTO, enabling the application layer to expose these specific creature attributes.

WizardWorldApi/WizardWorld.Application/Requests/MagicalCreatures · high confidence

A new Wizard entity has been introduced to the persistence layer, defining the structure for wizard records with properties for Id, FirstName, LastName, and a collection of Elixirs.

WizardWorldApi/WizardWorld.Persistance/Models/Wizards · high confidence

Users can now fetch a specific spell by its ID. This change introduces a new query and handler that retrieve a spell entity from the database using AsNoTracking to avoid tracking overhead, and map the result to a DTO. If the spell is not found, a NotFoundException is thrown.

WizardWorldApi/WizardWorld.Application/Requests/Spells/Queries/GetSpellById · medium confidence

The application now supports fetching elixir data via new query handlers. Users can retrieve a single elixir by its unique identifier, or perform a filtered search across multiple elixirs using criteria such as name, difficulty, manufacturer, inventor, and ingredient. The implementation uses the MediatR pattern with AutoMapper for mapping database entities to DTOs.

WizardWorldApi/WizardWorld.Application/Requests/Elixirs/Queries · high confidence

The persistence layer now includes explicit Entity Framework Core configuration classes for Counter, Elixir, House, Ingredient, Spell, and Wizard entities. These new configuration files define primary keys and, for Elixir and House, specify many-to-many relationships and foreign key mappings, establishing how these domain models map to the database schema.

WizardWorldApi/WizardWorld.Persistance/Configurations · medium confidence

Introduced new application-layer components for fetching ingredients: a data transfer object (IngredientDto), an AutoMapper mapping profile, and MediatR-based queries and handlers for retrieving a single ingredient by ID and listing ingredients with optional name filtering.

WizardWorldApi/WizardWorld.Application/Requests/Ingredients · high confidence

The persistence layer now includes new data models for magical creatures, including the main \MagicalCreature\ class with properties for name, description, classification, status, and dangerousness level. Supporting enums define \CreatureClassificationByMinistryOfMagic\ (Beast, Being, Spirit), \CreatureStatus\ (Extant, Endangered, Extinct), and \CreatureDangerousnessLevel\ (X through XXXXX). A \CreatureRelation\ class enables tracking relationships between creatures.

WizardWorldApi/WizardWorld.Persistance/Models/MagicalCreatures · high confidence

Users can now fetch a specific house by its ID or retrieve a list of all houses. The new GetHouseByIdQuery and GetHousesQuery handlers query the database using AsNoTracking for performance, eagerly loading related Traits and Heads, and map the results to HouseDto objects.

WizardWorldApi/WizardWorld.Application/Requests/Houses/Queries · high confidence

Users can now fetch a specific wizard by their unique identifier or search for wizards by first and last name. This change introduces new MediatR query handlers that query the database using AsNoTracking for read-only operations, mapping the results to WizardDto objects.

WizardWorldApi/WizardWorld.Application/Requests/Wizards/Queries · high confidence

Users can now retrieve magical creatures via new query handlers. The system introduces two new queries: one to fetch a single magical creature by its unique identifier, and another to retrieve a list of all magical creatures. Both queries map database entities to DTOs using AutoMapper, with the single-item query throwing a not-found exception if the creature does not exist.

WizardWorldApi/WizardWorld.Application/Requests/MagicalCreatures/Queries · high confidence

The application now supports persisting spell data with a new Spell model containing fields for name, incantation, effect, creator, and nullable verbal casting. Two new enums, SpellType and SpellLight, define the available spell categories (such as Charm, Curse, and DarkArts) and light effects (such as Blue, Red, and Fire).

WizardWorldApi/WizardWorld.Persistance/Models/Spells · high confidence

The WizardWorldApi is introduced, providing a new set of RESTful controllers for Elixirs, Feedback, Houses, Ingredients, Magical Creatures, Spells, and Wizards. Each controller exposes GET endpoints for listing and retrieving individual items, as well as a POST endpoint for submitting feedback, all wired to handle requests via the MediatR library. The API also includes a custom CounterMiddleware to track request counts and a database migration and seeding process that initializes the application's state on startup.

WizardWorldApi/WizardWorldApi · high confidence

The WizardWorldApi directory now contains the foundational configuration files for the API service, including a Dockerfile targeting .NET 9.0, a .dockerignore file, a solution file defining the project structure, a Docker Compose configuration for a PostgreSQL 16 database, and an empty dotnet marker file.

WizardWorldApi · high confidence

A new Elixir entity has been added to the persistence layer, containing properties for name, effect, side effects, characteristics, time, manufacturer, and navigation collections for ingredients and inventors. The model also includes an ElixirDifficulty enum to represent the complexity level of each elixir.

WizardWorldApi/WizardWorld.Persistance/Models/Elixirs · high confidence

The application now includes a new persistence layer that defines the database schema and data access configuration. This includes an \ApplicationDbContext\ that maps entities such as Spells, Houses, Elixirs, Wizards, Ingredients, Counters, and Magical Creatures to the database. The \ServiceCollectionExtensions\ registers the database context using Npgsql, enabling the application to interact with a PostgreSQL database. Additionally, model classes for each entity are introduced, establishing the structure for data storage and retrieval.

WizardWorldApi/WizardWorld.Persistance · high confidence

Added new persistence models to the Houses module: a House entity with properties for name, colours, founder, animal, element, ghost, and common room, along with collections for Heads and Traits. A HouseHead model was added to track headmasters, and a Trait model was introduced to store associated traits. Additionally, a new TraitName enumeration was created, defining specific traits such as Courage, Bravery, Loyalty, and Wisdom, enabling the system to associate specific character traits with each house.

WizardWorldApi/WizardWorld.Persistance/Models/Houses · high confidence

Users can now submit feedback through a new SendFeedback command that maps user input to an email provider. The system uses AutoMapper to convert the command into a FeedbackEmail object and delegates the actual sending to an IEmailProvider service, which currently supports Mailgun. The feedback type is categorized as General, Bug, DataError, or Suggestion.

WizardWorldApi/WizardWorld.Application/Requests/Feedback · medium confidence

New DTOs (ElixirDto, ElixirInventorDto) and an AutoMapper profile (ElixirMappingProfile) have been introduced to handle the serialization and mapping of Elixir and Wizard entities. This enables the application to expose structured data about elixirs and their inventors through the API.

WizardWorldApi/WizardWorld.Application/Requests/Elixirs · medium confidence

Introduced new DTOs (HouseDto, HouseHeadDto, TraitDto) and an AutoMapper profile to map house entities to their corresponding data transfer objects, enabling structured data exchange for house-related operations.

WizardWorldApi/WizardWorld.Application/Requests/Houses · high confidence

Introduced a new SpellDto class containing spell properties (Id, Name, Incantation, Effect, CanBeVerbal, Type, Light, Creator) and an associated AutoMapper mapping profile to facilitate data transfer between the application layer and the persistence models.

WizardWorldApi/WizardWorld.Application/Requests/Spells · high confidence

Introduced new DTOs (WizardDto, WizardElixirDto) and an AutoMapper profile to map between domain models and API request/response structures. This enables the application to serialize and deserialize wizard and elixir data for API interactions.

WizardWorldApi/WizardWorld.Application/Requests/Wizards · medium confidence

The persistence layer has been updated with new database migrations that expand the data model. Spells now include an 'Incantation' field and the 'CanBeVerbal' property has been changed to allow null values. A new 'Counters' table has been added to track numerical values. Additionally, the schema now supports 'MagicalCreatures' with a self-referential 'CreatureRelation' table to link creatures together. These changes update the application's state to support the new game mechanics.

WizardWorldApi/WizardWorld.Persistance/Migrations · medium confidence

The application now uses Mailgun for sending emails, replacing the previous email provider. This change is implemented by registering the \MailgunEmailProvider\ in the dependency injection container via \ServicesCollectionExtensions\. Additionally, MediatR is configured to automatically register handlers from the application assembly, and a new \EmailServiceFailureException\ is introduced to handle failures specific to the email service.

WizardWorldApi/WizardWorld.Application · medium confidence

The application's email feedback service has been migrated from a previous provider to Mailgun. This change introduces a new Mailgun-based implementation for sending feedback emails, replacing the prior logic. Users will now have their feedback emails processed and delivered via the Mailgun service.

WizardWorldApi/WizardWorld.Application/Services · high confidence

The persistence layer now includes Entity Framework Core configuration classes for the MagicalCreature and CreatureRelation entities. This adds the necessary mappings to define the primary keys and the one-to-many relationship between creatures, ensuring the database schema is correctly generated for these models.

WizardWorldApi/WizardWorld.Persistance/Configurations/MagicalCreatures · medium confidence

Added HTTP client and content extension helpers for integration tests; Added integration test infrastructure and test data seeding; Added integration tests for API controllers; Added shared test data generators for the wizarding world domain; Added unit tests for domain object mapping.

The project has been upgraded to target .NET 9.0 across all components, including the main API, application, persistence, and test projects. This update includes specific package versions such as Microsoft.EntityFrameworkCore 9.0.11, MediatR.AspNet 2.0.0, and Swashbuckle.AspNetCore 9.0.6, ensuring compatibility with the new runtime and modernizing the dependency stack.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 48 → 45 (-3.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 71 → 71 (-0.1)
• Architecture 95 → 95 (+0.0)
• Maturity 57 → 57 (+0.0)
• Readiness 57 → 42 (-14.7)
• Security 33 → 34 (+1.7)

• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium IaC: CKV2_GHA_1 (.github/workflows/deploy.yml)
• Medium IaC: CKV2_GHA_1 (.github/workflows/main.yml)
• Medium IaC: CKV_DOCKER_3 (WizardWorldApi/Dockerfile)
• Medium IaC: CKV_SECRET_6 (WizardWorldApi/compose.yaml)
• No exposed public API
• no production source files with tracked history to analyse
• no production source files with tracked history to analyse
• redundant comment (WizardWorldApi/WizardWorldApi/Program.cs)
• redundant comment (WizardWorldApi/WizardWorldApi/Program.cs)
• redundant comment (WizardWorldApi/WizardWorldApi/Program.cs)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (WizardWorldApi/WizardWorld.Application/Requests/Houses/HouseDto.cs)
• Duplicated block (9 lines × 2) (WizardWorldApi/WizardWorld.Application/Requests/Elixirs/ElixirDto.cs)
• Duplicated block (9 lines × 2) (WizardWorldApi/WizardWorld.Application/Requests/Spells/SpellDto.cs)
• End-of-life runtime: .NET net9.0
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium IaC: WD-COMPOSE-0002 (WizardWorldApi/compose.yaml)
• Medium IaC: WD-DOCKER-0003 (WizardWorldApi/Dockerfile)
• Medium IaC: WD-DOCKER-0003 (WizardWorldApi/Dockerfile)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No dependency advisory monitoring
• redundant comment (WizardWorldApi/WizardWorldApi/Program.cs)

• Unchanged — 13 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

MossPiglets/WizardWorldAPI was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.