Skip to content
CAI
Software that uses CAICheck a score

SaintAngeLs/distributed_minispace

39.5

Weak · 8 November 2026

82.2k

lines of production code

C#

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

MiniSpace is a student life activity platform built on .NET 8 and a microservices architecture, designed to manage social interactions, events, and content. It provides core capabilities for user identity and authentication, event discovery and participation, and social features including friend management, comments, and real-time chat. The system also handles media file storage, email notifications, and administrative reporting, all coordinated through an API gateway and event-driven messaging.

Features

Add IP address resolution and message broker infrastructure services

The identity service now includes an IPAddressService to reliably extract client IP addresses from HTTP requests, handling X-Forwarded-For headers and remote connection details. Additionally, a new MessageBroker implementation has been added to handle the publishing of integration events, supporting both direct publishing and an outbox pattern for reliability, while integrating with distributed tracing and correlation contexts.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Services · high confidence

Add PagedResponse wrapper for paginated data

A new PagedResponse generic wrapper class has been added to the Friends service core. This class provides a structured way to handle paginated results, exposing properties for the current page items, total counts, page size, and navigation helpers (NextPage, PreviousPage, First, Last, Empty). This supports the updated repository implementation by standardizing how paginated friend data is returned to consumers.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Core/Wrappers · high confidence

Add core response wrapper classes for API communication

The service now includes two new wrapper classes, PagedResponse and Response, to standardize how data and status information are returned. PagedResponse provides structured pagination details including total items, page numbers, and navigation hints, while Response encapsulates operation success status, content, and error messages. These wrappers support consistent API contract handling for event browsing and other service operations.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Core/Wrappers · high confidence

The Notifications service now exposes structured Data Transfer Objects (DTOs) to represent event data, including \EventDto\, \EventSettingsDto\, and \OrganizerDto\. These classes define the shape of event information—such as details, settings, and organizer identity—facilitating the serialization and transmission of event data within the application layer.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Dto/Events · high confidence

Add file source info repository interface

The media files service now includes a new repository interface, IFileSourceInfoRepository, which defines methods for managing file source information. This interface supports operations such as adding, deleting, and updating file source records, as well as querying for unassociated files and finding files by uploader or organization ID. This change enables the service to track and manage metadata about where media files originate, supporting features like cleanup of unassociated files and better organization of media assets.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Core/Repositories · high confidence

Add friend relationship and request query models

The Friends service application layer now includes query models to retrieve specific friend-related data. Users can now fetch paginated lists of followers, following, and general friends, as well as retrieve individual friend details, friend events, and both incoming and sent friend requests. These new query definitions enable the backend to support endpoints for viewing social connections and managing friend request statuses.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application/Queries · high confidence

Add handlers for retrieving media files and original media files

New query handlers have been added to the Media Files service to support fetching media content. GetMediaFileHandler retrieves the processed media file (served as image/webp) from S3, while GetOriginalMediaFileHandler retrieves the unmodified original file, preserving its original content type. Both handlers fetch file metadata and content from MongoDB and S3 respectively, returning a FileDto that includes the file's base64-encoded content, state, creation date, and uploader information.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Infrastructure/Mongo/Queries · high confidence

Added MongoDB query handlers for retrieving and searching comments

The Comments Service now includes infrastructure handlers for fetching individual comments and searching across multiple contexts. The new GetCommentHandler retrieves a single comment by ID using the MongoDB repository, while the SearchCommentsHandler aggregates results from organization events, organization posts, user events, and user posts repositories. It supports pagination, sorting (by creation date or ID), and filtering by context, returning a paged response of comment DTOs.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Queries · high confidence

Added MongoDB repository for file source information

The MediaFiles service now includes a new persistence layer for tracking file source metadata via the newly added FileSourceInfoMongoRepository. This implementation allows the system to store and retrieve associations between media files and their original sources, supporting operations such as querying by URL, finding unassociated files, and filtering by uploader or organization. This change enables the service to maintain accurate records of file provenance and manage the lifecycle of file associations more effectively.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Infrastructure/Mongo/Repositories · high confidence

Added application and identity context infrastructure

The infrastructure layer now includes new context classes (AppContext, IdentityContext, CorrelationContext) and a factory (AppContextFactory) to manage request-scoped identity and correlation data. This enables the service to extract user identity, authentication status, and request tracing information from HTTP or message broker contexts, providing a structured way to access user claims and correlation IDs throughout the application.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Contexts · high confidence

Added background worker for periodic event state updates

A new background service, EventStateUpdaterWorker, has been introduced to automatically update event states. This worker runs continuously, checking the current time every minute and dispatching an UpdateEventsState command whenever the minute value is divisible by 5, ensuring state synchronization occurs at five-minute intervals.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Services/Workers · high confidence

Added build, start, and Docker deployment scripts for the Events service

New shell scripts have been added to the MiniSpace.Services.Events location to streamline local development and containerized deployment. The \build.sh\ script sets the ASP.NET Core environment to 'local' and builds the API project in release mode. The \start.sh\ script runs the API locally with the 'local' environment. The \dockerize-tag-push.sh\ script builds a Docker image tagged as 'latest', tags it with the registry name 'adrianvsaint/minispace.services.events:latest', and pushes it to the registry, using the 'docker' environment variable.

MiniSpace.Services.Events/scripts · high confidence

Added build, test, and deployment automation scripts

The MiniSpace.Services.MediaFiles service now includes a set of shell scripts in the \scripts\ directory to streamline development and deployment workflows. These scripts provide commands for building the project (\build.sh\), running unit tests (\test.sh\), starting the service locally (\start.sh\), and managing Docker container operations including building, tagging, and pushing images to a registry (\dockerize.sh\, \dockerize-tag-push.sh\).

MiniSpace.Services.MediaFiles/scripts · high confidence

Added build, test, and deployment scripts for the Friends service

The MiniSpace.Services.Friends location now includes a set of operational shell scripts to streamline development and deployment workflows. Users can now run build.sh to compile the service in release mode, test.sh to execute unit tests, and start.sh to launch the service locally (configured to run the Students API context). Additionally, dockerize-tag-push.sh automates the Docker containerization process by building the image, tagging it with the latest version, and pushing it to the specified container registry.

MiniSpace.Services.Email/scripts, MiniSpace.Services.Friends/scripts · high confidence

Added command handlers for two-factor authentication and email verification

The identity service now includes new command handlers to support two-factor authentication (2FA) and email verification workflows. Users can generate 2FA secrets, enable or disable 2FA, and verify their email addresses through dedicated handlers (GenerateTwoFactorSecret, EnableTwoFactor, DisableTwoFactor, and VerifyEmail). These handlers delegate to the underlying identity service and log relevant actions, providing the backend support for these security features.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/Commands/Handlers · high confidence

Added comment and reply data transfer objects

Introduced CommentDto and ReplyDto classes to structure comment-related data within the notifications service. These DTOs define the shape of comment entities, including fields for content, user identification, timestamps, and nested reply structures, enabling the application layer to serialize and deserialize comment data for external events and handlers.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Dto/Comments · high confidence

Added core domain event infrastructure

The MiniSpace.Services.Events.Core module now includes the foundational structure for domain events, introducing the IDomainEvent interface and the associated solution file to support future entity implementations.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Core · high confidence

Added deployment and build automation scripts for the Identity service

New shell scripts have been added to the MiniSpace.Services.Identity/scripts directory to streamline the development and deployment lifecycle. The build.sh and test.sh scripts automate the .NET build and test processes, while start.sh facilitates local development by setting the environment to 'local' and running the API. For containerization, dockerize.sh handles CI/CD workflows on Travis CI by tagging and pushing images based on the branch (master or develop), and dockerize-tag-push.sh provides a manual option to build, tag, and push the image to Docker Hub.

MiniSpace.Services.Identity/scripts · high confidence

Added deployment and development scripts for the API Gateway

The MiniSpace.APIGateway now includes a set of shell scripts to streamline local development and CI/CD workflows. Developers can use start.sh and start-async.sh to run the application locally with specific environment configurations, while test.sh and build.sh handle unit testing and release builds. For deployment, dockerize.sh integrates with Travis CI to automatically build, tag, and push Docker images to Docker Hub based on the active branch (master or develop), and dockerize-tag-push.sh provides a manual alternative for immediate Docker image publishing.

MiniSpace.APIGateway/scripts · high confidence

Added deployment and development scripts for the Comments service

This change introduces a set of shell scripts in the Comments service's scripts directory to streamline local development and CI/CD workflows. Users can now use \start.sh\ and \start-async.sh\ to launch the API gateway and the Comments service respectively, with environment variables configured for local execution. The \build.sh\ and \test.sh\ scripts automate the .NET build and test processes. For containerization, \dockerize.sh\ handles building and pushing Docker images to Docker Hub with tags based on the branch (master or develop), while \dockerize-tag-push.sh\ provides a simpler mechanism to build, tag, and push the image to a specific Docker Hub repository.

MiniSpace.Services.Comments/scripts · high confidence

Added domain events for comments and likes

The Comments application layer now exposes a comprehensive set of domain events to communicate state changes. For comments, the system emits CommentCreated, CommentUpdated, and CommentDeleted events, carrying details such as user identity, content, timestamps, and reply counts. For the like functionality, it introduces LikeAdded, LikeUpdated, and LikeDeleted events to track user interactions. Additionally, a Rejected sub-namespace has been added with CreateCommentRejected, DeleteCommentRejected, and UpdateCommentRejected events to signal validation or business rule failures during comment operations.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Events · high confidence

Added domain events for the friends service

The Friends service core now exposes a set of domain events to signal key moments in the friend lifecycle, including creation, acceptance, decline, cancellation, and removal of requests, as well as friendship confirmation and removal. These events (such as FriendAdded, FriendshipConfirmed, and PendingFriendAccepted) provide a structured way for other parts of the system to react to changes in social connections.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Core/Events, MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Core/Events · high confidence

Added email notification creation command and handler

The application layer now includes a new command, CreateEmailNotification, and its corresponding handler. This allows the system to process requests to send email notifications by accepting user ID, email address, subject, and body, and then invoking the email service to send the message. A DeleteNotification command and its handler were also added, though the handler implementation is currently commented out and inactive.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Application/Commands · high confidence

Added external event definitions for comments, reactions, and media files

The application now exposes new external event types to capture user interactions and media changes: CommentCreated, ReactionCreated, EventImageUploaded, and MediaFileDeleted. These events allow downstream systems to react to new comments and reactions on content, as well as the upload and deletion of media files associated with events.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Events/External · high confidence

Added infrastructure clients for Friends, Organizations, and Students services

The Events service now includes HTTP clients to communicate with external services for retrieving friend lists, organization details, and student information. Specifically, the new \FriendsServiceClient\ fetches a user's friends, \OrganizationsServiceClient\ retrieves organization details and child organizations, and \StudentsServiceClient\ fetches student events, validates student existence, and retrieves student profiles. These clients enable the Events service to integrate data from these upstream services.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Services/Clients · high confidence

Added infrastructure context classes for request and identity handling

New infrastructure classes have been added to the Comments service to manage request correlation and user identity. This includes \AppContext\ and \AppContextFactory\ to capture and propagate correlation IDs and user data from HTTP or message broker contexts, \IdentityContext\ to represent authenticated user details (ID, role, claims), and \CorrelationContext\ as the underlying data structure for these contexts. These changes support better tracing and user-aware processing within the service.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Contexts · high confidence

Added outbox decorators for command and event handlers

The Comments service now includes infrastructure decorators that wrap command and event handlers with an outbox pattern. When enabled, these decorators ensure that commands and events are persisted to the message outbox before being processed, supporting reliable message delivery. The implementation uses the Paralax framework's CQRS and message broker abstractions, with configuration controlled via OutboxOptions.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Decorators · high confidence

Added queries for retrieving user details and online user lists

The application layer now exposes two new CQRS queries to support user data retrieval. GetOnlineUsers allows clients to fetch a paginated list of currently online users, while GetUser enables fetching the details of a specific user by their unique identifier. These queries define the input parameters (page/size for the list, user ID for the single record) required to trigger the corresponding handlers in the identity service.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/Queries · high confidence

