hamed-shirbandi/TaskoMask

TaskoMask is a task management platform built on a microservices architecture, separating concerns into distinct write and read services for owners, boards, and tasks. It employs a CQRS pattern with MongoDB for read-optimized data storage and event-driven synchronization via RabbitMQ to maintain consistency across services. The system provides a Blazor WebAssembly client for user interaction, accessed through an API Gateway that aggregates data from the backend services.

71 changes.

The project was initialized with a comprehensive .NET 8 solution structure, establishing building blocks for domain events, contracts, and infrastructure. Core microservices for identity, boards, and tasks were developed alongside a Blazor WebAssembly client and API gateway, implementing full CRUD capabilities for the Kanban-style task management domain.

60 changes.

This period focused on implementing core microservices for Identity, Owners, Boards, and Tasks, establishing their write-side domain models and read-side MongoDB projections. The work included building out CQRS architectures, integrating gRPC communication, and setting up event-driven synchronization between services. Comprehensive test coverage was added across all services, alongside infrastructure improvements like Docker Compose environments and Nuke-based build automation.

6 changes.

This period focused on establishing the core application architecture by introducing essential building blocks, including domain services, caching, validation, and event handling behaviors. It standardized cross-cutting concerns through centralized infrastructure registration and integrated observability tools like OpenTelemetry and Serilog for structured logging and distributed tracing.

The Owners Write API now exposes HTTP endpoints to manage organizations. Owners can create a new organization (POST /organizations), update an existing one (PUT /organizations/{id}), or delete it (DELETE /organizations/{id}). Each operation includes input validation, such as enforcing name length limits and ensuring the description does not match the name, and publishes integration events to notify other services of the changes.

src/2-Services/Owners/Api/Owners.Write.Api/UseCases/Organizations · high confidence

The acceptance test suite has been restructured to allow tests to run against the API gateway directly, rather than only through the browser UI. A new core layer provides a factory that dynamically resolves test tasks and questions to either UI or API implementations based on a configuration tag (API-Level or UI-Level). This enables running the same business scenarios against the backend services for faster feedback, while the existing UI-based Selenium tests remain available for end-to-end verification.

src/5-Tests/Acceptance · high confidence

The User Panel now includes dedicated pages for viewing individual Boards and Projects. The new Board page (at /board/{BoardId}) displays board details, cards, and supports opening task details in a modal, while the Project page (at /project/{ProjectId}) shows project information and lists its associated boards. Both pages fetch data via their respective API services and handle loading states and error notifications.

src/4-Clients/UserPanel/Pages/Boards, src/4-Clients/UserPanel/Pages/Projects · high confidence

A new BoardCardType enum has been introduced in the Contracts building blocks to define the lifecycle stages of a board card. This enum includes Backlog, ToDo, Doing, and Done values, each associated with localized display names via the ContractsMetadata resource, enabling consistent representation of card status across the application.

src/1-BuildingBlocks/Contracts/Enums · high confidence

This change introduces the Docker Compose setup for the \src/7-Docker\ location, enabling developers to run the full application stack locally. It includes \Infrastructure.yml\ to spin up dependencies (MongoDB, Redis, SQL Server, RabbitMQ, Seq) and \docker-compose.yml\ to define and build the microservices (Owners, Boards, Tasks APIs, Identity, Aggregator, API Gateway, and clients) with their specific network and port mappings. The \docker-compose.override.yml\ configures development-specific settings like environment variables and volume mounts for secrets/HTTPS, while \docker-compose.dcproj\ and \launchSettings.json\ provide Visual Studio integration for debugging these services.

src/7-Docker · high confidence

A new GetActivityDto class has been introduced in the Activities contracts to define the data structure returned when retrieving an activity. This Data Transfer Object includes fields for the activity's unique identifier, associated task ID, description, and creation time details, providing a standardized contract for activity data exposure.

src/1-BuildingBlocks/Contracts/Dtos/Activities · high confidence

The Identity service now includes a basic UI for the Identity Server, featuring a welcome page and layout structure. To enhance security, a custom filter is applied to enforce strict HTTP security headers, including Content-Security-Policy, X-Frame-Options, and Referrer-Policy. Additionally, the UI integration includes support for CAPTCHA validation via the DNTCaptcha library.

src/2-Services/Identity/Api/Identity.Api/Pages · high confidence

The Identity service now includes a dedicated UI for authentication flows. A new shared layout (\_Layout.cshtml) provides the page structure, styling via Bootstrap, and script includes for the login and logout pages. Additionally, a shared validation summary component (\_ValidationSummary.cshtml) has been added to display model state errors to users.

src/2-Services/Identity/Api/Identity.Api/Pages/Shared · high confidence

The login interface now includes a CAPTCHA challenge (sum of two numbers) to prevent automated access, and displays validation errors directly on the page. Users can also register via a link if a client URI is configured.

src/2-Services/Identity/Api/Identity.Api/Pages/Account/Login · high confidence

New shared contract types have been introduced in the BuildingBlocks layer to standardize data structures across the application. The \CreationTimeDto\ class provides a standardized way to expose creation and modification timestamps along with their string representations and date components, while the \SelectListItem\ class offers a simple model for dropdown selection options. These additions support consistent data transfer and UI binding patterns.

src/1-BuildingBlocks/Contracts/Dtos/Common, src/1-BuildingBlocks/Contracts/Models · high confidence

Users can now fetch a board's full details, including its cards and associated tasks, via a new GET endpoint at /boards/{id}. This feature aggregates data from multiple gRPC services (board, cards, and tasks) and returns a comprehensive BoardDetailsViewModel, enabling the user panel to display complete board information in a single request.

src/3-ApiGateways/UserPanel/Aggregator/Features/GetBoardById · high confidence

Users can now fetch comprehensive task details via a new GET /tasks/{id} endpoint. This feature aggregates data from multiple backend services, combining the core task information, associated comments, and activity history into a single response.

src/3-ApiGateways/UserPanel/Aggregator/Features/GetTaskById · high confidence

The User Panel Aggregator now exposes a new GET /organizations endpoint that returns detailed information for all organizations owned by the authenticated user. This feature aggregates data from multiple gRPC services, fetching the organization list, associated projects, and boards, and presents them in a single response. Currently, organization reports are initialized as empty placeholders pending a future implementation.

src/3-ApiGateways/UserPanel/Aggregator/Features/GetOrganizationsByOwnerId · high confidence

New integration event contracts have been introduced to support cross-service communication for core domain activities. The changes define specific event records for board operations (BoardAdded, BoardDeleted, BoardUpdated, CardAdded, CardDeleted, CardUpdated), task management (TaskAdded, TaskDeleted, TaskUpdated, TaskMovedToAnotherCard, CommentAdded, CommentDeleted, CommentUpdated), user identity (UserRegistered, UserUpdated), and owner/organization/project lifecycle (OwnerRegistered, OwnerRegisterationCompleted, OwnerProfileUpdated, OwnerUpdatingProfileCompleted, OrganizationAdded, OrganizationDeleted, OrganizationUpdated, ProjectAdded, ProjectDeleted, ProjectUpdated). All events implement the new IIntegrationEvent marker interface, establishing a standardized contract for these domain interactions.

