Merging into Marter Branch, #1
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
- Rename solution file: BlueTreadApp.slnx -> SecureCleanApiWaf.slnx - Rename project file: BlueTreadApp.csproj -> SecureCleanApiWaf.csproj - Update .gitignore with new project name patterns - Update Program.cs with project namespace and configuration - Update launchSettings.json with new application profiles This commit establishes the new project identity and configuration foundation.
**Entities (4):** - BaseEntity: Abstract base with ID, audit fields, domain events - User: User aggregate with Email value object and status - Token: JWT token entity with blacklisting support - ApiDataItem: Sample data entity with status tracking **Value Objects (3):** - Email: Validated email with domain rules - Role: User role (User, Admin) with validation - ValueObject: Base class for value object equality **Enums (4):** - UserStatus: Active, Inactive, Suspended, Deleted - TokenStatus: Active, Revoked, Expired - TokenType: Access, Refresh - DataStatus: Active, Archived, Deleted **Domain Events (4):** - IDomainEvent: Event marker interface - BaseDomainEvent: Base event with timestamp - UserRegisteredEvent: User creation event - TokenRevokedEvent: Token blacklisting event **Common (2):** - IAggregateRoot: Marker for aggregate roots - DomainException: Domain-specific exceptions This establishes the core domain model with rich business logic and invariants.
**Authentication Feature (6 components):** Commands: - LoginUserCommand + Handler: User authentication with JWT generation - BlacklistTokenCommand + Handler: Secure logout with dual-cache Queries: - IsTokenBlacklistedQuery + Handler: Token validation with caching - GetTokenBlacklistStatsQuery + Handler: Admin monitoring stats **Sample Data Feature (6 components):** Queries: - GetApiDataQuery + Handler: Retrieve all data from external API - GetApiDataByIdQuery + Handler: Retrieve single data item by ID - GetApiDataWithMappingQuery + Handler: Data retrieval with AutoMapper **Pipeline Behaviors (6):** - ICacheable: Interface for cacheable queries - CachingBehavior: Automatic caching via MediatR pipeline - ILoggable: Interface for loggable requests - LoggingBehavior: Automatic logging via MediatR pipeline - IValidatable: Interface for validatable commands - ValidationBehavior: Automatic validation via MediatR pipeline **Common (2):** - Result pattern: Result<T> for consistent error handling - DTOs: SampleDataDto for API responses This implements complete CQRS pattern with MediatR integration and cross-cutting concerns.
**Services (3):** - ApiIntegrationService: External API integration with HttpClientFactory - TokenBlacklistService: Dual-cache token management (Memory + Distributed) - CacheService: Generic caching abstraction for IMemoryCache/IDistributedCache **Repositories (3):** - UserRepository: User data access with EF Core - TokenRepository: Token persistence with EF Core - ApiDataItemRepository: API data caching with EF Core **Security (2):** - JwtTokenGenerator: JWT token creation and configuration - ApiKeyHandler: DelegatingHandler for external API authentication **Middleware (1):** - JwtBlacklistValidationMiddleware: Token validation in HTTP pipeline **Data Layer (3):** - ApplicationDbContext: EF Core DbContext configuration - ApiDataItemConfiguration: Entity Framework entity configuration - DatabaseSettings: Database connection configuration **Caching (2):** - CacheService: Generic caching implementation - SampleCache: Sample caching patterns and usage **Key Features:** - HttpClientFactory with Polly resilience policies - Dual-cache strategy for performance and scalability - Repository pattern with EF Core - JWT generation and validation - Custom middleware for authentication pipeline This establishes infrastructure for external integrations, data persistence, and cross-cutting concerns.
…or UI **API Controllers (3):** - AuthController: Login, logout, token management endpoints - TokenBlacklistController: Admin monitoring and statistics - SampleController: RESTful API v1 endpoints with caching **Dependency Injection Extensions (3):** - ApplicationServiceExtensions: Application layer DI configuration - InfrastructureServiceExtensions: Infrastructure layer DI with Polly - PresentationServiceExtensions: Presentation layer DI (Controllers, Swagger, JWT) **HTTP Pipeline Extensions (1):** - WebApplicationExtensions: Middleware pipeline configuration - Exception handling, HTTPS redirection, static files - Authentication, authorization, rate limiting - CORS, security headers, Swagger - Custom middleware (JWT blacklist validation) **Blazor Components (6):** - App.razor: Application root component - Routes.razor: Routing configuration - MainLayout.razor: Application layout - Home.razor + Home.razor.css: Home page with styling - Error.razor: Error page - _Imports.razor: Global using directives **Legacy Pages (1):** - _Host.cshtml: Blazor Server host page **Models (1):** - SampleModel: Sample data model for demonstrations **Static Files (1):** - wwwroot/readme.txt: Static files directory documentation **Key Features:** - RESTful API v1 with versioning - JWT authentication with role-based authorization - Swagger/OpenAPI documentation - Rate limiting (60/min, 1000/hr per IP) - CORS configuration - Security headers (XSS, Clickjacking, MIME-sniffing protection) - Blazor Server UI with SignalR - Dependency injection for all layers - Polly resilience policies (Retry + Circuit Breaker) This establishes the presentation layer with API endpoints, Blazor UI, and complete HTTP pipeline.
**Docker Configuration (4 files):** - Dockerfile: Multi-stage build for production deployment - Stage 1: Build with .NET 8 SDK - Stage 2: Runtime with ASP.NET Core 8 - Optimized for size and security - Dockerfile.original: Reference implementation - docker-compose.yml: Multi-container orchestration - App service with health checks - Redis for distributed caching (optional) - Environment variable configuration - .dockerignore: Exclude unnecessary files from Docker context **GitHub Actions CI/CD (2 workflows):** - azure-webapps-dotnet-core.yml: Azure App Service deployment - Build, test, publish workflow - Automated deployment to Azure - Environment-specific configuration - docker-publish.yml: Docker Hub publishing - Multi-platform builds (linux/amd64, linux/arm64) - Automated tagging and versioning - Push to Docker Hub registry **Key Features:** - Multi-stage Docker builds for optimization - Health check endpoints for container orchestration - Environment-based configuration - Automated CI/CD pipelines - Docker Compose for local development - Azure App Service integration - Docker Hub publishing automation This enables containerized deployment and automated CI/CD workflows.
**Main Guides (5):** - CLEAN-DDD_ARCH_README.md: Complete DDD & architecture documentation hub - CLEAN_ARCHITECTURE_GUIDE.md: Comprehensive architecture principles and implementation - MIGRATION_GUIDE.md: Step-by-step migration from single to multi-project - ARCHITECTURE_PATTERNS_EXPLAINED.md: Detailed pattern explanations - LAYER_INTEGRATION_GUIDE.md: How layers integrate and communicate **Layer-Specific Guides (5):** - 01-Domain-Layer.md: Entities, Value Objects, Events, Enums (85% complete) - 02-Application-Layer.md: CQRS with MediatR, Commands, Queries, Handlers - 03-Infrastructure-Layer.md: Services, Repositories, External integrations - 04-Infrastructure-Azure-Layer.md: Azure Key Vault, App Service integration - 05-Web-Presentation-Layer.md: Controllers, Extensions, Blazor components **Pattern & Strategy Guides (1):** - HYBRID-MAPPING-STRATEGY.md: AutoMapper + Custom Mapper decision matrix **Key Topics Covered:** - Clean Architecture principles and layers - Dependency Inversion Principle (DIP) - SOLID principles in practice - Domain-Driven Design (DDD) patterns - CQRS and MediatR integration - Repository pattern with EF Core - Value Objects and Aggregates - Domain Events and invariants - Single vs Multi-project approaches - Interface abstractions (15+ interfaces) - Layer boundaries and flow - Testing strategies per layer - Migration paths and best practices This provides complete architectural documentation with real-world implementation examples.
**Documentation Hub (1):** - API_README.md: Central hub for all API design documentation - Quick navigation to all guides - Overview of API capabilities - Links to specific topics **API Design Guides (2):** - API_DESIGN_GUIDE.md: Comprehensive API design principles - RESTful API design patterns - API versioning strategies (URL, Header, Query String) - Error handling with ProblemDetails - Security best practices (JWT, HTTPS, Rate Limiting) - Caching strategies (Cache-Aside, MediatR pipeline) - Performance optimization - API documentation with Swagger/OpenAPI - Testing strategies - CORS configuration - Content negotiation - Pagination and filtering - API_CONTRACTS_EXAMPLES.md: Real-world API contract examples - Request/Response models - Authentication endpoints - Data retrieval endpoints - Error response formats - ProblemDetails examples - Swagger schema examples - Validation error responses **Key Topics Covered:** - RESTful resource naming conventions - HTTP methods (GET, POST, PUT, DELETE, PATCH) - Status codes (200, 201, 400, 401, 403, 404, 500) - API versioning approaches - Authentication and authorization patterns - Rate limiting and throttling - CORS policies - Content negotiation (JSON, XML) - Caching headers and strategies - Error handling and ProblemDetails - API documentation and testing - Performance optimization techniques This provides complete API design documentation with production-ready patterns.
**Documentation Hub (1):** - AUTHENT-AUTHORIT_README.md: Central hub for all security documentation - Quick navigation to authentication, authorization, and security guides - Overview of security features - Links to CQRS implementation details **Security Implementation Guides (4):** - API-SECURITY-IMPLEMENTATION-GUIDE.md: Complete security architecture - JWT Bearer authentication configuration - Token blacklisting with dual-cache strategy - Custom middleware (JwtBlacklistValidationMiddleware) - Rate limiting setup (60/min, 1000/hr) - CORS configuration - Security headers (XSS, Clickjacking, MIME-sniffing) - Polly resilience policies (Retry + Circuit Breaker) - External API security (ApiKeyHandler) - Production deployment checklist - JWT_AUTHENTICATION_CQRS_ARCHITECTURE.md: CQRS authentication architecture - Command pattern (LoginUserCommand, BlacklistTokenCommand) - Query pattern (IsTokenBlacklistedQuery, GetTokenBlacklistStatsQuery) - MediatR integration and pipeline behaviors - Automatic caching with CachingBehavior - Handler implementations - Request flow diagrams - Best practices and patterns - CQRS_LOGIN_IMPLEMENTATION_SUMMARY.md: Login implementation details - LoginUserCommand and handler breakdown - JWT token generation process - Validation and error handling - Response structure and metadata - CQRS_LOGOUT_IMPLEMENTATION_SUMMARY.md: Logout implementation details - BlacklistTokenCommand and handler breakdown - Dual-cache token blacklisting strategy - Token invalidation process - Cache expiration and cleanup **Key Topics Covered:** - JWT Bearer authentication and authorization - Token-based authentication (stateless) - Role-based access control (RBAC) - Token blacklisting and revocation - CQRS pattern for authentication - MediatR integration - Dual-cache strategy (Memory + Distributed) - Custom middleware for token validation - Rate limiting and throttling - CORS policies - Security headers configuration - API key management - Polly resilience patterns - External API security - Production security checklist This provides complete security documentation with CQRS implementation examples.
**Deployment Hub (1):** - DEPLOYMENT_README.md: Master deployment guide and hub - Quick start guides for all platforms - Platform comparison matrix - Prerequisites and configuration - Security best practices - Troubleshooting guide - Links to specific deployment guides **Azure App Service Deployment (1):** - AzureAppService/DEPLOYMENT_GUIDE.md: Complete Azure PaaS deployment - Azure resource setup (App Service, Key Vault) - Managed Identity configuration - GitHub Actions CI/CD pipeline - Application Insights integration - Environment variables and secrets - Complete deployment checklist - Troubleshooting and monitoring - Estimated time: 10-15 minutes **Docker Deployment (6):** - Docker/DOCKER_README.md: Docker documentation hub - Docker/DOCKER_DEPLOYMENT.md: Full containerization guide (11 KB) - Building and running containers locally - Publishing to Docker Hub - Cloud deployment (Azure, AWS, GCP, Kubernetes) - Environment variables and configuration - Multi-stage builds - Estimated time: 5-10 minutes (local) - Docker/DOCKER_QUICK_REFERENCE.md: Quick commands and troubleshooting - Docker/DOCKER_SETUP_SUMMARY.md: Overview and checklist - Docker/DOCKER_TROUBLESHOOTING.md: Common issues and solutions - Docker/DOCKER_DNS_CONFIGURATION.md: DNS and networking setup **Deployment Options Covered:** - Docker Compose (Local): Low complexity, 5 min, for development - Azure App Service: Low complexity, 15 min, managed PaaS - Azure Container Apps: Medium complexity, 10 min, serverless containers - Docker + Kubernetes: High complexity, 30+ min, enterprise orchestration - CI/CD (GitHub Actions): Medium complexity, 20 min, automated deployments **Key Topics Covered:** - Azure App Service deployment - Docker containerization - Docker Compose orchestration - Multi-stage Docker builds - Environment-based configuration - Secrets management (Azure Key Vault) - Managed Identity for Azure resources - GitHub Actions CI/CD pipelines - Container health checks - Multi-platform builds (linux/amd64, linux/arm64) - Cloud platform deployment (Azure, AWS, GCP) - Kubernetes deployment - DNS configuration - Troubleshooting and monitoring - Security best practices - Performance optimization This provides complete deployment documentation for all major platforms.
**Testing Hub (1):** - TEST_README.md: Central hub for all testing documentation - Quick navigation to all testing guides - Overview of testing strategies - Links to specific testing approaches **Testing Strategy Guides (4):** - CLEAN_ARCHITECTURE_TESTING_STRATEGY.md: Complete testing strategy - Unit testing per layer (Domain, Application, Infrastructure, Presentation) - Integration testing approaches - Architecture tests with NetArchTest - End-to-End testing strategies - Test organization and structure - Mocking strategies (Moq, NSubstitute) - Test data builders - xUnit, NUnit, MSTest examples - Code coverage targets (80%+ recommended) - CI/CD integration - API_ENDPOINT_TESTING_GUIDE.md: How to test all API endpoints - Testing with Swagger UI - PowerShell testing scripts - Postman collection examples - curl commands for all endpoints - Authentication endpoint testing - Protected endpoint testing with JWT - Token blacklisting testing - Admin monitoring endpoint testing - Rate limiting verification - Error response testing - TEST_AUTHENTICATION_GUIDE.md: Step-by-step authentication testing - Running the application - Getting JWT tokens via CQRS endpoints - Testing protected endpoints - Testing logout and token blacklisting - Testing authorization policies (User, Admin) - Testing rate limiting - Admin monitoring endpoints - Troubleshooting guide - Complete testing workflow (5 minutes) **Key Topics Covered:** - Unit testing strategies per layer - Integration testing with WebApplicationFactory - Architecture tests with NetArchTest - API endpoint testing approaches - Authentication and authorization testing - JWT token testing workflows - Token blacklisting verification - Rate limiting testing - CORS testing - Error handling testing - Swagger/OpenAPI testing - PowerShell testing scripts - Postman integration - curl command examples - Mock objects and test doubles - Test data builders - Code coverage reporting - CI/CD test integration - Test organization best practices This provides complete testing documentation with practical examples for all layers.
Added comprehensive Clean Architecture documentation, including guides for Domain, Application, Infrastructure, Azure, and Presentation layers. Introduced a migration guide for transitioning to a multi-project structure and a quick reference for single-project setups. Updated `.gitignore` to exclude sensitive files and centralized logging configuration. Enhanced `README.md` with project overviews, dependency flow diagrams, and implementation checklists. Added detailed testing strategies covering unit, integration, and functional tests. Improved Azure integration documentation with examples for Key Vault, Blob Storage, and Service Bus. Simplified project organization for maintainability and scalability. Enhance configs, docs, and Azure integration - Improved `appsettings.Development.json` with detailed comments, verbose logging, JWT settings, CORS, rate-limiting, and database configurations for development. - Updated `appsettings.json` with Azure Key Vault integration, production-ready logging, JWT placeholders, stricter CORS, and rate-limiting rules. - Added certificates (`corporate-ca.crt` and `.cer`) for secure communication. - Expanded `README.md` with project overview, architecture, security, and deployment details. - Added `PROBLEMDETAILS-CUSTOMIZATION-GUIDE.md` and `PROBLEMDETAILS-EXAMPLES.md` for enriched API error responses. - Introduced `AZURE_INTEGRATION_GUIDE.md` for App Service, Key Vault, and Managed Identity setup. - Documented CI/CD pipeline in `CICD_PIPELINE_GUIDE.md` with GitHub Actions workflow for build, test, deploy, and security scans.
Enhanced readability and presentation by: - Replacing ambiguous symbols with meaningful emojis. - Fixing encoding issues for special characters. - Standardizing formatting with consistent symbols (✅, ❌). - Adding new badges for tools and technologies. - Expanding the technology stack and implementation details. Updated sections include: - Inspiration, Table of Contents, Executive Summary. - Core Technical Achievements, Metrics, Quick Reference. - Documentation Hubs, Clean Architecture, Security Features. - Added a "Contact" section and a personalized footer. These changes aim to improve clarity, consistency, and user engagement.
Enhanced formatting with icons and emojis for better navigation. Standardized terminology and fixed encoding issues across files. Added detailed examples, diagrams, and step-by-step guides. Expanded troubleshooting and support sections for user assistance. Aligned all documentation with modern technical writing standards. Improve README.md formatting and structure Enhanced readability and presentation by: - Replacing ambiguous symbols with meaningful emojis. - Fixing encoding issues for special characters. - Standardizing formatting with consistent symbols (✅, ❌). - Adding new badges for tools and technologies. - Expanding the technology stack and implementation details. Updated sections include: - Inspiration, Table of Contents, Executive Summary. - Core Technical Achievements, Metrics, Quick Reference. - Documentation Hubs, Clean Architecture, Security Features. - Added a "Contact" section and a personalized footer. These changes aim to improve clarity, consistency, and user engagement.
Updated section titles and headings for consistency, replacing ambiguous symbols with meaningful icons. Renamed "Contact & Contributions" to "Support & Contact" and enhanced the section with detailed instructions for help, bug reporting, and contributions. Reorganized "Documentation Hubs" and added new hubs for Clean Architecture, Authentication & Authorization, and Testing. Updated links to ensure accuracy and consistency, including references to API design documentation. Enhanced "Getting Started" and "Quick Reference" sections with actionable steps for new developers. Replaced outdated phrases with concise descriptions and improved the "Best Practices" and "Summary" sections. Added a "License & Legal" section and updated "API Status" with a clear summary of implementation readiness. Improved formatting and tone throughout, ensuring better readability and navigation. Merge branch 'Dev' of https://github.com/dariemcarlosdev/SecureCleanApiWaf into Dev
Added a new section under `services` in `docker-compose.yml` to provide guidance for common issues. Included Q&A entries for resolving problems like environment variables not being applied and changes not reflecting after a rebuild. These updates aim to improve developer experience and debugging.
Contributor
|
Caution Review failedThe pull request is closed. Note Other AI code review bot(s) detectedCodeRabbit has detected other AI code review bot(s) in this pull request and will avoid duplicating their findings in the review comments. This may lead to a less comprehensive review. WalkthroughRebrands BlueTreadApp to SecureCleanApiWaf and introduces a full layered architecture: domain entities, value objects, repositories, services, MediatR CQRS handlers, caching and blacklist features, EF Core infrastructure, middleware, DI/pipeline extensions, CI/CD workflows, Docker artifacts, and comprehensive configuration and docs. Changes
Sequence Diagram(s)sequenceDiagram
participant Client
participant AuthController
participant MediatR
participant LoginHandler
participant IUserRepo
participant JwtTokenGenerator
participant ITokenRepo
Client->>AuthController: POST /api/v1/auth/login (credentials)
AuthController->>MediatR: Send(LoginUserCommand)
MediatR->>LoginHandler: Handle
LoginHandler->>IUserRepo: GetByUsernameAsync
IUserRepo-->>LoginHandler: User
LoginHandler->>JwtTokenGenerator: GenerateToken(...)
JwtTokenGenerator-->>LoginHandler: JWT
LoginHandler->>ITokenRepo: AddAsync(Token)
LoginHandler->>ITokenRepo: SaveChangesAsync()
LoginHandler-->>MediatR: Result.Ok(LoginResponseDto)
MediatR-->>AuthController: Result
AuthController-->>Client: 200 {token, metadata}
sequenceDiagram
participant Client
participant Middleware
participant MediatR
participant IsTokenBlacklistedHandler
participant ITokenBlacklistService
participant Response
Client->>Middleware: Request with Authorization: Bearer <jwt>
Middleware->>MediatR: Send(IsTokenBlacklistedQuery)
MediatR->>IsTokenBlacklistedHandler: Handle
IsTokenBlacklistedHandler->>ITokenBlacklistService: IsTokenBlacklistedAsync
alt cached
ITokenBlacklistService-->>IsTokenBlacklistedHandler: cached status
else not cached
ITokenBlacklistService->>ITokenRepo: query repository
ITokenBlacklistService-->>IsTokenBlacklistedHandler: status
end
IsTokenBlacklistedHandler-->>Middleware: Result(TokenBlacklistStatusDto)
alt blacklisted
Middleware->>Response: 401 Unauthorized (payload)
Response-->>Client: 401
else valid
Middleware->>Response: pass through
Response-->>Client: proceed
end
Estimated code review effort🎯 5 (Critical) | ⏱️ ~120+ minutes Specific areas to focus during review:
Poem
Pre-merge checks and finishing touches❌ Failed checks (1 warning)
✅ Passed checks (2 passed)
📜 Recent review detailsConfiguration used: CodeRabbit UI Review profile: CHILL Plan: Pro 📒 Files selected for processing (95)
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
There was a problem hiding this comment.
Pull request overview
This pull request introduces comprehensive CI/CD automation, enhanced application configuration, and improved frontend presentation for the SecureCleanApiWaf project. The changes focus on deployment readiness, configuration clarity, and user experience improvements.
Key Changes:
- Added GitHub Actions workflows for Azure deployment and Docker publishing with security scanning
- Enhanced configuration files with extensive documentation and best practices guidance
- Redesigned home page with improved user experience and API documentation access
Reviewed changes
Copilot reviewed 95 out of 130 changed files in this pull request and generated 1 comment.
Show a summary per file
| File | Description |
|---|---|
docs/APIDesign/API_CONTRACTS_EXAMPLES.md |
New comprehensive API contracts documentation with examples for user management, authentication, and Blazor integration |
docker-compose.yml |
New Docker Compose configuration with detailed inline documentation for local development |
appsettings.json |
Enhanced base configuration with security warnings and comprehensive inline documentation |
appsettings.Development.json |
Development-specific settings with security guidance and extended documentation |
SecureCleanApiWaf.slnx |
New solution file for project structure |
SecureCleanApiWaf.csproj |
New project file with package references and Docker configuration |
README.md |
Comprehensive project documentation including architecture, deployment guides, and feature overview |
Properties/launchSettings.json |
Launch profiles including new Swagger and Docker configurations |
Program.cs |
Application entry point with extensive inline documentation explaining DI and pipeline configuration |
| Multiple service and infrastructure files | New implementations with detailed documentation for repositories, services, and middleware |
💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.
| @@ -0,0 +1,832 @@ | |||
| # API Contracts Examples - SecureCleanApiWaf | |||
|
|
|||
| > "Well-defined API contracts are the foundation of successful collaboration between backend and frontend teams�clear examples drive efficient development and seamless integration." | |||
There was a problem hiding this comment.
Corrected encoding issue: corrupted character in quote replaced with proper em dash.
Suggested change
| > "Well-defined API contracts are the foundation of successful collaboration between backend and frontend teams�clear examples drive efficient development and seamless integration." | |
| > "Well-defined API contracts are the foundation of successful collaboration between backend and frontend teams—clear examples drive efficient development and seamless integration." |
Contributor
|
Note Docstrings generation - SUCCESS |
Docstrings generation was requested by @dariemcarlosdev. * #1 (comment) The following files were modified: * `Core/Application/Common/Behaviors/CachingBehavior.cs` * `Core/Application/Common/DTOs/TokenBlacklistStatusDto.cs` * `Core/Application/Common/Interfaces/IApiDataItemRepository.cs` * `Core/Application/Common/Interfaces/IApiIntegrationService.cs` * `Core/Application/Common/Interfaces/ICacheService.cs` * `Core/Application/Common/Interfaces/ITokenBlacklistService.cs` * `Core/Application/Common/Interfaces/ITokenRepository.cs` * `Core/Application/Common/Interfaces/IUserRepository.cs` * `Core/Application/Common/Mapping/ApiDataMapper.cs` * `Core/Application/Common/Models/Result.cs` * `Core/Application/Common/Profiles/ApiDataMappingProfile.cs` * `Core/Application/Features/Authentication/Commands/BlacklistTokenCommand.cs` * `Core/Application/Features/Authentication/Commands/BlacklistTokenCommandHandler.cs` * `Core/Application/Features/Authentication/Commands/LoginUserCommand.cs` * `Core/Application/Features/Authentication/Commands/LoginUserCommandHandler.cs` * `Core/Application/Features/Authentication/Queries/GetTokenBlacklistStatsQuery.cs` * `Core/Application/Features/Authentication/Queries/GetTokenBlacklistStatsQueryHandler.cs` * `Core/Application/Features/Authentication/Queries/IsTokenBlacklistedQuery.cs` * `Core/Application/Features/Authentication/Queries/IsTokenBlacklistedQueryHandler.cs` * `Core/Application/Features/SampleData/Queries/GetApiDataByIdQuery.cs` * `Core/Application/Features/SampleData/Queries/GetApiDataByIdQueryHandler.cs` * `Core/Application/Features/SampleData/Queries/GetApiDataQuery.cs` * `Core/Application/Features/SampleData/Queries/GetApiDataQueryHandler.cs` * `Core/Application/Features/SampleData/Queries/GetApiDataWithMappingQuery.cs` * `Core/Application/Features/SampleData/Queries/GetApiDataWithMappingQueryHandler.cs` * `Core/Domain/Entities/ApiDataItem.cs` * `Core/Domain/Entities/BaseEntity.cs` * `Core/Domain/Entities/Token.cs` * `Core/Domain/Entities/User.cs` * `Core/Domain/Events/BaseDomainEvent.cs` * `Core/Domain/Events/TokenRevokedEvent.cs` * `Core/Domain/Events/UserRegisteredEvent.cs` * `Core/Domain/Exceptions/DomainException.cs` * `Core/Domain/ValueObjects/Email.cs` * `Core/Domain/ValueObjects/Role.cs` * `Core/Domain/ValueObjects/ValueObject.cs` * `Infrastructure/Caching/CacheService.cs` * `Infrastructure/Caching/SampleCache.cs` * `Infrastructure/Data/ApplicationDbContext.cs` * `Infrastructure/Data/Configurations/ApiDataItemConfiguration.cs` * `Infrastructure/Data/DatabaseSettings.cs` * `Infrastructure/Handlers/ApiKeyHandler.cs` * `Infrastructure/Middleware/JwtBlacklistValidationMiddleware.cs` * `Infrastructure/Repositories/ApiDataItemRepository.cs` * `Infrastructure/Repositories/TokenRepository.cs` * `Infrastructure/Repositories/UserRepository.cs` * `Infrastructure/Security/JwtTokenGenerator.cs` * `Infrastructure/Services/ApiIntegrationService.cs` * `Infrastructure/Services/TokenBlacklistService.cs` * `Presentation/Controllers/v1/AuthController.cs` * `Presentation/Controllers/v1/SampleController.cs` * `Presentation/Controllers/v1/TokenBlacklistController.cs` * `Presentation/Extensions/DependencyInjection/ApplicationServiceExtensions.cs` * `Presentation/Extensions/DependencyInjection/InfrastructureServiceExtensions.cs` * `Presentation/Extensions/DependencyInjection/PresentationServiceExtensions.cs` * `Presentation/Extensions/HttpPipeline/WebApplicationExtensions.cs`
Merged
…ec5e2 📝 Add docstrings to `Dev`
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This pull request introduces significant improvements to the CI/CD pipeline for the BlueTreadApp project, including new workflows for Azure deployment and Docker publishing, as well as enhancements to the application's frontend and project configuration. The changes focus on automating builds, deployments, and security scans, while also improving the user experience and cleaning up the repository.
CI/CD and Deployment Automation
.dockerignorefile to optimize Docker build contexts by excluding unnecessary files, improving build speed, image size, and security.Frontend and User Experience
Home.razorpage with a welcoming card, clear description of the demo project, and a prominent link to Swagger UI for API exploration; added corresponding CSS for improved appearance. [1] [2]Project Configuration and Cleanup
BlueTreadApp.csprojandBlueTreadApp.slnx, streamlining the repository. [1] [2]Other minor changes include small updates to error UI and style references in component files.
Summary by CodeRabbit
New Features
Documentation
✏️ Tip: You can customize this high-level summary in your review settings.