Added queries to retrieve media files and their originals

The application layer now includes two new query definitions: GetMediaFile and GetOriginalMediaFile. Both accept a MediaFileId and return a FileDto, enabling the system to fetch media file data and the original file content respectively.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Queries · high confidence

Added query handlers for retrieving user and online user data

New MongoDB query handlers have been introduced to support fetching individual user profiles and paginated lists of currently online users. The GetUserHandler retrieves a single user by ID, while the GetOnlineUsersHandler queries the database for users marked as online, applying sorting by last active time and pagination logic to return a paged result set.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Mongo/Queries · high confidence

Added query models for retrieving and searching comments

The Comments service now exposes two new application-layer query definitions to support fetching individual comments and paginated search results. The GetComment query allows retrieving a single comment by its ID, while the SearchComments query enables filtering comments by context (ID and type), parent comment, pagination, and sorting criteria (including support for multiple sort fields via a comma-separated string). These query models form the input contracts for the corresponding handlers that will process these requests.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Queries · high confidence

Added rejected event models for event operations

The Events application now includes a set of new domain classes in the \MiniSpace.Services.Events.Application.Events.Rejected\ namespace to represent failure scenarios for various event-related commands. These new \IRejectedEvent\ implementations cover operations such as creating, updating, and deleting events, as well as participant actions like signing up, canceling interest, and rating events. Each model captures the specific context of the rejection, including the affected EventId, relevant UserIds (such as StudentId or OrganizerId), and descriptive Reason and Code strings, enabling the system to properly propagate and handle validation or business-logic failures to users.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Events/Rejected · high confidence

Added request and response wrapper classes for comment operations

New wrapper classes have been introduced in the Comments Core service to standardize data transfer structures. BrowseCommentsRequest now encapsulates pagination, context, and sorting parameters for browsing comments. PagedResponse provides a generic container for paginated results, including metadata like total pages and navigation helpers. Response serves as a generic envelope for operation outcomes, indicating success status and containing content or error messages.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Core/Wrappers · high confidence

Added service client interfaces for Friends, Organizations, and Students

The application layer now includes new client interfaces to communicate with external services: IFriendsServiceClient for retrieving user friends, IOrganizationsServiceClient for fetching organization details and child organizations, and IStudentsServiceClient for student existence checks and retrieving student event data. These interfaces define the contracts for integrating friend lists, organizational hierarchies, and student information into the events service.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Services/Clients · high confidence

Added solution file for MiniSpace.Services.Events

A new Visual Studio solution file (src.sln) has been added to the MiniSpace.Services.Events/src directory. This file defines the build configuration for the service, grouping four projects: MiniSpace.Services.Events.Infrastructure, MiniSpace.Services.Events.Api, MiniSpace.Services.Events.Core, and MiniSpace.Services.Events.Application. This enables developers to build and manage the entire Events service module as a single unit within Visual Studio.

MiniSpace.Services.Events/src · high confidence

Adds exception-to-response mapping for the Organizations service

The Organizations service now includes infrastructure components to map application and domain exceptions into standardized HTTP responses. When an error occurs, the system returns a 400 Bad Request containing a specific error code and reason; for known domain or application exceptions, the code is derived from the exception's Code property or its type name, while other errors default to a generic 'error' code.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure/Exceptions · high confidence

Adds infrastructure context classes for request and identity management

The infrastructure layer now includes concrete implementations for application and identity contexts (AppContext, IdentityContext, CorrelationContext) along with a factory (AppContextFactory) to instantiate them. This enables the service to capture and propagate request correlation IDs, user identity details, and authentication status from HTTP or message broker sources into the application layer.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure/Contexts · high confidence

Application layer scaffolding with DI extensions and identity context

The application layer now includes foundational infrastructure: an \Extensions\ class registers command and event handlers along with in-memory dispatchers via the Paralax CQRS framework, and new interfaces (\IAppContext\, \IIdentityContext\) define the request and user identity data available to application services. A \ContractAttribute\ is also added to exclude specific code from coverage analysis.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application · high confidence

Email notification domain model and strategy pattern introduced

The email service now uses a structured domain model to handle notifications, introducing an \AggregateRoot\ base class and an \AggregateId\ value object to enforce identity and versioning. A new \EmailNotification\ entity tracks the lifecycle of messages (Pending, Sent, Failed, Cancelled), while \StudentEmails\ aggregates these notifications per user. To support diverse notification types, the system implements a strategy pattern with \EmailSubjectFactory\ and \EmailContentFactory\, mapping specific \NotificationEventType\ values (such as friend requests, event updates, and password resets) to dedicated subject and content strategies. This change also adds domain exceptions for validation (e.g., invalid email format, delivery failures) and repository interfaces for persisting student and notification data.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Core/Entities · high confidence

Email notification lifecycle events and external integration handlers

The email application layer now exposes a structured event lifecycle for email notifications, introducing domain events for creation, queuing, and sending (EmailCreated, EmailQueued, EmailSent) alongside corresponding rejection events (EmailCreationRejected, EmailQueueingRejected, EmailSendingRejected) to handle failures. It also implements an external event handler for NotificationCreated events, which triggers the generation of HTML email content using templates and factories, validates user consent and email availability, and publishes subsequent lifecycle events to the message broker. Additionally, a new UserStatusChanged event is defined to allow the email service to react to user status updates, supported by a set of specific application exceptions (e.g., EmailNotificationDisabledException) to enforce business rules during the notification process.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Application/Events · high confidence

Email service application layer scaffolding

The application layer for the Email service has been initialized with core infrastructure components. This includes a DI extension method to register command and event handlers along with in-memory dispatchers, interfaces for application and identity contexts to support request tracking and user identity, and a marker attribute for contracts. A solution file and a .gitignore for Visual Studio and build artifacts have also been added to support local development.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Application, MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application · high confidence

Event recommendation service and infrastructure wiring

The Events service now includes an event recommendation capability, introducing ML-based scoring via Microsoft.ML models (EventInputModel, EventPrediction) and the EventRecommendationService. This change also wires the full infrastructure layer: it registers repositories (Event, EventsUserViews, UserCommentsHistory, UserReactionsHistory) backed by MongoDB, adds service clients for Students, Friends, and Organizations, configures the message broker (RabbitMQ) with a MongoDB outbox, sets up distributed tracing (Jaeger), metrics, and Swagger, and subscribes command and event handlers for event lifecycle and social interactions.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure · high confidence

Exception handling infrastructure added for comments service

The Comments service now includes infrastructure components to map internal exceptions to standardized responses and messages. The new \ExceptionToResponseMapper\ translates domain and application exceptions into HTTP 400 responses with specific error codes and reasons, while the \ExceptionToMessageMapper\ provides a framework for mapping exceptions to message broker events (currently returning null for all cases). This establishes the error-handling contract for the service's API and messaging layers.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Exceptions · high confidence

Expanded event details and user profile data in API responses

The Events service now returns richer data in its DTOs. EventDto includes per-user status flags (IsSignedUp, IsInterested), the user's specific rating, and lists of friends who are interested in or signed up for the event, alongside full location and organizer details. New DTOs for user profiles (UserFromServiceDto) expose comprehensive personal information, including education, work history, and event participation lists. Additionally, pagination support (PageableDto, SortDto) and organization details (OrganizationDetailsDto) have been added to support browsing and organizational context.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/DTO · high confidence

Expanded organization management commands

The Organizations service application layer now includes a comprehensive set of new command definitions to support advanced organization features. Users can now initiate actions for creating and updating organizations (including sub-organizations) with detailed contact and settings information, managing organization roles and permissions, and handling member interactions such as inviting, assigning roles, leaving, and following organizations. Additionally, new commands allow organizations to manage privacy and visibility settings, accept or reject follow requests, and manage feed content.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application/Commands · high confidence

Friend request notifications now delivered via SignalR

The notification service now handles friend-related events (requests, invitations, acceptances, and declines) by creating persistent notification records and immediately pushing real-time alerts to users through SignalR. This ensures that students receive instant, in-app notifications for friend interactions without needing to refresh the page.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Friends · high confidence

Friends service infrastructure implementation

The Friends service now includes its complete infrastructure layer, introducing MongoDB-based persistence for friends, friend requests, and user relationships via new document models and repositories. This change adds query handlers to retrieve friends, followers, following lists, and sent/received friend requests with pagination support. It also implements an outbox pattern for reliable event publishing, context factories for correlation and identity tracking, and exception mappers to translate domain errors into standardized API responses and message broker events.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Infrastructure · high confidence

Identity service API exposes comprehensive authentication and account management endpoints

The MiniSpace Identity API now provides a full suite of endpoints for user lifecycle and security management. Users can sign up, sign in, and manage access tokens (refresh and revoke). Account security features include password recovery (forgot and reset), email verification, and two-factor authentication (generating secrets, enabling/disabling, and verifying codes). Administrators can ban or unban users and update user status. The service also exposes user profile details including role, permissions, and online status.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Api · high confidence

Identity service adds outbox pattern support and MongoDB index initialization

The Identity service infrastructure now includes OutboxCommandHandlerDecorator and OutboxEventHandlerDecorator to wrap command and event handlers, ensuring messages are persisted to an outbox before processing when enabled. Additionally, a new MongoDB extension method automatically creates a unique index on the UserDocument's Email field during application startup to enforce data integrity.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Decorators, MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Mongo · high confidence

Identity service application interfaces introduced

The application layer of the Identity service now exposes a set of new interfaces defining the core authentication and user management capabilities. These include IIdentityService for operations such as sign-in, sign-up, password reset, email verification, and two-factor authentication, alongside supporting services for JWT token creation, refresh tokens, password hashing, and IP address resolution. This establishes the contract for the identity logic used by the service.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/Services · high confidence

Identity service introduces comprehensive user management and authentication capabilities

The identity application layer now includes a full-featured IdentityService and RefreshTokenService, enabling users to sign up, sign in, and manage their accounts. Key capabilities include two-factor authentication support during sign-in, email verification token generation upon registration, and administrative functions to ban or unban users. The system also implements secure password reset flows (forgot/reset password) and manages JWT refresh tokens to maintain session continuity, with all significant state changes published as events via the message broker.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/Services/Identity · high confidence

Identity service solution structure added

The solution file for the MiniSpace Identity service has been introduced, defining the project structure with four core components: Application, Infrastructure, Api, and Core. This establishes the build configuration for the identity management functionality within the service.

MiniSpace.Services.Identity/src · high confidence

Infrastructure services for time, event mapping, and message publishing

The Comments service now includes concrete infrastructure implementations for core application interfaces. A DateTimeProvider supplies the current UTC time, an EventMapper provides the structure for converting domain events to integration events, and a MessageBroker handles publishing events via RabbitMQ with support for an outbox pattern, distributed tracing headers, and correlation context propagation.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Services · high confidence

Infrastructure services for time, event mapping, and messaging introduced

The infrastructure layer now includes concrete implementations for core application services: a DateTimeProvider that returns UTC time, an EventMapper skeleton for converting domain events to integration events, and a MessageBroker that publishes events via RabbitMQ with support for distributed tracing, correlation contexts, and an optional outbox pattern.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure/Services · high confidence

Initial API Gateway scaffolding with Ntrada routing and distributed tracing

The MiniSpace API Gateway is introduced as a new entry point for the platform, built on the Ntrada framework to route HTTP requests to downstream services like Identity and Reports. It establishes a request lifecycle that includes JWT authentication, CORS policies, and distributed tracing via OpenTracing (Jaeger), while injecting a Correlation-Context header into outgoing requests to propagate user and trace context across service boundaries.

MiniSpace.APIGateway/src · high confidence

Initial Web2 Blazor WASM client scaffolding with communication, comments, and events areas