src/1-BuildingBlocks/Contracts/Events · high confidence

The Website client now includes dedicated controllers to handle navigation to the home page and display error states. The HomeController exposes an Index action to render the main landing view, while the ErrorController provides actions to render both known and unknown error views, ensuring users receive appropriate feedback when issues occur.

src/4-Clients/Website/Controllers · high confidence

The Boards Read API now exposes a new capability to fetch all cards associated with a specific board. This is implemented via a REST endpoint at \boards/{boardId}/cards\ (requiring user-read-access) and a corresponding gRPC service. Both endpoints delegate to a MediatR handler that queries the MongoDB read-model database and returns the results as \GetCardDto\ objects.

src/2-Services/Boards/Api/Boards.Read.Api/Features/Cards/GetCardsByBoardId · high confidence

The Identity API now includes Razor Pages for handling user logout flows via Duende IdentityServer. This adds an Index page that initiates the sign-out process (deleting local cookies and handling federated sign-outs) and a LoggedOut page that redirects users to their post-logout URI or the home page.

src/2-Services/Identity/Api/Identity.Api/Pages/Account/Logout · high confidence

The application now supports configuring MassTransit with a RabbitMQ transport via a new extension method. This change introduces a \RabbitMqOptions\ class to map connection settings (host, exchange name, username, password) from configuration and registers the necessary MassTransit services, including consumer discovery and receive endpoint setup, within the infrastructure building block.

src/1-BuildingBlocks/Infrastructure/MassTransit · high confidence

The Web.MVC building block now includes built-in support for structured logging and distributed tracing via Serilog and OpenTelemetry. Developers can enable these capabilities by configuring the 'Serilog' and 'OpenTelemetry' sections in their app settings, which allows for automatic collection of logs, metrics, and traces (including ASP.NET Core and HTTP client instrumentation) exported via OTLP endpoints.

src/1-BuildingBlocks/Web.MVC/Configuration/Observation · high confidence

The building blocks infrastructure now includes a default AutoMapper configuration. A new CommonMappingProfile maps the CreationTime value object to its DTO equivalent, formatting date properties as long date strings. Additionally, a MapperExtensions helper was added to simplify dependency injection registration by automatically scanning the specified assembly for mapping profiles and including the common profile.

src/1-BuildingBlocks/Infrastructure/Mapping · high confidence

A new static extension method \Validate\ has been added to the \DataAnnotationExtension\ class, allowing objects to be validated against their data annotation attributes and returning a collection of validation results.

src/1-BuildingBlocks/Contracts/Extensions · high confidence

New Protocol Buffers definitions have been added to the contracts layer to support gRPC communication for core task management entities. This includes a base schema with common creation time fields and specific service definitions for retrieving Projects, Boards, Cards, Tasks, Organizations, Activities, and Comments by their respective identifiers (e.g., \GetProjectByIdGrpcService\, \GetCardsByBoardIdGrpcService\). These contracts establish the request and response structures for these read operations, enabling clients to fetch hierarchical data such as boards within a project or tasks within a card.

src/1-BuildingBlocks/Contracts/Protos · high confidence

The Web.MVC building block now includes global exception handlers for both HTTP and gRPC endpoints. The new HttpGlobalExceptionHandler intercepts unhandled exceptions in HTTP requests, logs the error, and returns a standardized JSON failure response with a 500 status code. Similarly, the new GrpcGlobalExceptionHandler catches exceptions in gRPC unary calls, logs the request details, and returns a Cancelled RPC status with the exception message. A new MessageConsumerFaultException class is also provided for specific consumer-related error scenarios.

src/1-BuildingBlocks/Web.MVC/Exceptions · high confidence

The application now includes strongly-typed resource classes for domain-level feedback and metadata. Users will see specific validation error messages for scenarios such as duplicate emails, invalid credentials, and entity count limits (e.g., maximum boards per project). Additionally, standardized display names for core entities like Board, Card, Task, and User are now available for localization.

src/1-BuildingBlocks/Domain/Resources · high confidence

The Boards.Read.Api service now includes consumers that keep the read-side MongoDB database synchronized with domain events. BoardAdded, BoardUpdated, and BoardDeleted events trigger insert, update, or delete operations on the Boards collection, with board creation also fetching project details via a gRPC client. Organization and Project update events propagate name changes to all affected boards. Similarly, CardAdded, CardUpdated, and CardDeleted events manage the Cards collection, and board updates also refresh the board name on associated cards.

src/2-Services/Boards/Api/Boards.Read.Api/Consumers · high confidence

The Owners Write API now includes consumers to handle identity service events: FaultOwnerRegisteredConsumer deletes an owner record if identity registration fails, while UserRegisteredConsumer and UserUpdatedConsumer publish OwnerRegisterationCompleted and OwnerUpdatingProfileCompleted events respectively to notify the read service of successful registration or profile updates.

src/2-Services/Owners/Api/Owners.Write.Api/Consumers · high confidence

A new Blazor component for updating owner profile details (display name and email) has been added to the Owner section of the User Panel. This modal form fetches the current owner data upon initialization and submits changes via the OwnerApiService, providing user feedback through toast notifications and closing the modal upon completion.

src/4-Clients/UserPanel/Pages/Owner/Components · high confidence

The Owners.Write.Api service now includes auto-generated strongly-typed resource classes (ApplicationMessages and ApplicationMetadata) alongside their corresponding .resx files. This enables the API to look up localized strings and metadata in a type-safe manner, supporting internationalization and consistent message handling within the owners service.

src/2-Services/Owners/Api/Owners.Write.Api/Resources · high confidence

The Web building block now includes a reusable HTTP client service (IHttpClientService) that wraps standard HTTP operations (Get, Post, Put, Delete) and integrates an automatic retry mechanism (HttpClientRetryHelper) to handle transient failures. A startup extension method (AddHttpClientService) is provided to register this service in the dependency injection container, allowing applications to consume HTTP endpoints with built-in resilience without implementing retry logic manually.

src/1-BuildingBlocks/Web · high confidence

The Web.MVC building block now includes a new \GrpcConfiguration\ class that provides an \AddGrpcPreConfigured\ extension method. This method registers gRPC services and automatically adds a global exception interceptor (\GrpcGlobalExceptionHandler\), ensuring that gRPC errors are consistently handled across the application without requiring manual configuration in each project.

src/1-BuildingBlocks/Web.MVC/Configuration/Grpc · high confidence

