SaraRasoulian/DotNet-WebAPI-Blazor-Sample
53.8
Adequate · 8 November 2026
698
lines of production code
C#
primary language
7
measurements over time
What this system is
This is a student management system built on a .NET 8 architecture, featuring a Blazor client and a WebAPI server. The server implements a clean architecture with distinct layers for domain logic, application services, and data persistence, exposing RESTful endpoints for full student CRUD operations. The system includes comprehensive automated testing and is fully containerized for deployment.
Features
Add Docker and Nginx configuration for the client application
The client application now includes a Dockerfile that builds the .NET 8.0 application and serves the static output via Nginx on port 8080. A corresponding nginx.conf configures the server to serve the built web files, and a .dockerignore file excludes build artifacts and user-specific files from the Docker context. These changes enable containerized deployment of the client.
client · medium confidence
Add student data persistence and repository layer
The server's infrastructure layer now includes the complete data access setup for the Student entity. This adds the Student entity's EF Core configuration, a StudentManagementDBContext, a StudentRepository implementing IStudentRepository, and the initial database migration (v1) that creates the Students table with unique constraints on email and GitHub username. The dependency injection registration for the DbContext and repository is also included.
server/src/Infrastructure · high confidence
Add student management interface with full CRUD operations
The client application now includes a complete set of Razor pages for managing students, including a home page, a student list, and individual pages for viewing, adding, editing, and deleting students. The implementation features client-side validation using DataAnnotations on the StudentDto, a dedicated StudentService for HTTP requests, and a MainLayout component that provides a responsive sidebar navigation and header. The layout includes a toggleable sidebar for desktop and a mobile-friendly navbar, styled with Bootstrap 5.1.0.
client/src · high confidence
Added student management capabilities with domain models and handlers
Users can now create, read, update, and delete student records through new command and query handlers in the Application layer. This includes CreateStudentHandler, DeleteStudentHandler, UpdateStudentHandler, GetAllStudentsHandler, and GetStudentByIdHandler. The domain layer introduces the Student entity with properties for first name, last name, email, birth date, and GitHub username, along with base entity classes for auditing and identity. The IStudentRepository interface defines the data access contract, and the Email value object enforces validation rules for email addresses.
server/src/Application/Students/Handlers/CommandHandlers, server/src/Application/Students/Handlers/QueryHandlers, server/src/Domain · high confidence
Initial WebAPI project structure and configuration
The WebAPI project is introduced with a new directory structure, including the main entry point (Program.cs) which configures dependency injection, Swagger, and CORS policies for both local and Docker-based client applications. A new StudentsController is added to expose REST endpoints for student management, and a GlobalExceptionHandler middleware is implemented to standardize error responses. Configuration files (appsettings) and launch settings are also added to support development and Docker environments.
server/src/WebAPI · high confidence
Introduces student management capabilities via the Application layer
The Application layer now supports full student lifecycle operations, including creating, updating, and deleting students, as well as retrieving them by ID or listing all. This is enabled by new MediatR commands and queries, corresponding validators that enforce business rules (such as unique email and GitHub username constraints), and request/response models. A global validation pipeline behavior is registered to automatically validate incoming commands.
server/src/Application · high confidence
Behavioural changes
Server project restructured with Docker support
The server codebase has been reorganized into a dedicated 'server' directory, accompanied by the addition of a Dockerfile and a .dockerignore file to support containerized builds. The solution file (StudentManagement.Server.sln) has been updated to reflect the new folder structure, grouping the WebAPI, Domain, Application, and Infrastructure projects under a 'src' folder, while test projects are organized under 'tests'.
server · medium confidence
Test coverage
Added comprehensive test suite for student management
Added unit, integration, and acceptance tests for the Student Management feature. The changes include unit tests for all student handlers (Create, Read, Update, Delete, and GetAll) using mocked repositories, integration tests for the StudentsController endpoints, and acceptance tests using SpecFlow to verify the full API lifecycle (CRUD operations) against a test database.
server/tests · high confidence
Dependencies
Upgrade to .NET 8 and modernize server-side dependencies
The server-side .NET projects have been upgraded to .NET 8, including the WebAPI, Application, Domain, and Infrastructure projects. This update introduces several new or updated dependencies: Blazor.Bootstrap 2.2.0 and ASP.NET Core WebAssembly 8.0.2 on the client side; FluentValidation 11.9.1, Mapster 7.4.0, and MediatR 12.2.0 in the application layer; and EF Core 8.0.4 with Npgsql 8.0.2 for database interactions. The WebAPI project now includes Swashbuckle for OpenAPI documentation. Additionally, the test suite has been updated with xUnit 2.4.2, NSubstitute 5.1.0, Bogus 35.5.1, and SpecFlow 3.9.74 to support the new framework version.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 55 → 54 (-1.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 72 → 72 (+0.0)
- Architecture 92 → 92 (+0.0)
- Maturity 79 → 79 (+0.0)
- Readiness 45 → 45 (+0.0)
- Security 84 → 84 (+0.0)
- Domain Modelling 71 → 71 (+0.0)
- Accessibility 50 → 45 (-5.4)
- Performance 100 → 100 (+0.0)
Resolved (10)
- Documentation: no project overview (README.md)
- XML-doc coverage: Application (server/src/Application/Application.csproj)
- XML-doc coverage: Domain (server/src/Domain/Domain.csproj)
- XML-doc coverage: Infrastructure (server/src/Infrastructure/Infrastructure.csproj)
- XML-doc coverage: WebAPI (server/src/WebAPI/WebAPI.csproj)
- XML-doc coverage: WebUI (client/src/WebUI/WebUI.csproj)
- redundant comment (client/src/WebUI/Services/ApiUrls.cs)
- redundant comment (server/src/Infrastructure/DependencyInjection.cs)
- redundant comment (server/src/WebAPI/Program.cs)
- redundant comment (server/tests/WebAPI.Tests.Integration/ControllersTests/StudentsControllerTests.cs)
API surface
- Unchanged — 5 HTTP endpoints
Architecture
- Unchanged — 2 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
SaraRasoulian/DotNet-WebAPI-Blazor-Sample 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.
About this page
- The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit bd88afb855ec77cd296ffcc79623b9e24779cdc1 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.