This change introduces the initial structure for the MiniSpace Web2 Blazor WebAssembly client. It includes the core application setup (Dockerfile, solution, and entry point), along with the implementation of three main feature areas: Communication (real-time chat via SignalR and REST-based chat management), Comments (CRUD operations and likes), and Events (creation, search, registration, and settings). The entry also adds standard project infrastructure such as build/test scripts, licensing, and README documentation.

MiniSpace.Web2 · high confidence

Initial application layer scaffolding for the Comments service

This change introduces the foundational application layer for the Comments service, establishing the core infrastructure for command and event handling. It adds a \ContractAttribute\ for marking contracts, defines \IAppContext\ and \IIdentityContext\ interfaces to expose request metadata and user identity details (such as role, authentication status, and claims), and provides an \Extensions\ class to register the CQRS command/event handlers and in-memory dispatchers via the Paralax framework.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application, MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application · high confidence

Initial core domain model for organizations

This change introduces the foundational domain entities and domain events for the Organizations service. It adds the core \Organization\ aggregate, which supports hierarchical structures via parent/child relationships, and includes built-in role-based access control with default roles (Creator, Admin, Moderator, User) and granular permissions. The update also defines supporting entities for user memberships (\UserOrganizations\), gallery images, invitations, and organization request workflows (with states like Pending, Approved, Rejected), along with the necessary domain events to track changes to organization details, roles, and gallery content.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Core · high confidence

Initial core domain model for the Comments service

This change introduces the foundational domain entities for the Comments service, establishing the core data structures and business logic. It adds the Comment aggregate root, which supports creating, updating, deleting, and replying to comments, as well as liking and unliking them with validation to prevent duplicate likes. The model includes a Reply entity for nested comments and a CommentContext enum to distinguish between comments on user/organization posts and events. Supporting infrastructure includes an AggregateId value object for safe identity management and an AggregateRoot base class to handle domain events and versioning.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Core/Entities · high confidence

Initial implementation of event infrastructure services

The Events service now includes core infrastructure components to support event management and discovery. This introduces an EventRecommendationService that uses Microsoft ML.NET to rank events based on user interests, and an EventService that handles browsing events with support for filtering by date, category, state, organization, and friend engagement. Validation logic for event names, descriptions, dates, capacity, and media files is enforced via EventValidator. Additionally, a MessageBroker implementation enables reliable event publishing with outbox support and distributed tracing integration.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Services · high confidence

Initial infrastructure layer for the Comments service

The Comments service now includes its infrastructure implementation, establishing the foundation for runtime operation. This adds dependency injection registrations for MongoDB repositories (storing comments in collections such as 'comments' and 'organization\_events\_comments'), Redis, and RabbitMQ with Jaeger tracing. It wires up the CQRS pipeline with an outbox pattern for reliable message publishing, configures certificate-based authentication, and exposes Swagger documentation. Additionally, it introduces a client for the Students service to resolve user data and implements the application context factory required for database access.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure · high confidence

Initial project scaffolding and configuration for MiniSpace

This change introduces the foundational structure for the MiniSpace project, including a .gitignore file tailored for Visual Studio and .NET development, and an Apache 2.0 license file. It adds a Visual Studio solution file (MiniSpace.sln) that defines the project hierarchy, encompassing an API Gateway, multiple microservices (Customers, Deliveries, Identity, Orders, Parcels, Pricing, Vehicles, Availability, OrderMaker), and their respective Core, Application, Infrastructure, and API layers, along with associated test projects. Additionally, it provides a docker-images.txt file with configuration examples for required infrastructure services (RabbitMQ, MongoDB, SQL Server, PostgreSQL, InfluxDB, Redis, Consul, Vault, Grafana, Prometheus, Seq, Elasticsearch, Kibana, Logstash, Jaeger) and a prod-services.yml file for deploying the application services using PM2, specifying .NET 8.0 publish paths and environment URLs for components like the API Gateway, Identity Service, and Web interface.

MiniSpace · high confidence

Initial project scaffolding and new communication and comments services

The MiniSpace.Web project is introduced with foundational infrastructure including a Dockerfile for .NET 8 containerization, a solution file, and CI/CD build scripts. Functionally, the web application adds a new Comments area and a Communication area. The Comments service enables users to create, update, delete, and like comments, as well as search for root and sub-comments. The Communication service provides REST APIs for managing chats (creating, deleting, adding/removing users) and messages (sending, updating status, deleting), while the ChatSignalRService implements real-time chat capabilities with automatic reconnection and typing notifications.

MiniSpace.Web · high confidence

Initial project scaffolding for Comments service

The MiniSpace.Services.Comments location is initialized with the foundational project structure, including a .NET 8.0 Dockerfile for containerized deployment, an Apache 2.0 license, and a Visual Studio solution file defining the API, Application, Core, Infrastructure, and corresponding unit test projects.

MiniSpace.Services.Comments · high confidence

Initial project scaffolding for MiniSpace.Services.Notifications

This change introduces the foundational structure for the Notifications service, including a .gitignore file, an Apache 2.0 license, and a Visual Studio solution file. It also adds a Dockerfile for containerization using .NET 8.0 and a set of shell scripts to streamline local development and CI/CD workflows (build, test, start, and dockerize-tag-push).

MiniSpace.Services.Notifications · high confidence

Initial project structure and Docker support for Events Service

The MiniSpace.Services.Events location now includes the foundational project scaffolding, including a Visual Studio solution file defining the API, Application, Core, and Infrastructure layers along with their respective unit tests. A Dockerfile has been added to enable containerized deployment using .NET 8.0, and standard repository configuration files like .gitignore and the Apache 2.0 LICENSE have been established to support development and distribution workflows.

MiniSpace.Services.Events · high confidence

Initial project structure and build infrastructure for Organizations service

The Organizations service is introduced with a standard .NET solution structure, including API, Application, Core, and Infrastructure projects, alongside corresponding unit test projects. To support deployment and local development, the service includes a Dockerfile targeting .NET 8.0, a .gitignore file, and shell scripts for building, testing, and running the service locally or via Docker.

MiniSpace.Services.Organizations · high confidence

Initial project structure and configuration for Media Files service

The MiniSpace.Services.MediaFiles module is introduced with a standard .NET solution structure containing API, Application, Core, and Infrastructure projects. This includes an AWS configuration model (AwsOptions) for storage integration, a Dockerfile for containerized deployment using .NET 8.0, and standard repository metadata such as .gitignore and Apache 2.0 license files.

MiniSpace.Services.MediaFiles · high confidence

Initial release of MiniSpace Identity microservice

The MiniSpace Identity service is now available, providing user authentication capabilities including sign-up, sign-in, and token management (access and refresh tokens). The service is containerized via a Dockerfile using .NET 8.0 and exposes an API documented in a .rest file for endpoints like /sign-up, /sign-in, /me, and token operations. The project structure includes API, Core, Application, and Infrastructure layers, along with corresponding unit test projects, and is licensed under Apache 2.0.

MiniSpace.Services.Identity · high confidence

Initial release of the Media Files API service

The Media Files service is now available as a standalone API, providing endpoints for uploading media files, retrieving media files by ID, retrieving the original version of a media file, and deleting media files. The service is built on the Paralax framework and exposes routes for POST requests to upload files and DELETE requests to remove them, along with GET endpoints for fetching file data.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Api · high confidence

Initial release of the MiniSpace API Gateway

This change introduces the MiniSpace API Gateway, a new .NET 8.0 service that acts as the entry point for the microinfrastructure. It is now containerized via a Dockerfile and includes configuration for running on port 80. To support development and testing, the release includes a sample REST scenario file demonstrating the full workflow (identity, customers, parcels, orders, vehicles, availability, and deliveries) and a comprehensive reference file listing all available API endpoints.

MiniSpace.APIGateway, MiniSpace.APIGateway.Ocelot · high confidence

Initial release of the Notifications API with SignalR support

The Notifications API service is introduced, providing endpoints to manage student notifications including creating, updating status, retrieving by user, and deleting notifications. The service is built on the Paralax framework and integrates SignalR to support real-time communication via NotificationHub and ChatHub, enabling live updates for events such as friend requests. The API also includes CORS configuration and standard authentication/authorization middleware.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Api · high confidence

Initial release of the Posts service API

The MiniSpace.Services.Posts service is now available, providing a REST API for managing social posts. Users can create, update, delete, and repost posts, as well as change post states (e.g., draft, published, reported). The service exposes endpoints for searching posts, retrieving user feeds, and tracking post views. It is built on the .NET 8.0 framework and deployed via Docker.

MiniSpace.Services.Posts · high confidence

Initial release of the Reports service

The MiniSpace.Services.Reports service is introduced, providing a new capability for users to create, manage, and review reports. The service exposes an API for creating reports, searching them with pagination, and performing administrative actions such as starting a review, resolving, rejecting, or deleting reports. It also allows students to view their own active reports. The implementation follows a CQRS pattern with command handlers for state changes and publishes domain events (e.g., ReportCreated, ReportCancelled) to a message broker, while also listening for external events like CommentCreated and EventCreated to maintain consistency with other system components.

(repo-wide) · high confidence

Initial release of the Students service with student management and gRPC API

The Students service is now available, providing a comprehensive set of capabilities for managing student profiles and interactions. Users can complete registration, update personal details (including education, work, languages, and interests), manage visibility settings, and handle account states (valid, banned, unverified, incomplete). The service introduces user blocking and unblocking features, profile view tracking, and notification preferences. Access is provided via REST endpoints for standard CRUD operations and state changes, as well as a new gRPC interface for efficient retrieval of student data and paginated lists. The implementation follows a CQRS pattern with domain-driven design, ensuring robust event handling for actions like student deletion and state changes.

MiniSpace.Services.Students · high confidence

Initial repository setup with documentation, CI/CD, and deployment scripts

The repository has been initialized with essential project infrastructure files. This includes a comprehensive .gitignore for Visual Studio and .NET artifacts, a GitLab CI/CD pipeline (.gitlab-ci.yml) that builds and deploys multiple microservices (API Gateway, Web, Identity, Events, etc.) via Docker, and a deployment script (deploy.sh) for production updates. Additionally, standard open-source governance documents have been added: a Code of Conduct, Contributing guidelines, a Security policy, and an Apache 2.0 License. The README.md has been updated to describe MiniSpace as a student life activity app built on .NET 8, Blazor, and microservices, replacing the previous placeholder content.

(repo-wide) · high confidence

Introduce DTOs for Organizations and Posts in the Notifications service

Added new Data Transfer Objects to support organization and post data structures within the notifications application layer. This includes OrganizationDto, OrganizationRoleDto, OrganizationSettingsDto, OrganizationUserDto, and OrganizationUsersDto to represent organization details, roles, settings, and user memberships, as well as PostDto to represent post content, metadata, and visibility.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Dto/Organizations, MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Dto/Posts · high confidence

Introduce MongoDB document models and mapping extensions for the Events service

This change adds the foundational persistence layer for the Events service by introducing a set of new MongoDB document classes (AddressDocument, CommentDocument, EventDocument, EventSettingsDocument, OrganizerDocument, ParticipantDocument, RatingDocument, ReactionDocument, UserCommentsDocument, UserEventsViewsDocument, UserReactionDocument, and ViewDocument) along with corresponding extension methods for mapping between domain entities and DTOs. These documents define the schema for storing event details, participant interactions (sign-ups, interests, ratings, comments, reactions), and user view history, enabling the service to persist and retrieve event data from MongoDB.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Mongo/Documents · high confidence

Introduce MongoDB repository implementations for events and user activity history

This change adds the MongoDB persistence layer for the Events service, introducing concrete repository classes that implement the core data access interfaces. EventMongoRepository provides methods to retrieve, browse, and manage events with support for pagination, filtering by state, category, organizer, and friends, as well as sorting. EventsUserViewsRepository handles tracking user event views. Additionally, UserCommentsHistoryMongoRepository and UserReactionsHistoryMongoRepository are added to persist and retrieve user comment and reaction histories, including paged retrieval and deletion capabilities. These repositories utilize MongoDB's aggregation pipeline for efficient paginated queries and upsert operations for history records.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Mongo/Repositories · high confidence