The Identity service now automatically handles user identity lifecycle events for new owners. When an owner registers, the new OwnerRegisteredConsumer triggers the creation of a corresponding user account (login/logout capability). Similarly, if an owner's profile email is updated, the OwnerProfileUpdatedConsumer ensures the user account's email is synchronized. This removes the need for manual user provisioning steps after owner registration.

src/2-Services/Identity/Api/Identity.Api/Consumers · high confidence

The User Panel now includes dedicated Razor components for managing cards within a board. The AddCard component allows users to create new cards by specifying a name and type, while the UpdateCard component enables editing existing card details and includes functionality to delete a card after confirmation. Both components integrate with the CardApiService to handle data submission and display appropriate feedback via toast notifications.

src/4-Clients/UserPanel/Pages/Cards · high confidence

The Web.MVC building block now provides three new static configuration classes—MvcConfiguration, RazorPagesConfiguration, and WebApiConfiguration—to standardize how ASP.NET Core applications are bootstrapped. MvcConfiguration offers pre-configured pipelines for MVC apps, including Kestrel synchronous I/O settings and a CurrentUserService registration. RazorPagesConfiguration provides a similar streamlined setup for Razor Pages, including authentication and developer exception pages. WebApiConfiguration introduces a dedicated pipeline for API applications that includes JWT authentication, CORS, Swagger integration, and a global HTTP exception handler middleware to manage errors consistently.

src/1-BuildingBlocks/Web.MVC/Configuration/MVC · high confidence

The Web.MVC building block now includes a centralized Swagger configuration that automatically includes XML documentation comments from all XML files in the application's base directory, configures Bearer token (JWT) security schemes, and hides specific API paths (such as DNTCaptchaImage) from the generated documentation. This change simplifies Swagger setup for consuming applications by providing pre-configured middleware extensions.

src/1-BuildingBlocks/Web.MVC/Configuration/Swagger · high confidence

The User Panel now includes an IdentityServerAuthorizationHandler that automatically attaches access tokens to requests sent to the API gateway. This handler is configured to target the URL specified in the 'Url:ApiGateway' setting and requests the scopes defined in the 'oidc:DefaultScopes' configuration section, ensuring authenticated communication with backend services.

src/4-Clients/UserPanel/Configuration · high confidence

The Boards Read API now includes its core infrastructure layer, introducing a MongoDB-based data access strategy. This change adds a dedicated \BoardReadDbContext\ to manage \Board\ and \Card\ collections, along with an initialization routine that creates necessary database indexes for efficient querying. Dependency injection is configured via \ModuleExtensions\ to wire up the MongoDB context, AutoMapper profiles for DTO-to-protobuf mapping, and shared building block services. This provides the foundational persistence and serialization capabilities required for the read-side of the Boards service.

src/2-Services/Boards/Api/Boards.Read.Api/Infrastructure · high confidence

The Boards Read API now explicitly registers its internal gRPC endpoints (GetBoardById, GetCardsByBoardId, GetBoardsByProjectId, GetBoardsByOrganizationId, GetCardById) and configures a gRPC client for the Owner Read Service's GetProjectById endpoint. This centralizes the wiring of gRPC communication within the service's configuration layer.

src/2-Services/Boards/Api/Boards.Read.Api/Configuration · high confidence

The Identity API's infrastructure layer now includes the core setup for ASP.NET Core Identity, including the \IdentityDbContext\ mapped to SQL Server tables (Users, Roles, Claims, etc.), a DI module to register these services, and an EF Core migration for the initial schema. Additionally, a database initialization routine is provided that automatically creates the database and seeds a super-user account based on configuration values.

src/2-Services/Identity/Api/Identity.Api/Infrastructure · high confidence

Added the UserLogin use case components (request, handler, and validator) to the Identity API. The login flow now validates required username and password fields, authenticates credentials via ASP.NET Core Identity, checks for active user status, and registers a local login provider association upon success.

src/2-Services/Identity/Api/Identity.Api/UseCases/UserLogin · high confidence

The Identity API now includes explicit configuration for Duende IdentityServer, defining the available identity resources (OpenID, Profile), API scopes (read/write access for Owners, Boards, and Tasks services), and API resources (including a new Aggregator API). A single client, 'UserPanel', is configured to authenticate via the Authorization Code flow with PKCE, allowing it to access the defined scopes. These configurations are registered in the service collection via the new IdentityServerExtensions, enabling the identity service to issue tokens for the specified microservices.

src/2-Services/Identity/Api/Identity.Api/Configuration · high confidence

The Website client application is introduced, providing the entry point for the web interface. It includes a Dockerfile based on .NET 8 to enable containerized deployment, along with standard ASP.NET Core setup files (Program.cs, Startup.cs) that configure MVC and Serilog request logging. The application is configured via appsettings files for Development, Staging, and Production environments, defining service URLs and OpenTelemetry endpoints for metrics and tracing.

src/4-Clients/Website · high confidence

The repository is initialized with a comprehensive .NET solution structure, including a new \TaskoMask.sln\ that defines the project hierarchy (BuildingBlocks, Services, Clients, Tests). A Nuke-based build system is introduced via \build.ps1\, \build.sh\, and \build.cmd\ scripts to automate compilation. Code quality and formatting are standardized through a new \.editorconfig\ with strict C\# style rules, a \.csharpierrc.yaml\ for CSharpier, and a \Directory.Build.props\ file to enforce code style during builds. Additionally, \.dockerignore\ and an updated \.gitignore\ are added to manage build artifacts and container contexts.

(repo-wide) · high confidence

This change introduces the new Boards Write API, a .NET 8 service responsible for managing board and card lifecycle operations. The service implements the core domain model for Boards and Cards, including value objects for names and descriptions, and enforces business rules such as unique board names within a project, unique card names within a board, and maximum card count limits. It uses MongoDB for persistence, with specific indexes created for board IDs and project IDs. The API exposes endpoints for creating, updating, and deleting boards and cards, emitting domain events for these actions. Configuration includes MongoDB connection strings, RabbitMQ settings for messaging, and JWT authentication policies for user read access.

src/2-Services/Boards/Api/Boards.Write.Api, src/2-Services/Identity/Api/Identity.Api, src/2-Services/Tasks/Api/Tasks.Write.Api · high confidence

This change introduces the UserPanel API Gateway, a new .NET 8 service that acts as the entry point for the User Panel. It is built on Ocelot for routing and integrates with IdentityServer for JWT-based authentication. The gateway includes configuration for Serilog (logging to console, file, and Seq), OpenTelemetry (metrics and tracing), and Swagger UI for API documentation. It is containerized via a new Dockerfile targeting .NET 8 and includes development and production appsettings.

src/3-ApiGateways/UserPanel/ApiGateway · high confidence

This change introduces the new UserPanel client, a Blazor WebAssembly application that provides the user interface for the platform. The client is configured with OIDC authentication via IdentityServer, integrates Blazored Toast and Modal libraries for UI feedback, and registers HTTP clients to communicate with the API Gateway for both protected and public endpoints. It includes a Dockerfile for containerization using .NET 8 and Nginx, along with static asset bundling configuration.

src/4-Clients/UserPanel · high confidence

The website's Razor view layer has been established with a new shared layout (\_Layout.cshtml) that includes navigation links to the user panel and a footer with GitHub source attribution. The home page (Index.cshtml) now displays the application's value proposition and a dynamic link to the user panel registration, alongside an image of GitHub contributors. Supporting views include a shared error handling template (Error.cshtml, KnownError.cshtml) and a domain validation summary component, all configured via \_ViewImports and \_ViewStart to use the new layout and necessary tag helpers.

src/4-Clients/Website/Views · high confidence

The Tasks.Read.Api service now includes its core infrastructure layer, establishing the data access and mapping foundation for read operations. This introduces a dedicated TaskReadDbContext to interact with MongoDB collections for Tasks, Comments, and Activities, along with automatic database initialization logic that creates necessary indexes (including unique constraints on IDs) upon startup. Dependency injection is configured to wire up these components, and AutoMapper profiles are registered to handle translations between domain entities, DTOs, and gRPC responses, enabling the service to query and return task-related data.

src/2-Services/Tasks/Api/Tasks.Read.Api/Infrastructure · high confidence

A new abstract BaseConsumer class has been added to the building blocks, providing a standardized base for implementing MassTransit consumers. This class implements the IConsumer interface and injects an IRequestDispatcher, allowing derived consumer classes to focus on specific business logic via the abstract ConsumeMessage method while handling the standard Consume lifecycle.

src/1-BuildingBlocks/Web.MVC/Consumers · high confidence

A new BasePageModel class has been added to the Web.MVC building blocks, inheriting from PageModel and injecting an IRequestDispatcher service. This provides a standardized base for Razor Pages to access the in-memory bus for handling requests, reducing boilerplate in individual page models.

src/1-BuildingBlocks/Web.MVC/Pages · high confidence

The UserPanel Aggregator service is now available as a .NET 8 Web API, providing a unified entry point for client requests. It aggregates data from the Owner, Board, and Task read services via gRPC clients and enforces JWT authentication against the Identity service. The service includes configuration for RabbitMQ messaging, response caching, OpenTelemetry observability, and Swagger documentation, with support for Development and Staging environments.

src/3-ApiGateways/UserPanel/Aggregator · high confidence

Added a new set of Data Transfer Objects (DTOs) for the Projects module, including AddProjectDto, GetProjectDto, UpdateProjectDto, ProjectReportDto, and the base ProjectBaseDto. These classes define the structure for project creation, retrieval, updates, and reporting, incorporating validation attributes for fields such as name, description, and organization ID.

src/1-BuildingBlocks/Contracts/Dtos/Projects · high confidence

New DTOs have been added to the contracts layer to support task management operations. AddTaskDto and UpdateTaskDto define the input structures for creating and modifying tasks, including validation rules for title length and required fields. GetTaskDto exposes the full set of fields returned when retrieving a task, such as card name, board, project, and organization identifiers, along with creation time. TaskReportDto provides aggregated counts for tasks in various states (To-Do, Doing, Done, Backlog). These changes establish the data contracts for the task write service and reporting capabilities.

src/1-BuildingBlocks/Contracts/Dtos/Tasks · high confidence

The aggregator now includes a new MappingProfile that configures AutoMapper to convert gRPC responses (CreationTimeGrpcResponse, GetOrganizationGrpcResponse, GetProjectGrpcResponse, GetBoardGrpcResponse, GetCardGrpcResponse) into their corresponding DTOs. This ensures consistent data transformation between the gRPC client layer and the internal domain models.

src/3-ApiGateways/UserPanel/Aggregator/Infrastructure/Mapper · high confidence

This change adds the core abstractions and infrastructure implementations for the application layer's service contracts. It defines interfaces for the current authenticated user, an event publisher (implemented via MassTransit for out-of-process communication), a request dispatcher (implemented via MediatR for in-process commands, queries, and domain events), and a notification service. Additionally, it introduces an event store abstraction with a Redis-based implementation for persisting and retrieving domain events, enabling the application to track entity history and state changes.

src/1-BuildingBlocks/Application/Services, src/1-BuildingBlocks/Infrastructure/Services · high confidence

This change adds the core domain entities, value objects, and specifications for the Owners service. Users can now register owners, create and manage organizations, and add, update, or delete projects within those organizations. The domain enforces business rules such as unique email addresses for owners, unique organization and project names, maximum limits for organizations and projects, and constraints that names and descriptions cannot be identical. It also defines domain events for owner registration, profile updates, and organization/project lifecycle changes.

src/2-Services/Owners/Api/Owners.Write.Api/Domain · high confidence

The building blocks infrastructure now includes pipeline behaviors and exception handlers to standardize request processing. CachingBehavior automatically caches responses for queries marked with ICacheableQuery, respecting global and per-request configuration. EventStoringBehavior ensures domain events are persisted via the event store. ValidationBehaviour enforces both FluentValidation and data annotations, reporting errors through the notification service. ManagedExceptionHandler and UnmanagedExceptionHandler provide centralized error handling, logging requests and exceptions while populating the notification service for consistent user feedback.

src/1-BuildingBlocks/Infrastructure/Behaviors, src/1-BuildingBlocks/Infrastructure/Exceptions · high confidence

The application now supports optional caching for queries through the new \BaseQuery\ abstract class and \ICacheableQuery\ interface in the BuildingBlocks layer. Queries inheriting from \BaseQuery\ are marked as cacheable, with caching disabled by default; users can explicitly enable it by calling \EnableCaching()\ on the query instance before sending it. This change encapsulates caching logic at the base query level, allowing the \CachingBehavior\ to detect and handle cached queries automatically.

src/1-BuildingBlocks/Application/Queries · high confidence

The domain building block now includes a reusable base class for value objects (\BaseValueObject\) that implements standard equality and hashing logic, along with a concrete \CreationTime\ value object. This allows domain entities to track creation and modification timestamps while ensuring value-based equality semantics.

src/1-BuildingBlocks/Domain/ValueObjects · high confidence

The read-side domain model for the Boards service now includes explicit entity classes for Board and Card. These classes inherit from a common base entity, enforce non-null IDs via constructor validation, and expose properties for core attributes such as name, description, and associated organization or project identifiers. This establishes the foundational data structures for reading board and card information within this service.

src/2-Services/Boards/Api/Boards.Read.Api/Domain · high confidence

New Data Transfer Objects (DTOs) have been added to the building blocks contracts to support comment operations. This includes a base DTO (CommentBaseDto) defining common fields like content and task ID with validation rules, along with specific DTOs for adding (AddCommentDto), retrieving (GetCommentDto, which includes creation time), and updating (UpdateCommentDto) comments.

src/1-BuildingBlocks/Contracts/Dtos/Comments · high confidence