Introduce Organizations API with REST and gRPC endpoints

The Organizations service now exposes a new API layer that allows users to manage organizations via both HTTP and gRPC. The REST endpoints support creating organizations and sub-organizations, managing roles, handling follow/leave requests, and deleting organizations, while also providing read access to organization details, root/child hierarchies, user-specific lists, and paginated views. Additionally, a gRPC service is introduced to retrieve organization details, root organizations, and child organization lists, enabling efficient programmatic access to organizational data.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Api · high confidence

Introduce comprehensive DTOs for organization data transfer

The application layer now exposes a complete set of Data Transfer Objects (DTOs) to structure organization-related data for consumers. This includes \OrganizationDto\ and \OrganizationDetailsDto\ for basic and detailed organization information (including new contact fields like address and email), \OrganizationSettingsDto\ for granular permission controls, and \OrganizationRequestDto\/\OrganizationRequestsDto\ to expose join requests. Supporting structures such as \UserDto\, \RoleDto\, \SubOrganizationDto\, \InvitationDto\, and \GalleryImageDto\ are also introduced to map nested entities, while \PagedResult\<T\>\ provides a standard wrapper for paginated responses.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application/Dto · high confidence

Introduce core domain entities and exception handling for the Events service

This change establishes the foundational domain model for the Events service by adding core entity classes such as Event, Organizer, Participant, Rating, and Address, along with supporting enums like Category, State, and Visibility. It also introduces a comprehensive set of domain-specific exceptions (e.g., EventCapacityExceededException, StudentAlreadySignedUpException) to enforce business rules and handle validation errors within the event lifecycle.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Core/Entities · high confidence

Introduce core domain entities for the Friends service

The Friends service now includes its foundational domain model, introducing entities such as Friend, FriendRequest, User, and their respective collections (UserFriends, UserRequests) to manage friendship states and requests. These classes implement the AggregateRoot pattern with support for domain events, enabling the tracking of lifecycle changes like inviting, accepting, declining, and removing friends.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Core/Entities · high confidence

Introduce domain model and DDD foundations for the Media Files service

The Media Files service now implements a Domain-Driven Design structure with new core entities and infrastructure. Users benefit from a robust \AggregateId\ value object for entity identification and an \AggregateRoot\ base class that tracks domain events and versioning. The domain model includes a \FileSourceInfo\ entity to manage media uploads with specific context types (such as student profiles, organization banners, and event galleries), tracking uploader identity, file metadata, and association states. A \ContextType\ enum and \State\ enum define the specific scopes and lifecycle stages of media files, providing a structured way to handle diverse media sources within the platform.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Core/Entities · high confidence

Introduce identity application layer scaffolding

The identity service now includes a new Application project that defines the core domain interfaces and service registration. This adds the IIdentityContext interface to expose user details (ID, role, name, email, authentication status, admin/banned flags, and claims) and the IAppContext interface for request-scoped identity access. It also provides an Extensions class to register command and event handlers with in-memory dispatchers via the Paralax framework, and introduces a ContractAttribute for potential future contract-based validation.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application · high confidence

Introduce new Communication service for real-time chat

The MiniSpace platform now includes a dedicated Communication service that enables real-time chat capabilities. This service exposes REST endpoints for managing chat rooms (creating, deleting, adding/removing users) and messages (sending, updating status, deleting), while utilizing SignalR to push live updates to clients. The implementation follows a CQRS pattern, handling commands like sending messages or updating status through specific handlers that interact with the underlying repository and message broker.

MiniSpace.Services.Communication · high confidence

Introduces Application layer scaffolding with DI extensions and core interfaces

The Organizations service now includes a new Application project that establishes the foundational structure for command/event handling and service abstractions. Users benefit from a standardized dependency injection setup via the new \Extensions\ class, which registers command/event handlers and in-memory dispatchers from the Paralax framework. The layer also defines core interfaces for application context (\IAppContext\, \IIdentityContext\) to manage request identity and authentication state, as well as service contracts for time (\IDateTimeProvider\), messaging (\IMessageBroker\), and event mapping (\IEventMapper\) to decouple application logic from infrastructure details.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application · high confidence

Introduces MongoDB document models and mapping extensions for identity data

This change adds the MongoDB document classes (UserDocument, RefreshTokenDocument, UserResetTokenDocument) and the corresponding extension methods that map these documents to domain entities and DTOs. This establishes the persistence layer for user profiles, authentication refresh tokens, and password reset tokens within the Identity service's MongoDB storage.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Mongo/Documents · high confidence

Introduction of CQRS command models for comment and like operations

The Comments application layer now exposes explicit CQRS command classes to handle user interactions. New commands include CreateComment, UpdateComment, and DeleteComment for managing comment content and lifecycle, as well as AddLike and DeleteLike for managing user likes. These commands define the specific data contracts (such as CommentId, ContextId, and CommentContext) required to execute these actions within the service.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Commands · high confidence

Introduction of Friends Service Data Transfer Objects

The Friends service application layer now exposes a set of Data Transfer Objects (DTOs) to structure data exchange. These include FriendDto and FriendRequestDto for managing individual connections and pending requests, UserDto for comprehensive user profiles (including event interests and ban status), and container DTOs (UserFriendsDto, UserRequestsDto, FriendEventsDto) to aggregate related data. This change establishes the contract for how friend-related information is serialized and returned to clients.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application/Dto · high confidence

Introduction of application-layer DTOs for the notification service

The notification service now exposes a comprehensive set of Data Transfer Objects (DTOs) within its application layer to support various domain features. These include \NotificationDto\ and \StudentNotificationsDto\ for managing user notifications, \FriendDto\, \FriendRequestDto\, and \FriendEventDto\ to handle social connections and friend-related events, \EventParticipantsDto\ and \ParticipantDto\ for tracking event attendance, \ReactionDto\ for content interactions, \ReportDto\ for moderation workflows, \AddressDto\ for location data, and \StudentDto\ (mapped to \UserDto\) for detailed student profiles. These structures define the contract for data exchange between the service's application logic and external consumers or internal handlers.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Dto · high confidence

Introduction of application-layer service interfaces

The Friends service application layer now exposes four new interfaces to support internal architecture and external integrations: IStudentsServiceClient for retrieving user data, IDateTimeProvider for time abstraction, IEventMapper for converting domain events to application events, and IMessageBroker for publishing events. These interfaces define the contracts for core service dependencies within the application layer.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application/Services · high confidence

Introduction of application-layer service interfaces for media file handling

The media files service now exposes a set of new application interfaces that define the contract for core capabilities: uploading and downloading files via S3 or GridFS, validating file size and extensions, mapping domain events, publishing messages, and providing time. These interfaces establish the abstraction layer for storage backends and validation logic, enabling the service to support flexible storage strategies and consistent event-driven behavior.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Services · high confidence

Introduction of core application service interfaces for the Events domain

The Events application layer now exposes a set of new service contracts that define its core capabilities. Users can now browse events and organizer-specific events via the IEventService, while IEventValidator enforces strict rules on event names, descriptions, dates, capacity, fees, and media files. The system also introduces IEventRecommendationService to rank events based on user interests, IMessageBroker for publishing domain events, IEventMapper for translating domain events, and IDateTimeProvider to abstract time-dependent logic.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Services · high confidence

Introduction of domain event models for notification lifecycle

The notification service now exposes specific domain events to track the lifecycle of notifications. New classes have been added to represent \NotificationCreated\, \NotificationDeleted\, and \NotificationUpdated\ scenarios, all implementing the \IDomainEvent\ interface. These events carry relevant context such as user IDs, notification IDs, status changes, and message details, enabling downstream consumers to react to specific notification state changes.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Core/Events · high confidence

Introduction of email domain events

The email service now exposes specific domain events for the lifecycle of email notifications, including creation, sending, updates, and deletion. These events (EmailSent, EmailUpdated, EmailDeleted, and NotificationCreated) implement the new IDomainEvent interface, enabling external systems to react to these state changes.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Core/Events · high confidence

Introduction of rejected event types for notification lifecycle operations

The notification service application layer now includes specific domain events to signal when notification creation, deletion, processing, or update operations are rejected. These new classes—NotificationCreationRejected, NotificationDeletionRejected, NotificationProcessRejected, and NotificationUpdateRejected—implement the IRejectedEvent interface and carry the notification ID, a reason, and a code, enabling consumers to handle and react to failed notification operations.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/Rejected · high confidence

Introduction of specialized comment repository interfaces

The core comments service now defines distinct repository interfaces for managing comments on user posts, user events, organization posts, and organization events, alongside a general comment repository. These interfaces establish the contract for retrieving, adding, updating, and deleting comments, as well as browsing comments with pagination support, enabling the service to handle comment data specific to different content owners and types.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Core/Repositories · high confidence

Media Files Infrastructure: Outbox, Context, and Cleanup Worker

The Media Files service infrastructure now supports reliable message delivery via Outbox decorators for commands and events, ensuring that operations are persisted before being published. It introduces a structured application context (AppContext) and factory to propagate user identity and correlation data across request boundaries. Additionally, a background FileCleanupWorker is implemented to periodically dispatch commands that remove unassociated media files, helping to manage storage usage.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Infrastructure · high confidence

Media file deletion and cleanup logic implemented

The Media Files service now supports deleting individual media assets and cleaning up orphaned files. The new DeleteMediaFileHandler allows users to remove specific files by URL, enforcing access control to ensure only the uploader or an organization admin can delete the asset, while also removing both the original and processed versions from S3 and publishing a deletion event. Additionally, a new CleanupUnassociatedFilesHandler background process automatically removes files that have been unassociated for more than one day, ensuring storage hygiene.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Commands/Handlers · high confidence

Media files service infrastructure implementation

The Media Files service infrastructure now provides the core capabilities for handling media uploads, including file validation, storage, and event publishing. File uploads are validated against a 5 MB size limit and supported MIME types (JPEG, PNG, GIF, TIFF, WebP, ICO, PDF, ZIP, MP4, WebM, MPEG) using magic-byte detection. Uploaded images are automatically resized to a maximum of 1024x1024 pixels and converted to WebP format (50% quality) for optimized storage, while original files are preserved. Files are stored in an S3 bucket named 'minispace-data-files', with images saved in 'images' and 'webps' folders, and other files in 'files'. The service supports uploading media for student profiles, banners, galleries, organization profiles, banners, and events, and publishes corresponding domain events (e.g., StudentImageUploaded, OrganizationImageUploaded) via a message broker with outbox support for reliability. A generic file upload endpoint is also available for non-image files.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Infrastructure/Services · high confidence

MongoDB document models and mapping extensions for notifications

The notification service now persists data using new MongoDB document structures: NotificationDocument, FriendEventDocument, and UserNotificationsDocument. To support this storage layer, a new Extensions class provides mapping methods that convert between these documents, core domain entities (Notification, FriendEvent, UserNotifications), and application DTOs (NotificationDto, FriendEventDto). This enables the service to store individual notifications, friend-related event triggers, and aggregated user notification lists in MongoDB.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Documents, MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Mongo/Documents · high confidence

MongoDB persistence layer for identity tokens and user data

The identity service now stores refresh tokens, user reset tokens, and user profiles in MongoDB via new repository implementations. This enables core authentication flows such as password reset and token validation, allowing users to securely manage their sessions and recover access to their accounts.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Mongo/Repositories · high confidence

MongoDB persistence layer for organizations, members, roles, and galleries

The Organizations service now uses MongoDB to persist organization data, replacing previous storage mechanisms. This change introduces a comprehensive set of repository implementations—including OrganizationMongoRepository, OrganizationMembersMongoRepository, OrganizationRolesMongoRepository, OrganizationGalleryMongoRepository, OrganizationRequestsMongoRepository, UserInvitationsMongoRepository, and UserOrganizationsMongoRepository—that handle CRUD operations for organizations, their hierarchical sub-organizations, members, roles, gallery images, requests, and invitations. Users benefit from the ability to manage complex organization structures, including recursive lookups for sub-organizations, member management, role-based access control, and media gallery updates, all backed by a consistent MongoDB document model.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure/Mongo/Repositories · high confidence