A new DomainException class has been added to the BuildingBlocks.Domain.Exceptions namespace. This class inherits from ManagedException and provides a simple constructor accepting a message, serving as the base exception type for domain-level errors within the application.

src/1-BuildingBlocks/Domain/Exceptions · high confidence

A new ManagedException class has been added to the Contracts/Exceptions building block. This class inherits from the standard System.Exception and provides a simple constructor that accepts a message string, establishing a specific exception type for managed error handling within the application's contract layer.

src/1-BuildingBlocks/Contracts/Exceptions · high confidence

New Data Transfer Objects (DTOs) have been added to the building blocks contracts to support organization management. This includes base and specific DTOs for adding, updating, and retrieving organizations (AddOrganizationDto, UpdateOrganizationDto, GetOrganizationDto), a base definition (OrganizationBaseDto) with validation attributes for name and description, and a report DTO (OrganizationReportDto) that extends project reporting to include a projects count.

src/1-BuildingBlocks/Contracts/Dtos/Organizations · high confidence

New interfaces have been added to the domain services layer to standardize data access and query logic. IBaseRepository defines standard CRUD operations (Add, Update, Delete, GetById, GetList, Count) and disposal for entities, while IBaseAggregateRepository extends this with a ConcurrencySafeUpdate method for aggregate roots. Additionally, ISpecification introduces a pattern for evaluating whether entities satisfy specific criteria via the IsSatisfiedBy method.

src/1-BuildingBlocks/Domain/Services · high confidence

The Owners Read API now includes core domain models for Organization, Owner, and Project. These entities define the structure for reading owner-related data, including properties such as Name, Description, Email, and DisplayName, and enforce validation by throwing domain exceptions for null IDs during instantiation.

src/2-Services/Owners/Api/Owners.Read.Api/Domain · high confidence

The domain building block now includes a hierarchy of base entity classes: Entity, BaseEntity, and AggregateRoot. Entity provides a basic identifier, BaseEntity adds creation and modification timestamps, and AggregateRoot introduces versioning for concurrency control and a mechanism to track and clear domain events.

src/1-BuildingBlocks/Domain/Entities · high confidence

A new generic DomainEvent base class has been added to the BuildingBlocks.Domain.Events namespace. This class implements MediatR's INotification interface and provides a standardized structure for domain events, including properties for EntityId, EntityType, EventType, and OccurredOn. This change establishes a common foundation for domain event handling within the application's building blocks.

src/1-BuildingBlocks/Domain/Events · high confidence

The system now exposes a set of Data Transfer Objects (DTOs) in the \TaskoMask.BuildingBlocks.Contracts.Dtos.Cards\ namespace to handle card-related data contracts. This includes \AddCardDto\ and \UpdateCardDto\ for creating and modifying cards, inheriting from a new \CardBaseDto\ that enforces validation rules for card name, board association, and type. \GetCardDto\ extends this base to include read-only details such as board name, project/organization/owner identifiers, and creation time. Additionally, \CardReportDto\ is introduced to expose task count metrics for cards.

src/1-BuildingBlocks/Contracts/Dtos/Cards · high confidence

The Tasks.Read.Api service now includes explicit domain models for Task, Comment, and Activity. These entities define the structure of the read-side data, including task details (title, description, board/project context), comment content, and activity logs, establishing the foundation for the read-optimized view of task data.

src/2-Services/Tasks/Api/Tasks.Read.Api/Domain · high confidence

The Web.MVC layer now includes a new BaseApiController that provides derived controllers with access to the current user's identity and a request dispatcher, alongside an ErrorViewModel for consistent error handling and an ICurrentUser implementation that extracts user details from the HTTP context. These additions establish a standardized foundation for MVC-based API endpoints within the building blocks.

src/1-BuildingBlocks/Web.MVC/Controllers · high confidence

The Boards Read API now includes a new feature to retrieve a specific card by its ID. This change adds the necessary request handler, query model, and two endpoint implementations: a REST controller accessible at /cards/{id} with user-read-access authorization, and a gRPC service method. The handler queries the MongoDB read database and maps the result to a DTO, throwing an application exception if the card is not found.

src/2-Services/Boards/Api/Boards.Read.Api/Features/Cards/GetCardById · high confidence

The application now includes a new JWT configuration module that registers authentication and authorization services. Users can define specific authorization policies in the 'Jwt' configuration section, where each policy can optionally require the user to be authenticated via the new 'RequireAuthenticatedUser' flag, in addition to requiring specific scopes.

src/1-BuildingBlocks/Web.MVC/Configuration/Jwt · high confidence

The Tasks Write API now exposes a dedicated endpoint to update existing tasks via an HTTP PUT request at /tasks/{id}. This change introduces a structured use-case implementation that includes request validation (ensuring the description differs from the title), concurrency-safe updates to the task aggregate, and the publishing of domain and integration events upon successful modification.

src/2-Services/Tasks/Api/Tasks.Write.Api/UseCases/Tasks/UpdateTask · high confidence

The application now provides a new BaseCommandHandler in the BuildingBlocks that centralizes event publishing logic. Command handlers inheriting from this base class can now easily publish domain events (in-process) and integration events (out-process) using the injected IEventPublisher and IRequestDispatcher, simplifying the implementation of command handlers that need to raise events.

src/1-BuildingBlocks/Application/Commands · high confidence

The User Panel now includes a set of Razor components for managing boards, cards, and tasks. Users can add new boards with organization and project selection, update or delete existing boards, and navigate via a breadcrumb that also allows adding cards. The interface supports drag-and-drop reordering of tasks between cards and provides modals for viewing task details, updating cards, and adding new cards.

src/4-Clients/UserPanel/Pages/Boards/Components · high confidence

The User Panel now includes dedicated Blazor components for managing comments: AddComment.razor allows users to submit new comments for a specific task, while UpdateComment.razor enables editing existing comments and includes functionality to delete them with a confirmation step. These components interact with the CommentApiService to handle data operations and provide user feedback via toast notifications.

src/4-Clients/UserPanel/Pages/Comments · high confidence

The BuildingBlocks.Contracts layer now includes helper classes for command results (CommandResult) and generic operation results (Result and Result\<TValue\>), along with an email validation utility and a set of domain constant values for entity length limits. Additionally, strongly-typed resource classes (ContractsMessages and ContractsMetadata) with corresponding .resx files have been added to provide localized strings for operation statuses, validation errors, and UI labels.

src/1-BuildingBlocks/Contracts/Helpers · high confidence

The User Panel's Dashboard now includes a set of new Razor components (Workspace, TabNav, Projects, Reports, Tips) that provide a tabbed interface for managing organizations. Users can view organization details, switch between Boards, Projects, and Reports tabs, and add or update projects and organizations via modals directly from the dashboard view.

src/4-Clients/UserPanel/Pages/Dashboard/Components · high confidence