New DTOs for email notifications and student data

The email service application layer now includes three new Data Transfer Objects: EmailNotificationDto, which carries details for individual email messages; StudentDto, representing student profile information including notification preferences and event interests; and StudentEmailsDto, a container for managing a list of email notifications associated with a specific student.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Application/Dto · high confidence

New DTOs for media file details and upload responses

The application layer now exposes dedicated Data Transfer Objects to support media file operations. FileDto provides detailed metadata for media items, including the uploader ID, creation timestamp, processing state, and base64-encoded content. Two new response types, FileUploadResponseDto and GeneralFileUploadResponseDto, standardize the data returned after uploads, with the former distinguishing between original and processed URLs and the latter providing a single file URL for general uploads.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Dto · high confidence

New Docker Compose infrastructure and service definitions for MiniSpace

This change introduces a comprehensive set of Docker Compose files and supporting configurations to define the MiniSpace application's runtime environment. It adds specific compose profiles for infrastructure services (consul, fabio, vault, grafana, prometheus, jaeger, seq, mongo, rabbitmq, redis) and application services (api-gateway, identity-service, students-service, events-service, etc.), distinguishing between local development builds and production images pulled from a registry. Additionally, it includes Prometheus scrape configurations for monitoring all services and custom Dockerfiles for Prometheus and RabbitMQ (with management and prometheus plugins enabled).

MiniSpace/compose · high confidence

New MongoDB query handlers for event details, participants, ratings, and feeds

The Events service now includes a set of new MongoDB query handlers that implement the backend logic for retrieving specific event data. Users can now fetch detailed event information, view event ratings and participant lists, and access paginated event feeds. The implementation also supports retrieving a user's specific events (signed up or interested) and a personalized event feed that integrates with a recommendation service to rank events by user interest. Additionally, search functionality has been updated to support filtering by category, state, and friend engagement types.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Mongo/Queries · high confidence

New MongoDB query handlers for organization hierarchy and details

The Organizations service now includes a comprehensive set of new MongoDB query handlers to support advanced organization browsing and detail retrieval. Users can now fetch paginated lists of organizations with search filtering, retrieve root and all child organizations recursively, and view detailed organization profiles that aggregate gallery images, user members, and roles. Additionally, new endpoints allow users to query their own organizations, followed organizations, and specific organization requests, providing a richer data view for the organization management interface.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure/Mongo/Queries · high confidence

New application-level domain events for organization lifecycle and membership

The Organizations application layer now exposes a comprehensive set of new domain events to signal key state changes. These include \OrganizationCreated\, \RootOrganizationCreated\, and \OrganizationUpserted\ to track creation and updates; \OrganizationDeleted\ and \OrganizationSettingsUpdated\ for deletion and configuration changes; and a suite of membership events (\UserAddedToOrganization\, \UserInvitedToOrganization\, \UserRemovedFromOrganization\, \OrganizerAddedToOrganization\, and \RoleAssignedToMember\) to capture all user interactions, role assignments, and organizer additions within an organization.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application/Events · high confidence

New authentication and identity infrastructure services

The identity service now includes a new set of infrastructure components for handling authentication and security operations. This introduces JWT token generation (including specific reset tokens), password hashing and validation, cryptographically secure random number generation, and verification token management. Additionally, it adds support for Two-Factor Authentication (2FA) by implementing services to generate 2FA secret tokens and validate TOTP codes, enabling users to secure their accounts with time-based one-time passwords.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Auth · high confidence

New command models for friend request lifecycle

The Friends service application layer now includes specific command models to manage the full lifecycle of friend interactions. Users can now initiate invitations (InviteFriend), accept or decline pending requests (PendingFriendAccept, PendingFriendDecline), withdraw sent requests (SentFriendRequestWithdraw), and remove existing friends (RemoveFriend). These commands provide the structured input contracts required for the service's internal handlers to process these social actions.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application/Commands · high confidence

New command models for notification management

The application layer now exposes distinct command objects to handle creating, deleting, and updating the status of notifications. Users can now trigger these specific actions through the defined command structures, which include necessary identifiers such as user ID, notification ID, and relevant context data like event or post IDs for creation.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Commands · high confidence

New commands for media file upload, deletion, and cleanup

The media files service now exposes distinct commands to manage the full lifecycle of media assets. Users can upload files via \UploadFile\ (supporting generic file types with source context like events or posts) or \UploadMediaFile\ (optimized for media-specific metadata). Deletion is handled by a new \DeleteMediaFile\ command that targets files by URL, and a \CleanupUnassociatedFiles\ command has been added to support background jobs that remove orphaned blobs, ensuring storage hygiene.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Commands · high confidence

New context infrastructure for identity and correlation data

The identity service now includes a new set of internal context classes (AppContext, IdentityContext, CorrelationContext) and a factory (AppContextFactory) to manage request-scoped identity and correlation data. This allows the service to consistently extract user identity details (ID, role, email, claims) and correlation metadata from HTTP or message broker contexts, providing a unified way to access authentication state and request tracing information throughout the application.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Contexts · high confidence

New development and deployment automation scripts for MiniSpace services

Added three new shell scripts to streamline local development and Docker operations. \start\_all\_services.sh\ launches all backend services (API Gateway, Identity, Events, etc.) in separate terminal tabs using the system's default terminal emulator. \load\_dev\_settings.sh\ automates the retrieval of development \appsettings\ files from a remote Git repository and copies them into the respective service directories. \dockerize-all.sh\ iterates through all service directories to execute their individual \dockerize-tag-push.sh\ scripts, facilitating batch Docker image tagging and pushing.

MiniSpace/scripts · high confidence

New event interaction and management capabilities

The Events service now supports a comprehensive set of user interactions and administrative actions. Users can sign up for events, express interest, rate events, and cancel these actions (sign-up, interest, and ratings). Event organizers and administrators can create, update, and delete events, as well as manage participant lists by adding or removing participants. Additionally, the service tracks event views for users and includes a background process to automatically update event states based on time.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Commands/Handlers · high confidence

New event interaction and management commands

The Events application now exposes a comprehensive set of new commands to support full event lifecycle management and user engagement. Users can now create, update, and delete events, as well as search for events using filters like state, category, and organization. Additionally, students can sign up for events, express interest, rate events, and cancel their participation or ratings. The system also tracks event views and allows organizers to manage their specific event listings.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Commands · high confidence

New event query endpoints for retrieval, search, and feeds

The application layer now exposes a suite of new query handlers to retrieve event data. Users can fetch individual events, view event participants, and check event ratings. The service also supports paginated listing of all events, filtering events by organizer, and viewing a user's specific event feed with sorting options. Additionally, a comprehensive search capability allows filtering events by name, organizer, organization, category, state, date range, and friend engagement, while a separate query retrieves events associated with a specific user.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Queries · high confidence

New external event handlers for comments, reactions, and media

Added new external event handlers to process incoming events: CommentCreatedHandler persists comment history, ReactionCreatedHandler records user reactions, EventImageUploadedHandler updates event banners and galleries, and MediaFileDeletedHandler removes media from events. These handlers enable the service to react to external comment, reaction, and media lifecycle events.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Events/External/Handlers · high confidence

New external service client interfaces for notifications

The notifications service now includes client interfaces for interacting with several other domain services, enabling it to fetch contextual data for notifications. New interfaces added are ICommentsServiceClient, IEventsServiceClient, IFriendsServiceClient, IOrganizationsServiceClient, IPostsServiceClient, IReactionsServiceClient, IReportsServiceClient, and IStudentsServiceClient. These interfaces define methods to retrieve specific entities (e.g., comments, event participants, friends, posts, reactions, reports, users) which are likely used by notification handlers to enrich notification content or determine recipients.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Services/Clients · high confidence

New friend request lifecycle handlers for inviting, accepting, declining, withdrawing, and removing friends

The application layer now includes dedicated command handlers to manage the complete friend request workflow. Users can send invitations (InviteFriendHandler), accept pending requests (PendingFriendAcceptHandler), decline requests (PendingFriendDeclineHandler), withdraw sent requests (SentFriendRequestWithdrawHandler), and remove existing friends (RemoveFriendHandler). Each handler validates the current state, updates the underlying repositories, and publishes the corresponding domain event to the message broker to notify other services.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application/Commands/Handlers · high confidence

New identity commands for authentication, security, and user management

The identity service now exposes a comprehensive set of new application commands to support enhanced user lifecycle and security features. Users can now initiate password recovery flows via ForgotPassword and ResetPassword commands, and manage account security through EnableTwoFactor, GenerateTwoFactorSecret, DisableTwoFactor, and VerifyTwoFactorCode. Authentication capabilities have been expanded with SignIn (including device type tracking), UseRefreshToken, and token revocation (RevokeAccessToken, RevokeRefreshToken). Additionally, administrative and status management is supported via BanUser, UnbanUser, UpdateUserStatus, and VerifyEmail commands, alongside the existing SignUp command which now explicitly handles user roles and permissions.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/Commands · high confidence

New identity domain events for authentication, authorization, and security

The Identity service now publishes a comprehensive set of domain events to track user lifecycle and security actions. These include events for account creation (SignedUp), login/logout (SignedIn, SignedOut), and session management (TokenRefreshed, UserStatusChanged). Security-related events cover two-factor authentication (TwoFactorAuthenticationEnabled, TwoFactorAuthenticationDisabled, TwoFactorCodeGenerated) and email verification (EmailVerified). Authorization changes are tracked via OrganizerRightsGranted and OrganizerRightsRevoked, while account status changes are signaled by UserBanned and UserUnbanned. Additionally, password reset flows are supported by PasswordResetTokenGenerated and PasswordReset events. Rejection events (e.g., SignInRejected, EnableTwoFactorRejected) are also introduced to handle failed operations.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/Events · high confidence

New identity service DTOs for authentication, user profiles, and password resets

The identity service now exposes dedicated Data Transfer Objects to support enhanced authentication and user management capabilities. AuthDto provides detailed session information including access/refresh tokens, role, expiration, two-factor status, and device context (IP, device type). UserDto exposes comprehensive user profile data, including email verification status, two-factor secret, online status, and permissions. UserResetTokenDto supports the new forgot/reset password workflow by exposing reset token details. These DTOs enable the service to handle 2FA, email verification, and password reset flows with richer context.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/DTO · high confidence

New notification handlers for identity and report events

The notification service now processes external identity and report events to generate in-app notifications. For identity events, it handles user sign-ups (sending a welcome email with a verification link), email verification, password reset requests (sending a reset link), and two-factor authentication code generation. For report events, it notifies both the issuer and the target content owner about report creation, cancellation, deletion, rejection, and resolution, as well as notifying the issuer when a review starts. These handlers persist the notifications to the user's notification history and publish events to the message broker, with some report handlers also broadcasting via SignalR.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Identity, MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Reports · high confidence

New organization management capabilities: roles, sub-organizations, and follow requests

The Organizations service now supports a comprehensive set of new commands and handlers for managing organizational structures and memberships. Users can create and update organizations (including sub-organizations), define custom roles with specific permissions, and assign these roles to members. The service also introduces a follow mechanism where users can request to follow private organizations (pending approval) or join public ones directly, with handlers to accept or reject these requests. Additionally, administrators can invite users, leave organizations, delete sub-organizations, and update organization settings and details, with all actions properly validating user permissions and publishing relevant domain events.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application/Commands/Handlers · high confidence

New organization query endpoints for hierarchical, user-specific, and paginated data retrieval

The Organizations application layer now exposes a comprehensive set of new query interfaces to support advanced organization browsing and management. Users can retrieve root and child organizations (including all descendants), fetch paginated lists of organizations with search capabilities, and access user-specific views such as organizations created by, followed by, or associated with a specific user. Additionally, new endpoints allow fetching detailed organization information, associated roles, gallery data, and paginated organization requests, enabling richer data presentation in the UI.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application/Queries · high confidence