Users can now move a task to a different card via a new PUT endpoint at /tasks/{taskId}/moveto/{cardId}. This change introduces the MoveTaskToAnotherCard use case, which validates the request, updates the task's card assignment with concurrency control, and publishes the resulting domain and integration events.

src/2-Services/Tasks/Api/Tasks.Write.Api/UseCases/Tasks/MoveTaskToAnotherCard · high confidence

Users can now fetch comprehensive project information via a new GET /projects/{id} endpoint. This feature aggregates data by calling underlying gRPC services to retrieve the core project details and a stream of associated boards, returning a unified ProjectDetailsViewModel that includes both the project entity and its board collection.

src/3-ApiGateways/UserPanel/Aggregator/Features/GetProjectById · high confidence

The User Panel client now includes a set of helper classes to streamline UI interactions and data management. CommandResultHandler and QueryResultHandler provide a fluent API to automatically display success or error toasts, publish component messages, and close modals based on operation results. HtmlParser assists in formatting error lists for toast notifications. ReloadDataHelper determines which specific views (such as Dashboard, Project, or Board indexes) need to refresh based on incoming message types, while MagicKey defines constants for API gateway client names.

src/4-Clients/UserPanel/Helpers · high confidence

The User Panel now includes dedicated Razor components for managing projects within the Projects area. Users can add new projects via the AddProject component, which collects name, description, and organization selection. Existing projects can be updated or deleted using the UpdateProject component, which loads current details and provides a confirmation flow for deletion. Additionally, the Breadcrumb component provides navigation context, displaying the organization and project name to help users orient themselves within the application hierarchy.

src/4-Clients/UserPanel/Pages/Projects/Components · high confidence

The Owners Read API now exposes new query endpoints to retrieve data for organizations, owners, and projects. Users can fetch a single organization by ID, list all organizations for a specific owner, retrieve owner details, get a single project by ID, and list all projects within an organization. These capabilities are available via both REST and gRPC interfaces, utilizing the MediatR pattern for request handling and MongoDB for data retrieval.

src/2-Services/Owners/Api/Owners.Read.Api/Features/Organizations, src/2-Services/Owners/Api/Owners.Read.Api/Features/Owners, src/2-Services/Owners/Api/Owners.Read.Api/Features/Projects, src/2-Services/Tasks/Api/Tasks.Read.Api/Features/Activities, src/2-Services/Tasks/Api/Tasks.Read.Api/Features/Comments, src/2-Services/Tasks/Api/Tasks.Read.Api/Features/Tasks · high confidence

The Boards Read API now exposes three new query capabilities: fetching a single board by its ID, listing all boards for a specific organization, and listing all boards for a specific project. These features are implemented using a CQRS pattern with MediatR handlers that query the MongoDB read database, and are exposed via both REST endpoints (under the 'Boards' tag) and gRPC services. The organization and project listing endpoints require 'user-read-access' authorization, while the single board lookup is publicly accessible.

src/2-Services/Boards/Api/Boards.Read.Api/Features/Boards · high confidence

The User Panel now includes a set of shared Razor components that define the core user interface structure. Authentication flows are handled via a new Authentication.razor page and a LoginRedirect.razor component that directs unauthenticated users to the identity provider. The main layout (MainLayout.razor) integrates a Blazored Toast notification system, while the navigation menu (NavMenu.razor) provides role-based access controls, allowing users to add workspaces, projects, and boards, update their profile, or sign out. Additionally, a Boards.razor component displays board cards with links to update or add new boards, and a Confirmation.razor component provides a reusable modal dialog for delete confirmations.

src/4-Clients/UserPanel/Shared · high confidence

The User Panel now includes a comprehensive task management view. Users can create new tasks via the AddTask component, edit or delete existing tasks through the UpdateTask modal, and move tasks between cards using the Move component. The task details page displays basic information, comments, and a chronological list of activities. The dashboard has also been updated to show an organization workspace view.

src/4-Clients/UserPanel/Pages/Tasks · high confidence

The Identity API now supports creating new user accounts and updating existing user email addresses. The RegisterUser use case allows users to sign up with an owner ID, email, and password, handling duplicate email checks and publishing domain and integration events upon success. The UpdateUser use case enables changing a user's email address by specifying the old and new email, also triggering relevant events. Both operations include validation logic and error handling via the notification service.

src/2-Services/Identity/Api/Identity.Api/UseCases/RegisterUser, src/2-Services/Identity/Api/Identity.Api/UseCases/UpdateUser · high confidence

A new registration page is now available at /register, allowing users to create an owner account by submitting their display name, email, and password. The page includes client-side validation, a loading state during submission, and redirects to the home page upon successful registration or displays error messages if the operation fails.

src/4-Clients/UserPanel/Pages/Owner · high confidence

The Owners.Read.Api service now maintains its MongoDB read-model by consuming domain events for Owners, Organizations, and Projects. New consumers handle creation, updates, and deletions: owner registration and profile updates sync owner data; organization add/update/delete events sync organization records and cascade name updates to associated projects; and project add/update/delete events keep the project collection current. A new gRPC extension registers the corresponding read-endpoints (GetOrganizationsByOwnerId, GetProjectById, GetProjectsByOrganizationId) to expose this synchronized data.

src/2-Services/Owners/Api/Owners.Read.Api/Consumers · high confidence

The User Panel client now supports OpenID Connect (OIDC) authentication, configured via new appsettings files for Development, Staging, and production environments. These configurations define the OIDC authority, client ID, scopes, and redirect URIs, alongside specific service URLs for the Website, User Panel, and API Gateway. Additionally, static assets including Bootstrap v4.3.1, Blazored Modal, and Blazored Toast CSS have been added to support the UI components.

src/4-Clients/UserPanel/wwwroot · high confidence

The website's static assets now include the minified CSS for Bootstrap v4.3.1. This adds the standard Bootstrap styling, grid system, and form components to the site, enabling consistent UI rendering across different screen sizes and devices.

src/4-Clients/Website/wwwroot · high confidence

The User Panel Aggregator now registers all its gRPC service clients (including GetBoardById, GetProjectById, GetBoardsByProjectId, and others) through a single \AddGrpcClients\ extension method. This change centralizes the configuration of client addresses based on the underlying read services (Owner-Read-Service, Board-Read-Service, Task-Read-Service), simplifying the dependency injection setup and ensuring consistent client wiring for the aggregator's data retrieval operations.

src/3-ApiGateways/UserPanel/Aggregator/Configuration · high confidence

The Organization management interface in the User Panel has been updated to support full CRUD operations. While the Add Organization form allows users to create new organizations, the Update Organization form now includes a Delete button that triggers a confirmation modal before removing an existing organization. Both forms utilize the updated DTOs from the contracts layer for data binding and validation.

src/4-Clients/UserPanel/Pages/Organizations · high confidence

The API endpoints for creating, updating, and deleting cards have been restructured into the UseCases layer. This change introduces dedicated endpoint classes (AddCardEndpoint, UpdateCardEndpoint, DeleteCardEndpoint) that route requests to corresponding command handlers, ensuring that card modifications are processed through the application's command pattern while maintaining existing authorization and validation logic.

src/2-Services/Boards/Api/Boards.Write.Api/UseCases/Cards · high confidence

The CAPTCHA setup logic has been consolidated into a new \CaptchaConfiguration\ class, which exposes an \AddCaptcha\ extension method for registering the DNTCaptcha service. This change standardizes the initialization of CAPTCHA settings—including cookie storage, expiration, visual noise, encryption, and input field names—making it easier to manage and reuse across the application.

src/1-BuildingBlocks/Web.MVC/Configuration/Captcha · high confidence

The Owners Write API now consolidates its infrastructure service registrations into a dedicated module. Users benefit from a unified entry point that automatically configures the MongoDB context, registers the owner validator service, and wires up the owner aggregate repository, ensuring consistent setup of backend data access and validation components.

src/2-Services/Owners/Api/Owners.Write.Api/Infrastructure/CrossCutting · high confidence

A new DI module has been introduced to the Aggregator's infrastructure layer, consolidating the registration of core services. This change configures the application to automatically discover and register building block infrastructure components (consumers, handlers, validators) and establishes the object mapping configuration, ensuring these foundational services are available to the Aggregator without manual wiring in the entry point.

src/3-ApiGateways/UserPanel/Aggregator/Infrastructure/DI · high confidence

The infrastructure layer now provides a unified \AddBuildingBlocksInfrastructure\ extension method to configure core application services. This single registration point sets up the in-memory message bus via MediatR, integrates MassTransit with RabbitMQ for event publishing, and configures validation, caching (EasyCaching), and event-storing behaviors within the request pipeline. It also registers the Redis-based event store service and applies both managed and unmanaged exception handlers, simplifying the startup configuration required to enable these cross-cutting concerns.

src/1-BuildingBlocks/Infrastructure · high confidence

The API endpoints for adding, updating, and deleting comments have been reorganized into the UseCases layer. This change introduces dedicated endpoint classes (AddCommentEndpoint, UpdateCommentEndpoint, DeleteCommentEndpoint) that route HTTP requests to corresponding command handlers, ensuring that comment modifications are processed through the application's command pattern while maintaining existing authorization and validation logic.

src/2-Services/Tasks/Api/Tasks.Write.Api/UseCases/Comments · high confidence

The Owners Read API now includes the core infrastructure layer required to serve read queries. This introduces a dedicated MongoDB context (OwnerReadDbContext) exposing collections for Owners, Organizations, and Projects, along with automatic database initialization that creates specific indexes (e.g., unique IDs, email, and foreign keys) to support query performance. Dependency injection is centralized in ModuleExtensions to wire up the MongoDB connection, AutoMapper profiles, and shared building-block services. The included mapping profiles define how domain entities are converted into DTOs and gRPC responses, ensuring consistent data shapes for API consumers.

src/2-Services/Owners/Api/Owners.Read.Api/Infrastructure · high confidence

The identity service's domain layer has been refactored to introduce explicit domain entities and events. New entity classes (User, UserLogin, UserToken) now inherit from ASP.NET Core Identity base types with string keys, and the User entity includes an IsActive flag. Additionally, domain events (UserRegisteredEvent, UserUpdatedEvent) have been added to capture user lifecycle changes, integrating with the shared building block event infrastructure.

src/2-Services/Identity/Api/Identity.Api/Domain · high confidence

The build system has been replaced with a Nuke script (src/6-Build/Build.cs) that orchestrates the entire build pipeline. This new build process automatically restores .NET tools, compiles the solution, and enforces code quality via CSharpier and dotnet format linting checks before running tests. Unit tests are executed with code coverage collection (OpenCover format), and the default build target now includes Stryker mutation testing, which reports results to a dashboard in CI environments. The build also includes specific configuration files for JetBrains Rider (Build.csproj.DotSettings) and MSBuild props/targets to support this new tooling.

src/6-Build · high confidence

New view models have been added to the BuildingBlocks.Contracts layer to structure detailed data for key domain entities. Specifically, BoardDetailsViewModel, CardDetailsViewModel, OrganizationDetailsViewModel, OwnerDetailsViewModel, ProjectDetailsViewModel, TaskDetailsViewModel, and PanelDashboardViewModel now encapsulate specific DTOs (such as GetBoardDto, GetCardDto, GetTaskDto, etc.) and their related collections. This change provides a standardized contract for presenting detailed information about boards, cards, tasks, organizations, owners, and projects, replacing the previous ad-hoc or less structured data transfer patterns.

src/1-BuildingBlocks/Contracts/ViewModels · high confidence

The Owners Write API now uses MongoDB as its persistence layer, replacing previous storage mechanisms. This change introduces a new \OwnerWriteDbContext\ to manage the connection, an \OwnerAggregateRepository\ to handle data retrieval (including lookups by email, organization, and project), and an \OwnerValidatorService\ to enforce unique email constraints. Additionally, a \DbInitialization\ component ensures the database is properly seeded and indexes (unique on ID and email, non-unique on display name) are created upon startup.

src/2-Services/Owners/Api/Owners.Write.Api/Infrastructure/Data · high confidence

The application now exposes specific exception classes, ApplicationException and ValidationException, which inherit from a common ManagedException base. This change allows the system to distinguish between general application errors and validation failures, enabling more precise error handling and reporting for users encountering issues during request processing.

src/1-BuildingBlocks/Application/Exceptions · high confidence

The Owners Read and Write API services have been re-architected to use .NET 8 base images in their Dockerfiles, replacing previous build configurations. The startup logic has been refactored into explicit \Program.cs\ and \Startup.cs\ files, where the Read API now initializes gRPC services and the Write API handles database seeding. Both APIs now include configuration for OpenTelemetry (metrics, tracing, and logging endpoints) and updated JWT authority settings for staging environments, while the Write API additionally configures Redis for event storage.

src/2-Services/Owners/Api/Owners.Read.Api, src/2-Services/Owners/Api/Owners.Write.Api · high confidence

The API endpoints for registering and updating owner profiles have been reorganized into the UseCases directory structure. This change refactors the service architecture by moving the endpoint definitions, request models, use case handlers, and validation logic for owner registration and profile updates into dedicated folders under the UseCases namespace, aligning with the application's clean architecture patterns.

src/2-Services/Boards/Api/Boards.Write.Api/UseCases/Boards, src/2-Services/Owners/Api/Owners.Write.Api/UseCases/Owners · high confidence

The API endpoints for creating, updating, and deleting projects have been restructured into the UseCases layer. This change introduces dedicated endpoint controllers, command requests, and validation logic for each operation, ensuring that project modifications are handled through a consistent command-based flow with concurrency-safe updates and integration event publishing.