New query models for retrieving email notifications

The application layer now includes query definitions for fetching email notifications, supporting both single-notification retrieval by user and ID, and paginated, sortable lists of notifications filtered by date range and status. This introduces the necessary CQRS query structures to enable these read operations.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Application/Queries · high confidence

New repository interfaces for event browsing, user views, and interaction history

The core service layer now exposes dedicated repository interfaces to support advanced event discovery and user activity tracking. IEventRepository defines methods for browsing events with granular filtering by state, category, organization, and friend engagement, as well as specific views for organizers and students. IEventsUserViewsRepository manages aggregated event views per user, while IUserCommentsHistoryRepository and IUserReactionsHistoryRepository provide CRUD operations and paged retrieval for user comments and reactions, establishing the data access contracts for these new capabilities.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Core/Repositories · high confidence

New repository interfaces for notifications, friends, and user notifications

The core repository layer now exposes three new interfaces: INotificationRepository for basic notification CRUD, IFriendEventRepository for friend event management, and IUserNotificationsRepository for user-specific notification operations including status updates and existence checks. These interfaces define the contract for data access in the notifications service.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Core/Repositories · high confidence

New repository interfaces for the Friends service core

The Friends service core now exposes a set of new repository interfaces to manage social graph data. These include IFriendRepository for core friendship operations (adding, removing, inviting, accepting/declining), IFriendRequestRepository for managing pending requests, IUserFriendsRepository for user-specific friend lists, IUserRequestsRepository for user-specific request lists, and IUserRepository for basic user entity persistence. These interfaces define the data access contract for the service's domain entities.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Core/Repositories · high confidence

New service clients for external domain services

The Notifications service now includes infrastructure clients to communicate with the Comments, Events, Friends, Posts, Reactions, Reports, and Students services. These new HTTP clients enable the notification system to fetch data from these external domains, supporting features such as retrieving event participants, friend requests, post details, and user information to enrich notification content.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Services/Clients · high confidence

Notification cleanup and infrastructure services introduced

The notifications service now includes several new background and infrastructure components to manage notification lifecycle and external communication. A new BaseUrlService provides environment-aware base URLs for the application. Event mapping logic has been added to translate internal domain events into external integration events. Message publishing is now handled via a MessageBroker that supports RabbitMQ, distributed tracing, and an outbox pattern for reliable delivery. Additionally, multiple background services have been implemented to automatically clean up user notifications: a daily service removes read notifications, while periodic services (running every 10 minutes) prune old notifications or clear all notifications for students exceeding specific count thresholds (200 or 300). A DateTimeProvider abstraction is also introduced to support time-based operations.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Services · high confidence

Notification management commands implemented

The notification service now supports creating, deleting, and updating the status of notifications. The CreateNotificationHandler generates detailed notification messages for event invitations, post comments, and organization updates by fetching details from external services, while also publishing a NotificationCreated event. The DeleteNotificationHandler removes a specific notification for a user and publishes a NotificationDeleted event. The UpdateNotificationStatusHandler allows changing a notification's status (e.g., to read/unread) after validating its existence.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Commands/Handlers · high confidence

Notification service application layer scaffolding

The application layer for the Notification service has been initialized with core infrastructure files. This includes a solution file for the project, a .gitignore configuration, and foundational interfaces for application context (IAppContext) and identity context (IIdentityContext) to support request tracking and user identity. Additionally, extension methods are provided to register command and event handlers along with in-memory dispatchers, establishing the basic CQRS execution pipeline for the service.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application · high confidence

Notification support for comment activity and likes

The Notifications service now processes external events for comment creation, updates, and likes. When a comment is created, the system identifies the content owner (user or organization) based on the context (post or event) and notifies them of the new comment. Comment updates trigger notifications to both the author and the event organizer. Additionally, when a comment is liked, the original author receives a notification. All these events are persisted to the user's notification history and broadcast in real-time via SignalR.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Comments · high confidence

Notification support for new content reactions

The notification service now processes the new ReactionCreated event, ensuring users are alerted when their content receives a reaction. This includes notifying the original creator of posts or events, as well as broadcasting updates to friends, followers, and organization members depending on the target type. The implementation introduces the ReactionCreated event definition and its corresponding handler to manage these real-time notifications via SignalR.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Reactions · high confidence

Notifications for new and updated posts

The notification service now sends real-time alerts when a post is created or modified. For user-authored posts, notifications are delivered to the author's friends and followers; for organization-authored posts, they are delivered to all organization members. These notifications are persisted in the database and broadcast instantly via SignalR to keep users informed of activity in their network or groups.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Posts/Handlers · high confidence

Notifications service infrastructure initialization

The Notifications service infrastructure layer has been established, introducing core application context handling via AppContext and AppContextFactory to propagate user identity and correlation data across message brokers and HTTP requests. The service now registers a comprehensive set of external event subscriptions (including student sign-ups, friend requests, posts, comments, reactions, and reports) and integrates clients for the Friends, Students, Events, Posts, Comments, Reactions, and Reports services to support cross-service notifications. Infrastructure also includes MongoDB and Redis persistence, RabbitMQ with Jaeger tracing, SignalR support, and hosted services for periodic notification cleanup.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Infrastructure, MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure, MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure · high confidence

Outbox pattern integration for command and event handlers

The Organizations service infrastructure now wraps command and event handlers with outbox decorators to ensure reliable message delivery. This change introduces \OutboxCommandHandlerDecorator\ and \OutboxEventHandlerDecorator\, which intercept handler execution to persist messages to an outbox before processing, controlled by \OutboxOptions\. The \Extensions\ class registers these decorators via dependency injection and configures the MongoDB-based outbox storage alongside RabbitMQ and other infrastructure components, ensuring that organizational operations are tracked reliably in the message bus.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Decorators, MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure · high confidence

Outbox pattern support for command and event handlers

The Events service now wraps command and event handlers with outbox decorators. When enabled, these decorators ensure that commands and events are persisted to the message outbox before being processed, providing reliable delivery guarantees. The outbox behavior can be toggled via configuration, and a message ID is automatically generated if one is not already present in the message properties.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Decorators · high confidence

Reactions service introduces API endpoints and CQRS handlers for managing reactions

The MiniSpace.Services.Reactions service now exposes a REST API for creating, updating, and deleting reactions, as well as retrieving reaction summaries. The API registers endpoints for GET /reactions, GET /reactions/summary, POST /reactions, PUT /reactions/{reactionId}, and DELETE /reactions/{reactionId}. The POST endpoint creates a new reaction or updates an existing one if the user has already reacted to the same content, publishing a ReactionCreated event upon completion. The PUT endpoint allows users to change the type of their existing reaction, while the DELETE endpoint removes a reaction and publishes a ReactionDeleted event. Both update and delete operations enforce identity validation to ensure users can only modify or remove their own reactions. The service also provides a summary endpoint that returns reaction counts, dominant reaction types, and the authenticated user's specific reaction details.

MiniSpace.Services.Reactions · high confidence

Real-time chat and notification capabilities via SignalR hubs

The notification service now supports real-time communication through two new SignalR hubs: ChatHub and NotificationHub. ChatHub enables users to send direct messages to specific individuals and broadcast messages to named groups, while also managing group membership with join/leave notifications. NotificationHub allows the system to push individual notifications to specific users and broadcast notifications to all connected clients, facilitating immediate delivery of friend requests and other alerts without requiring page refreshes.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Hubs · high confidence

SignalR hub and connection manager scaffolding added

The infrastructure layer now includes initial scaffolding for SignalR real-time communication. A \NotificationHub\ class has been added to handle client connections and message routing, while a \SignalRConnectionManager\ has been introduced to manage hub context interactions. These components provide the foundational structure for broadcasting notifications, though the current implementation serves as a base for further development.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Hubs, MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Managers · medium confidence

Structured application exceptions for the Organizations service

The Organizations application layer now includes a dedicated exception hierarchy to provide precise error reporting. A base \AppException\ class with a machine-readable \Code\ property serves as the foundation for specific exceptions covering key scenarios: validation failures (\InvalidOrganizationNameException\, \InvalidPermissionException\), state issues (\InvalidRequestStateException\), and various not-found or conflict conditions for organizations, members, organizers, roles, and requests (e.g., \OrganizationNotFoundException\, \MemberNotFoundException\, \OrganizerAlreadyAddedException\, \UserAlreadyMemberException\). This allows consumers to handle errors programmatically based on specific error codes rather than parsing generic messages.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application/Exceptions · high confidence

Structured logging for event command handlers

The Events service now includes structured logging for key command handlers. A new \MessageToLogTemplateMapper\ maps commands like CreateEvent, DeleteEvent, and SignUpToEvent to human-readable log templates, and the \Extensions\ class registers this mapper along with command and event handler logging via the Paralax builder.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Logging · high confidence

Structured logging for media file operations

The MediaFiles service now includes structured logging for key media commands. A new logging extension registers a template mapper that produces specific log messages for uploading, deleting, and cleaning up media files, allowing users to track these actions with clear context such as file names and URLs.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Infrastructure/Logging · high confidence

Support for external organization image upload and deletion events

The organization service now listens to external media events to keep profile, banner, and gallery images in sync. New event types, OrganizationImageUploaded and MediaFileDeleted, are handled by dedicated processors that update the organization's profile or banner URL when the corresponding image is uploaded or removed, and add or remove images in the organization gallery. This ensures that changes made via external media services are reflected in the organization's stored image references.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Application/Events/External · high confidence

User notification retrieval with pagination, filtering, and sorting

The notifications service now supports retrieving notifications for a specific user with advanced query capabilities. Users can fetch a single notification by ID or retrieve a paginated list of notifications filtered by status and date range, with results sorted by creation date in either ascending or descending order.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Mongo/Queries · high confidence

Architecture

Introduction of application service interfaces for infrastructure and domain mapping

The Comments application layer now exposes four new interfaces to support internal architecture: IStudentsServiceClient for retrieving user data, IDateTimeProvider for abstracting time access, IEventMapper for translating domain events, and IMessageBroker for publishing events. These additions establish the contracts required for dependency injection and decoupling within the service's application logic.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Services · high confidence

Behavioural changes

API Gateway transitions to the Nuar framework

The MiniSpace API Gateway has been migrated to the Nuar framework, replacing the previous implementation. This change introduces a new architecture where routing, authentication (JWT), and service discovery are driven by YAML configuration files (e.g., \nuar.yml\, \ntrada.docker.yml\) rather than hardcoded logic. The gateway now utilizes Nuar's built-in hooks for correlation context and span tracing, integrates with RabbitMQ for message handling, and supports Docker-based deployment via a new Dockerfile and build scripts.

MiniSpace.APIGateway.Nuar · high confidence

Automatic cleanup of comments when events or posts are deleted

The Comments service now automatically removes associated comments when the parent content is deleted. This is implemented via new event handlers for \EventDeleted\ and \PostDeleted\ messages. When an \EventDeleted\ event is received, the service fetches and deletes all comments linked to that event ID. Similarly, when a \PostDeleted\ event is received, it fetches and deletes all comments linked to that post ID. This ensures data consistency by preventing orphaned comments in the system.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Events/External · high confidence

Comments are now stored as embedded arrays within parent documents

The Comments service has switched its MongoDB storage strategy from using separate, top-level comment documents to embedding comments directly inside the parent OrganizationEvent, OrganizationPost, UserEvent, and UserPost documents. This change means that adding, updating, or deleting a comment now modifies the parent record rather than a standalone comment collection, and browsing comments retrieves them from these embedded arrays. This restructuring supports the new capability to fetch parent comments and their children in a single query, improving performance for comment threads.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Repositories · high confidence

Comments service handlers now support multi-context comments and explicit like management

The command handlers in the Comments application layer have been refactored to support comments across four distinct contexts (Organization Event, Organization Post, User Event, and User Post) using a CommentContext enum, replacing the previous single-context approach. This change introduces dedicated handlers for adding and deleting likes, which now enforce strict ownership validation (ensuring only the comment author can delete a like) and publish specific domain events (LikeAdded, CommentUpdated) to the message broker. Additionally, the CreateComment handler now validates parent comment existence and structure to support threaded replies, and all comment mutations (Create, Update, Delete) now correctly update the LastUpdatedAt timestamp and publish corresponding events.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Commands/Handlers · high confidence

Event notification handlers now notify organizers and broadcast via SignalR

The notification service now actively notifies event organizers when students interact with their events. Specifically, when a student signs up, shows interest, cancels a signup, or cancels interest, the system now creates and persists a notification for the event organizer in addition to the student. These notifications are persisted via the user notifications repository and immediately broadcast to the organizer's client in real-time using SignalR, ensuring organizers are instantly aware of changes to their event's participation status.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Events/Handlers · high confidence

Friends service application events refactored

The Friends service's application-layer event definitions have been reorganized and expanded. New event classes were added to handle user status updates and friend invitation notifications, while existing events for friend requests and removals were updated. Additionally, a new set of 'Rejected' event classes was introduced to explicitly model failures for friend adding, invitation, removal, and request operations, providing clearer error handling for these interactions.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application/Events · high confidence

Friends service introduces structured domain exceptions

The Friends service core now includes a dedicated exception hierarchy in the \MiniSpace.Services.Friends.Core.Exceptions\ namespace to provide more granular error handling for friend-related operations. This change adds a base \DomainException\ class with a specific error \Code\, along with concrete exceptions for specific failure scenarios: \FriendAcceptanceException\ and \FriendDeclinationException\ for request handling failures, \FriendAlreadyAddedException\ to prevent duplicate entries, \FriendshipStateException\ for invalid state transitions, and validation exceptions like \InvalidFriendRequestException\, \InvalidFriendInvitationException\, \InvalidFriendFullNameException\, and \InvalidAggregateIdException\. These changes allow the service to throw typed errors that carry context (such as user IDs and current states), enabling better debugging and client-side error handling.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Core/Exceptions · high confidence

Identity core domain model refactored with new security and account management features

The identity service's core entity model has been significantly updated to support enhanced security and account lifecycle management. The User entity now includes support for email verification and two-factor authentication (2FA), allowing users to enable/disable 2FA and verify their email addresses. Account security is further strengthened by the introduction of a RefreshToken entity for managing session tokens and a UserResetToken entity to handle password reset flows. Additionally, the user role system has been simplified to an enum (User, Admin, Banned), replacing the previous role class structure, and new methods have been added to the User entity to support banning and unbanning users.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Core/Entities · high confidence

Introduction of application-layer service interfaces

The email service application layer now exposes a set of new abstractions to support its internal logic and external integrations. These include IEmailService for sending messages, IStudentsServiceClient for retrieving student data, IDateTimeProvider for time-sensitive operations, IEventMapper for translating domain events, and IMessageBroker for publishing events. These interfaces define the contracts that the application layer relies on, decoupling the email sending logic from specific implementations and infrastructure details.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Application/Services · high confidence

Introduction of new Data Transfer Objects for the Comments service

This change introduces a new set of Data Transfer Objects (DTOs) within the Comments service's application layer, establishing the contract for data exchange. The primary addition is \CommentDto\, which exposes comment details including identifiers, text content, timestamps (\CreatedAt\, \LastUpdatedAt\, \LastReplyAt\), reply counts, and nested \ReplyDto\ objects, supporting features like threaded replies and soft deletion. Supporting DTOs include \ReplyDto\ for individual reply data, \PageableDto\ and \SortDto\ to enable pagination and sorting capabilities for comment lists, and \UserDto\ to carry user profile information associated with comments. These structures replace or supplement previous internal representations, standardizing how comment entities and related user data are serialized for API consumers.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Dto · high confidence

Introduction of new application service interfaces

The notifications application layer now exposes several new abstractions to decouple core logic from infrastructure and external dependencies. These include IBaseUrlService for retrieving base URLs, IDateTimeProvider for abstracting time access, IEventMapper for translating domain events, IMessageBroker for publishing events, and ISignalRConnectionManager for sending real-time messages. These interfaces provide the contracts required by the updated command handlers and other application services.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Services · high confidence

Introduction of structured domain exception types

The MediaFiles service now includes a base DomainException class and a specific InvalidAggregateIdException, enabling more granular error handling for invalid aggregate identifiers within the core service layer.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Core/Exceptions · high confidence

Introduction of structured exception types for the Friends service

The Friends service application layer now includes a dedicated set of custom exception classes to handle specific error scenarios. This change introduces a base \AppException\ class and several derived types, including \AlreadyFriendsException\, \AlreadyInvitedException\, \FriendRequestNotFoundException\, \FriendshipNotFoundException\, \InvalidFriendRequestException\, \InvalidFriendRequestStateException\, \InvalidRoleException\, \UnauthorizedFriendActionException\, and \UnauthorizedUserAccessException\. These exceptions provide structured error codes and context (such as user IDs) to improve error handling and debugging for friend-related operations.

MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Application/Exceptions · high confidence

MongoDB repository implementations for notifications, friend events, and user notifications

The notification service now persists data using MongoDB via three new repository classes: FriendEventMongoRepository, NotificationMongoRepository, and UserNotificationsMongoRepository. These classes implement the core repository interfaces and handle CRUD operations for friend events, individual notifications, and per-user notification aggregates. UserNotificationsMongoRepository adds support for upserting user notification lists, updating individual notification statuses, checking existence, removing specific notifications, counting notifications, and retrieving recent notifications. This change shifts the notification infrastructure from its previous storage mechanism to MongoDB.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Mongo/Repositories · high confidence

MongoDB schema update for FileSourceInfo with organization and context tracking

The MediaFiles service now persists additional metadata for file source information in MongoDB, including the uploading user's ID, creation timestamp, and file processing state. Crucially, the schema now supports multi-tenancy and content context by adding optional OrganizationId, EventId, and PostId fields, allowing media files to be explicitly linked to specific organizations, events, or posts.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Infrastructure/Mongo/Documents · high confidence

New application events for media file lifecycle and cleanup

The MediaFiles service now exposes a comprehensive set of application events to track file operations and background maintenance. Uploads are now granularly tracked via \EventFileUploaded\, \EventImageUploaded\, \GeneralFileUploaded\, \MediaFileUploaded\, \OrganizationImageUploaded\, \PostFileUploaded\, and \StudentImageUploaded\, providing detailed context such as file URLs, content types, and associated entity IDs (posts, organizations, students, events). Deletions are signaled by \MediaFileDeleted\, and the new background worker for removing unassociated files emits \FileCleanupBackgroundWorkerStarted\, \FileCleanupBackgroundWorkerStopped\, and \UnassociatedFilesCleaned\ events to monitor the cleanup process.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Events · high confidence

New domain events for event lifecycle and student interactions

The Events application layer now exposes a comprehensive set of domain events to track the full lifecycle of events and user engagement. These include \EventCreated\, \EventUpdated\, and \EventDeleted\ to signal state changes, along with \EventParticipantAdded\ and \EventParticipantRemoved\ for attendance tracking. Student-specific interactions are captured via \StudentSignedUpToEvent\, \StudentShowedInterestInEvent\, and their corresponding cancellation events (\StudentCancelledSignUpToEvent\, \StudentCancelledInterestInEvent\). Additionally, operational events like \EventBackgroundWorkerStarted\, \EventBackgroundWorkerStopped\, \EventViewed\, and \EventsStateUpdated\ are introduced to support background processing and analytics.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Events · high confidence

New external event models for post creation and updates

The notifications service now defines specific external event classes, PostCreated and PostUpdated, within the MiniSpace.Services.Notifications.Application.Events.External.Posts namespace. These models capture the necessary data (such as post ID, user/organization context, content, and notification flags) to trigger notifications when posts are created or modified, replacing the previous structure for handling these external post-related messages.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Posts · high confidence

New internal event definitions and handlers for notification lifecycle

The Notifications service now defines and handles internal domain events for the full notification lifecycle: creation, update, and deletion. New event classes (NotificationCreated, NotificationUpdated, NotificationDeleted) are introduced in the Application layer, alongside corresponding handlers. The NotificationCreated handler is currently a placeholder with no active logic, while the NotificationUpdated and NotificationDeleted handlers implement the core behavior of marking notifications as read or deleted, persisting the change, and publishing subsequent events via the message broker.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events · high confidence

Notification queries now support pagination, filtering, and sorting

The notifications service now allows users to retrieve their notifications with pagination, filtering, and sorting capabilities. A new query, GetNotificationsByUser, accepts parameters for date range (StartDate, EndDate), notification status, page number, results per page, and sorting criteria (OrderBy, SortOrder). This replaces or augments previous retrieval methods, enabling more efficient handling of large notification lists. Additionally, a dedicated query GetNotification allows fetching a single notification by ID. The underlying PagedResult structure provides metadata for navigation (NextPage, PrevPage) to support client-side pagination UIs.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Queries · high confidence

Notifications core domain model and infrastructure restructured

The Notifications service core has been refactored to adopt a Domain-Driven Design approach. This introduces a new \AggregateId\ value object and an \AggregateRoot\ base class to manage entity identity and domain events. The \Notification\ entity has been updated to include specific event types (via \NotificationEventType\) and details, supporting a wider range of triggers such as friend requests, event sign-ups, posts, comments, reactions, and reports. New entities like \UserNotifications\ and \FriendEvent\ have been added to manage user-specific notification collections and friend-related event data, while comprehensive domain exceptions enforce data validity.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Core/Entities · high confidence

Notifications service external event contracts updated

The MiniSpace Notifications service has updated its external event definitions to align with changes in the event domain. New or modified contracts now include EventCreated (with organizer details and media URLs), EventDeleted (including name and date range), EventUpdated, and several student-interaction events (StudentSignedUpToEvent, StudentShowedInterestInEvent, StudentCancelledSignUpToEvent, StudentCancelledInterestInEvent, EventParticipantAdded, and EventParticipantRemoved). These changes ensure the notification service correctly processes the latest event payloads from other services.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Events/External/Events · high confidence

Organizations now support hierarchical structure and detailed contact information

The Organization document model has been expanded to support a tree structure via a new ParentOrganizationId and SubOrganizations fields, allowing organizations to be nested. Additionally, the core organization entity now persists and exposes detailed contact information, including Address, Country, City, Telephone, and Email. This change is accompanied by new MongoDB document structures and mapping extensions for related entities such as roles, invitations, members, gallery images, and user-organization associations to support the updated data model.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure/Mongo/Documents · high confidence

Structured application exceptions for event validation and authorization

The Events application now introduces a comprehensive set of typed exception classes to replace generic error handling. This includes an abstract \AppException\ base class and specific exceptions for validation rules (such as \InvalidEventNameException\, \InvalidEventCapacityException\, and \InvalidEventFeeException\), resource not found scenarios (\EventNotFoundException\, \OrganizationNotFoundException\), and authorization failures (\UnauthorizedEventAccessException\, \OrganizerDoesNotBelongToOrganizationException\). These changes ensure that API responses provide precise, machine-readable error codes and context for event creation, updates, and access control.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Exceptions · high confidence

Structured application exceptions for identity operations

The identity service now uses a dedicated exception hierarchy in the application layer to provide more specific error handling. A new abstract \AppException\ base class defines a standard error code, from which specific exceptions inherit: \InvalidTokenException\ for expired or invalid tokens, \InvalidTwoFactorCodeException\ for incorrect 2FA codes, \TokenNotFoundException\ for missing reset tokens, and \UserNotFoundException\/\UserNotFoundByEmailException\ for missing user records. This allows consumers to catch and handle these distinct identity-related failure scenarios precisely.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Application/Exceptions · high confidence

Structured application exceptions with error codes

The Notifications service now uses a dedicated exception hierarchy in the application layer to handle specific error scenarios. A base AppException class provides a standardized error code, which is implemented by specific exceptions such as InvalidNotificationStatusException, NotificationAlreadyDeletedException, and NotificationNotFoundException. This allows the service to return consistent, machine-readable error codes (e.g., 'invalid\_notification\_status', 'notification\_already\_deleted') to clients when operations fail due to invalid states or missing resources.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Application/Exceptions · high confidence