src/2-Services/Owners/Api/Owners.Write.Api/UseCases/Projects · high confidence

The MongoDB building block has been restructured to improve configuration management and domain modeling. MongoDbContext now uses the IOptions\<MongoDbOptions\> pattern for connection settings, replacing direct configuration access. A new MongoDbBaseAggregateRepository has been introduced to handle concurrency-safe updates for aggregate roots, checking version changes before replacement. The base repository remains for standard entity operations, while unused methods and interfaces like IMongoDbContext have been removed to simplify the API.

src/1-BuildingBlocks/Infrastructure/MongoDB · high confidence

The board-related Data Transfer Objects (DTOs) in the contracts layer have been reorganized and renamed to better reflect the domain's ubiquitous language. This change introduces a new \BoardBaseDto\ containing shared properties like Name, Description, and ProjectId, which is inherited by \AddBoardDto\ and \GetBoardDto\. \GetBoardDto\ now explicitly includes owner, organization, project name, and creation time details. \UpdateBoardDto\ has been simplified to focus only on mutable fields (Id, Name, Description), and \BoardReportDto\ now inherits from \TaskReportDto\. These structural adjustments ensure consistent validation attributes and clearer separation of concerns for board creation, retrieval, and updates.

src/1-BuildingBlocks/Contracts/Dtos/Boards · high confidence

The owner Data Transfer Objects in the contracts layer have been renamed and reorganized to follow the domain's ubiquitous language. This change introduces \GetOwnerDto\ for retrieving owner details, \RegisterOwnerDto\ for new owner registration (including validation for display name, email, and password), and \UpdateOwnerProfileDto\ for modifying existing owner profiles. These files define the specific contract structures used for owner-related API interactions.

src/1-BuildingBlocks/Contracts/Dtos/Owners · high confidence

The API endpoints for adding and deleting tasks have been restructured into the UseCases layer. The AddTask endpoint now accepts a POST request to /tasks with a card ID, board ID, title, and description, enforcing validation that the title and description must not be identical. The DeleteTask endpoint handles HTTP DELETE requests to /tasks/{id}, ensuring the task exists before removal. Both operations now utilize a command-dispatch pattern to handle domain logic and publish integration events.

src/2-Services/Tasks/Api/Tasks.Write.Api/UseCases/Tasks/AddTask · high confidence

The Tasks Read API now synchronizes its local MongoDB state by consuming domain events (TaskAdded, TaskDeleted, TaskUpdated, TaskMovedToAnotherCard, CardUpdated, CommentAdded, CommentDeleted, CommentUpdated) through new MassTransit consumers. When a task is added or moved, the service calls the Board Read Service's gRPC endpoint to fetch card details (name, type, project/organization/owner IDs) and enriches the stored task record. Task and comment updates/deletions are applied directly to the local database, ensuring the read model stays consistent with the write side.

src/2-Services/Tasks/Api/Tasks.Read.Api/Consumers · high confidence

The Identity.Api service now serves Bootstrap v4.3.1 for its frontend styling. This update to the static CSS assets in the wwwroot directory ensures that the login, registration, and other identity-related pages render with the latest Bootstrap 4.3.1 components and utilities, affecting the visual appearance and layout of these user-facing views.

src/2-Services/Identity/Api/Identity.Api/wwwroot · high confidence

The User Panel client now uses a standardized \BaseApiService\ to route all external requests through the API gateway, ensuring consistent HTTP client configuration and resolving previous runtime lookup errors. Dedicated API services (Board, Card, Comment, Organization, Owner, Project, Task) have been implemented to handle domain operations, with URLs aligned to the monolith's read/write endpoints (e.g., \/owners-read/\, \/owners-write/\, \/aggregator/\). Additionally, a \ComponentMessageService\ and \DragDropService\ have been added to enable internal state synchronization and drag-and-drop data sharing between UI components.

src/4-Clients/UserPanel/Services · high confidence

Added Stryker mutation testing reports to Identity unit tests; Added integration test fixtures for Board and Card collections; Added integration test infrastructure for the Owners service; Added integration tests for Identity service user registration and login; Added integration tests for Organization and Project CRUD operations; Added integration tests for Owners Read service features; Added integration tests for Tasks.Read service queries; Added integration tests for board and card write operations; Added integration tests for card retrieval features; Added integration tests for owner registration and profile update; Added integration tests for task and comment CRUD operations; Added test data builders for Board entities; Added test helpers and data builders for Identity unit tests; Added test infrastructure base classes and data generation utilities; Added unit test fixture for Boards Write service; Added unit test fixture for Identity service mocks; Added unit tests for Organization and Project use cases; Added unit tests for comment management use cases; Added unit tests for owner registration and profile update use cases; Added unit tests for task write operations; Added unit tests for user registration and login use cases.

All projects in the solution, including the BuildingBlocks, Services, ApiGateways, Clients, and Tests, have been upgraded to target the .NET 8 runtime. This change updates the \TargetFramework\ property across all \.csproj\ files. Additionally, the diff shows the addition of standard project properties such as \AssemblyName\ and \RootNamespace\ to ensure consistent naming conventions, and the adoption of \\<ImplicitUsings\>enable\</ImplicitUsings\>\ in many projects to simplify code imports.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 37.

• Code Health 38
• Architecture 82
• Maturity 59
• Readiness 30
• Security 57
• Domain Modelling 66
• Event-Driven 100
• Accessibility 33

• 300 commits — 251 feature/other, 49 fixes

• src/2-Services — 170 commits
• src/1-BuildingBlocks — 29 commits
• (repo) — 25 commits
• .github/workflows — 18 commits
• .github/README.md — 14 commits
• src/3-ApiGateways — 10 commits
• (root) — 7 commits
• .config/dotnet-tools.json — 7 commits
• src/6-Build — 7 commits
• src/4-Clients — 5 commits
• .nuke/build.schema.json — 2 commits
• docs/images — 2 commits
• src/7-Docker — 2 commits
• docs/Branch-Conventions.md — 1 commit
• src/6-Docker — 1 commit

• fix: Fix porject name bug in solution
• fix: Revert "fix: remove map razor page into use end point"
• fix: chore: fix a naming mistake for card tests namespace
• fix: chore: fix docker-compose address in comments
• fix: chore: fix linter
• fix: fix: Swagger and DNTCaptcha conflict
• fix: fix: a compile error with docker-compose project
• fix: fix: add captcha validation into identity
• fix: fix: add card mapping config
• fix: fix: add task domain services to DI configs
• fix: fix: ci workflow
• fix: fix: contributers image url
• fix: fix: docker files
• fix: fix: dotnet-tools config
• fix: fix: edit message and text captcha
• fix: fix: fix a compile error
• fix: fix: fix a parameter naming mistake
• fix: fix: fix card endpoint route
• fix: fix: fix some compile errors
• fix: fix: fix some compile errors
• …and 280 more

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

hamed-shirbandi/TaskoMask 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.