Structured domain exceptions for comment validation and like operations

The Comments service now introduces a set of specific, typed exceptions to handle domain validation errors more precisely. A new \DomainException\ base class provides a standard error code, from which several concrete exceptions inherit: \InvalidAggregateIdException\ for invalid identifiers, \InvalidCommentContentException\ for bad comment data, and four distinct exceptions for like/unlike operations (\StudentAlreadyLikesCommentException\, \StudentNotLikeCommentException\, \UserAlreadyLikesCommentException\, \UserNotLikeCommentException\). This allows the system to throw and catch specific error conditions related to user interactions with comments, improving error handling clarity for these specific scenarios.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Core/Exceptions · high confidence

Structured domain exceptions for identity operations

The Identity service now introduces a set of strongly-typed domain exceptions (e.g., EmailAlreadyVerifiedException, TwoFactorAlreadyEnabledException, UserCannotBeBannedException) that inherit from a new base DomainException class. This change provides specific error codes and contextual details (such as user IDs or email addresses) for common identity scenarios, enabling more precise error handling and clearer feedback for users and administrators.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Core/Exceptions · high confidence

Structured error mapping for event operations

The Events service now maps specific application exceptions (such as EventNotFound, UnauthorizedEventAccess, or InvalidEventDateTime) to structured rejection messages for downstream consumers and standardized HTTP responses for API clients. This ensures that errors during event creation, participation, or updates return consistent codes and reasons rather than generic failure messages.

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Exceptions · high confidence

Structured error mapping for identity operations

The identity service now uses dedicated mappers to translate internal exceptions into standardized responses and domain events. The new ExceptionToResponseMapper converts application and domain errors into HTTP 400 responses with specific error codes and messages, while the ExceptionToMessageMapper routes exceptions like invalid credentials, email conflicts, and two-factor authentication errors to corresponding rejected events (e.g., SignInRejected, SignUpRejected, EnableTwoFactorRejected). This ensures consistent error handling and clearer feedback for users during sign-in, sign-up, email verification, and two-factor management flows.

MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Exceptions · high confidence

Structured exception handling for the Comments service

The Comments application layer now introduces a dedicated exception hierarchy to provide consistent, typed error reporting. A base \AppException\ class defines a standard error \Code\ property, from which specific exceptions inherit to handle distinct failure scenarios: \CommentNotFoundException\, \ParentCommentNotFoundException\, \UserNotFoundException\, and \StudentNotFoundException\ for missing entities; \InvalidCommentContextException\ and \InvalidCommentContextEnumException\ for invalid context data; \InvalidParentCommentException\ for invalid reply relationships; \StudentAlreadyExistsException\ for duplicate student additions; and \UnauthorizedCommentAccessException\ for permission violations. This allows consumers of the service to catch and handle specific business logic errors rather than generic exceptions.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Exceptions · high confidence

Structured exception types for media file validation and access control

The MediaFiles service now exposes a set of specific, structured exceptions to provide clearer error reporting for users and clients. This includes validation errors for file size limits, content type mismatches, and invalid context types, as well as access control exceptions for unauthorized uploads or file access attempts. These changes allow consumers of the service to handle specific failure scenarios (such as a file being too large or a user lacking permission) more precisely than with generic errors.

MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Exceptions · high confidence

Structured logging for comment and like operations

The Comments service now includes structured logging for command handlers via the Paralax CQRS logging framework. This change adds a new logging extension and a message-to-template mapper that generates specific log messages for comment lifecycle events (Create, Update, Delete) and like actions (Add, Delete), allowing users to track these operations in application logs.

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Logging · high confidence

Structured logging templates for notification commands and events

The notification service now includes standardized, human-readable log messages for key operations. A new \MessageToLogTemplateMapper\ registers specific log templates for commands like creating, deleting, and updating notification status, as well as for external events such as friend requests and notifications. These templates are wired into the service's dependency injection via a new \AddHandlersLogging\ extension, ensuring that actions like 'Created notification with id: {NotificationId} for user: {UserId}' are consistently logged, improving observability for administrators and developers.

MiniSpace.Services.Notifications/src/MiniSpace.Services.Notifications.Infrastructure/Logging · high confidence

Structured logging templates for organization management commands

The Organizations service now provides structured, human-readable log messages for key organization management actions. A new \MessageToLogTemplateMapper\ registers specific log templates for commands such as creating, deleting, and updating organizations, assigning roles, inviting users, and managing privacy settings. These templates are wired into the application via the \AddHandlersLogging\ extension, ensuring that operations like creating an organization or assigning a role to a member are recorded with clear context (e.g., IDs and names) rather than generic logs.

MiniSpace.Services.Organizations/src/MiniSpace.Services.Organizations.Infrastructure/Logging · high confidence

Test coverage

Added Locust load test for sign-in endpoint; Added end-to-end tests for the Friends service API; Added unit tests for Comment and AggregatedId entities; Added unit tests for Events application command handlers; Added unit tests for Identity Core entities; Added unit tests for Identity application services and handlers; Added unit tests for MessageBroker service; Added unit tests for Two-Factor Authentication and Message Broker services; Added unit tests for comment and like command handlers; Added unit tests for external event handlers; Added unit tests for organization management commands and core entities.

Dependencies

Standardize .NET 8.0 target framework and Paralax dependency versions across services

All service projects (API, Application, Core, Infrastructure) and their associated test projects now target .NET 8.0. The dependency management has been updated to use the Paralax framework suite (including Paralax, Paralax.Logging, Paralax.WebApi, Paralax.CQRS.\, Paralax.MessageBrokers.\, Paralax.Persistence.\, Paralax.Security, etc.) with wildcard versioning ("\") instead of the previous specific versions (e.g., 0.4.\* or 1.1.448). Additionally, the API Gateway projects have been updated to use the Nuar framework suite with wildcard versions, and the Events service infrastructure now includes Microsoft.ML packages.

(dependencies) · high confidence

Housekeeping

Added .gitignore and solution file for Email Core service

The MiniSpace.Services.Email.Core project now includes a .gitignore file to exclude build artifacts, user-specific settings, and IDE cache files from version control, alongside a new Visual Studio solution file (MiniSpace.Services.Email.Core.sln) that defines the project structure and build configurations for Debug and Release modes.

MiniSpace.Services.Email/src/MiniSpace.Services.Email.Core · 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 39 → 40 (+0.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 42 → 42 (+0.0)
  • Architecture 73 → 73 (+0.1)
  • Maturity 54 → 59 (+4.8)
  • Readiness 56 → 56 (+0.0)
  • Security 42 → 43 (+1.2)
  • Domain Modelling 50 → 49 (-0.7)
  • Event-Driven 87 → 66 (-20.8)
  • Accessibility 31 → 32 (+0.8)
  • Performance 62 → 64 (+1.9)

Resolved (72)

  • Change coupling: CreateComment.cs ↔ CommentDto.cs (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Commands/CreateComment.cs)
  • Change coupling: EventMongoRepository.cs ↔ EventService.cs (MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Mongo/Repositories/EventMongoRepository.cs)
  • Change coupling: FileSourceInfo.cs ↔ FileSourceInfoDocument.cs (MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Core/Entities/FileSourceInfo.cs)
  • Change-coupling hub: CommentDocument.cs → CreateComment.cs, CommentDto.cs, Comment.cs (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Documents/CommentDocument.cs)
  • Change-coupling hub: StudentDocument.cs → StudentDto.cs, Student.cs, EventMapper.cs (MiniSpace.Services.Students/src/MiniSpace.Services.Students.Infrastructure/Mongo/Documents/StudentDocument.cs)
  • Coverage not measured — the suite ran but produced no coverage data
  • Duplicated block (16–17 lines × 10) (MiniSpace.Web/src/MiniSpace.Web/Pages/Account/ProfileComponent.razor)
  • Duplicated block (16–17 lines × 5) (MiniSpace.Web/src/Astravent.Web.Wasm/Pages/Account/ProfileComponent.razor)
  • Off-boarding risk: anonymized user #1
  • Split Astravent.Web.Wasm
  • Split Astravent.Web.Wasm
  • Split MiniSpace.Services.Notifications.Application
  • The test class UpdateCommnetHandlerTest contains a typo in its name ('Commnet' instead of 'Comment'). This is a naming inconsistency and a spelling error.
  • XML-doc coverage: Astravent.Web.Wasm (MiniSpace.Web/src/Astravent.Web.Wasm/Astravent.Web.Wasm.csproj)
  • XML-doc coverage: Astravent.Web.Wasm (MiniSpace.Web2/src/Astravent.Web.Wasm/Astravent.Web.Wasm.csproj)
  • XML-doc coverage: MiniSpace.APIGateway (MiniSpace.APIGateway.Nuar/src/MiniSpace.APIGateway/MiniSpace.APIGateway.csproj)
  • XML-doc coverage: MiniSpace.APIGateway (MiniSpace.APIGateway/src/MiniSpace.APIGateway/MiniSpace.APIGateway.csproj)
  • XML-doc coverage: MiniSpace.APIGateway.Ocelot (MiniSpace.APIGateway.Ocelot/src/MiniSpace.APIGateway.Ocelot/MiniSpace.APIGateway.Ocelot.csproj)
  • XML-doc coverage: MiniSpace.Services.Comments.Api (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Api/MiniSpace.Services.Comments.Api.csproj)
  • XML-doc coverage: MiniSpace.Services.Comments.Application (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/MiniSpace.Services.Comments.Application.csproj)
  • …and 52 more

New (44)

  • Change coupling: StudentDocument.cs ↔ EventMapper.cs (MiniSpace.Services.Students/src/MiniSpace.Services.Students.Infrastructure/Mongo/Documents/StudentDocument.cs)
  • Documentation: no build, run or usage example (README.md)
  • Documentation: no map of the repository's parts (README.md)
  • Duplicated block (19 lines × 2) (MiniSpace.Web/src/Astravent.Web.Wasm/Program.cs)
  • Off-boarding risk: anonymized user #1
  • redundant comment (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Queries/Handlers/SearchCommentsHandler.cs)
  • redundant comment (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Queries/Handlers/SearchCommentsHandler.cs)
  • redundant comment (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Queries/Handlers/SearchCommentsHandler.cs)
  • redundant comment (MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Infrastructure/Mongo/Queries/Handlers/SearchCommentsHandler.cs)
  • redundant comment (MiniSpace.Services.Communication/src/MiniSpace.Services.Communication.Application/Commands/Handlers/CreateChatHandler.cs)
  • redundant comment (MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Events/External/Handlers/EventImageUploadedHandler.cs)
  • redundant comment (MiniSpace.Services.Events/src/MiniSpace.Services.Events.Infrastructure/Mongo/Queries/Handlers/GetUserEventsFeedHandler.cs)
  • redundant comment (MiniSpace.Services.Friends/src/MiniSpace.Services.Friends.Infrastructure/Mongo/Queries/Handlers/GetSentFriendRequestsHandler.cs)
  • redundant comment (MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Core/Entities/User.cs)
  • redundant comment (MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Mongo/Documents/Extensions.cs)
  • redundant comment (MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Mongo/Documents/Extensions.cs)
  • redundant comment (MiniSpace.Services.Identity/src/MiniSpace.Services.Identity.Infrastructure/Mongo/Documents/Extensions.cs)
  • redundant comment (MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Commands/Handlers/DeleteMediaFileHandler.cs)
  • redundant comment (MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Application/Commands/Handlers/DeleteMediaFileHandler.cs)
  • redundant comment (MiniSpace.Services.MediaFiles/src/MiniSpace.Services.MediaFiles.Infrastructure/Services/MediaFilesService.cs)
  • …and 24 more

Architecture

  • Unchanged — 17 containers · 13 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

SaintAngeLs/distributed_minispace 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 bd93ec738bd897079a8bdd2fe93afcc5d4455ba9 — 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.