generator-codedesignplus 0.0.1-rc.2

package/generators/microservice/templates/microservice/src/domain/CodeDesignPlus.Net.Microservice.Domain/ValueObjects/AddressValueObject.cs

@@ -0,0 +1,30 @@
+namespace CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+public sealed partial class AddressValueObject
+{
+    public AddressValueObject(string country, string state, string city, string address, int codePostal)
+    {
+        this.Country = country;
+        this.State = state;
+        this.City = city;
+        this.Address = address;
+        this.CodePostal = codePostal;
+    }
+
+    public string Country { get; private set; }
+    public string State { get; private set; }
+    public string City { get; private set; }
+    public string Address { get; private set; }
+    public int CodePostal { get; private set; }
+
+    public static AddressValueObject Create(string country, string state, string city, string address, int codePostal)
+    {
+        DomainGuard.IsNullOrEmpty(country, Errors.CountryIsNull);
+        DomainGuard.IsNullOrEmpty(state, Errors.StateIsNull);
+        DomainGuard.IsNullOrEmpty(city, Errors.CityIsNull);
+        DomainGuard.IsNullOrEmpty(address, Errors.AddressIsNull);
+        DomainGuard.IsLessThan(codePostal, 0, Errors.CodePostalIsInvalid);
+
+        return new AddressValueObject(country, state, city, address, codePostal);
+    }
+}

package/generators/microservice/templates/microservice/src/domain/CodeDesignPlus.Net.Microservice.Domain/ValueObjects/ClientValueObject.cs

@@ -0,0 +1,27 @@
+namespace CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+    public sealed partial class ClientValueObject
+{
+    public ClientValueObject(Guid id, string name, string document, string typeDocument)
+    {
+        this.Id = id;
+        this.Name = name;
+        this.Document = document;
+        this.TypeDocument = typeDocument;
+    }
+
+    public Guid Id { get; private set; }
+    public string Name { get; private set; }
+    public string Document { get; private set; }
+    public string TypeDocument { get; private set; }
+
+    public static ClientValueObject Create(Guid id, string name, string document, string typeDocument)
+    {
+        DomainGuard.GuidIsEmpty(id, Errors.IdClientIsInvalid);
+        DomainGuard.IsNullOrEmpty(name, Errors.NameClientIsInvalid);
+        DomainGuard.IsNullOrEmpty(document, Errors.DocumentIsNull);
+        DomainGuard.IsNullOrEmpty(typeDocument, Errors.TypeDocumentIsNull);
+
+        return new ClientValueObject(id, name, document, typeDocument);
+    }
+}

package/generators/microservice/templates/microservice/src/domain/CodeDesignPlus.Net.Microservice.Infrastructure/CodeDesignPlus.Net.Microservice.Infrastructure.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PublishAot>true</PublishAot>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CodeDesignPlus.Net.Microservice.Application\CodeDesignPlus.Net.Microservice.Application.csproj" />
+  </ItemGroup>
+</Project>

package/generators/microservice/templates/microservice/src/domain/CodeDesignPlus.Net.Microservice.Infrastructure/Errors.cs

@@ -0,0 +1,6 @@
+namespace CodeDesignPlus.Net.Microservice.Infrastructure;
+
+public class Errors: IErrorCodes
+{
+    public const string UnknownError = "000 : An unknown error occurred.";
+}

package/generators/microservice/templates/microservice/src/domain/CodeDesignPlus.Net.Microservice.Infrastructure/Repositories/OrderRepository.cs

@@ -0,0 +1,109 @@
+namespace CodeDesignPlus.Net.Microservice.Infrastructure.Repositories;
+
+public class OrderRepository(IServiceProvider serviceProvider, IOptions<MongoOptions> mongoOptions, ILogger<RepositoryBase> logger) 
+    : RepositoryBase(serviceProvider, mongoOptions, logger), IOrderRepository
+{
+    public Task AddProductToOrderAsync(AddProductToOrderParams parameters, CancellationToken cancellationToken)
+    {
+        var product = new ProductEntity
+        {
+            Id = parameters.IdProduct,
+            Name = parameters.Name,
+            Description = parameters.Description,
+            Price = parameters.Price,
+            Quantity = parameters.Quantity
+        };
+
+        var filterId = Builders<OrderAggregate>.Filter.Eq(x => x.Id, parameters.Id);
+        var update = Builders<OrderAggregate>.Update
+            .Push(x => x.Products, product)
+            .Set(x => x.UpdatedAt, parameters.UpdatedAt)
+            .Set(x => x.UpdatedBy, parameters.UpdateBy);
+
+        var collection = base.GetCollection<OrderAggregate>();
+
+        return collection.UpdateOneAsync(
+            filterId,
+            update,
+            cancellationToken: cancellationToken
+         );
+    }
+
+    public Task CancelOrderAsync(CancelOrderParams parameters, CancellationToken cancellationToken)
+    {
+        var filterId = Builders<OrderAggregate>.Filter.Eq(x => x.Id, parameters.Id);
+
+        var update = Builders<OrderAggregate>.Update
+            .Set(x => x.Status, parameters.OrderStatus)
+            .Set(x => x.ReasonForCancellation, parameters.Reason)
+            .Set(x => x.CancelledAt, parameters.CancelledAt)
+            .Set(x => x.UpdatedAt, parameters.UpdatedAt)
+            .Set(x => x.UpdatedBy, parameters.UpdateBy);
+
+        return base.GetCollection<OrderAggregate>().UpdateOneAsync(filterId, update, cancellationToken: cancellationToken);
+    }
+
+    public Task CompleteOrderAsync(CompleteOrderParams parameters, CancellationToken cancellationToken)
+    {
+        var filterId = Builders<OrderAggregate>.Filter.Eq(x => x.Id, parameters.Id);
+
+        var update = Builders<OrderAggregate>.Update
+            .Set(x => x.CompletedAt, parameters.CompletedAt)
+            .Set(x => x.Status, parameters.OrderStatus)
+            .Set(x => x.UpdatedAt, parameters.UpdatedAt)
+            .Set(x => x.UpdatedBy, parameters.UpdateBy);
+
+        return base.GetCollection<OrderAggregate>().UpdateOneAsync(filterId, update, cancellationToken: cancellationToken);
+    }
+
+    public Task CreateOrderAsync(OrderAggregate order, CancellationToken cancellationToken)
+    {
+        return this.CreateAsync(order, cancellationToken);
+    }
+
+    public Task<OrderAggregate> FindAsync(Guid id, CancellationToken cancellationToken)
+    {
+        var filterId = Builders<OrderAggregate>.Filter.Eq(x => x.Id, id);
+
+        return base.GetCollection<OrderAggregate>().FindAsync(filterId, cancellationToken: cancellationToken).Result.FirstOrDefaultAsync(cancellationToken);
+    }
+
+    public async Task<List<OrderAggregate>> GetAllOrdersAsync(CancellationToken cancellationToken)
+    {
+        var result = await base.GetCollection<OrderAggregate>().FindAsync(x => true, cancellationToken: cancellationToken);
+
+        return await result.ToListAsync(cancellationToken);
+    }
+
+    public Task RemoveProductFromOrderAsync(RemoveProductFromOrderParams parameters, CancellationToken cancellationToken)
+    {
+        var filterId = Builders<OrderAggregate>.Filter.Eq(x => x.Id, parameters.Id);
+
+        var update = Builders<OrderAggregate>.Update
+            .PullFilter(x => x.Products, p => p.Id == parameters.IdProduct)
+            .Set(x => x.UpdatedAt, parameters.UpdatedAt)
+            .Set(x => x.UpdatedBy, parameters.UpdateBy);
+
+        return base.GetCollection<OrderAggregate>().UpdateOneAsync(filterId, update, cancellationToken: cancellationToken);
+    }
+
+    public Task UpdateOrderAsync(OrderAggregate order, CancellationToken cancellationToken)
+    {
+        return this.UpdateAsync(order, cancellationToken);
+    }
+
+    public Task UpdateQuantityProductAsync(UpdateQuantityProductParams parameters, CancellationToken cancellationToken)
+    {
+        var filterId = Builders<OrderAggregate>.Filter.And(
+            Builders<OrderAggregate>.Filter.Eq(x => x.Id, parameters.Id),
+            Builders<OrderAggregate>.Filter.ElemMatch(x => x.Products, x => x.Id == parameters.ProductId)
+        );
+
+        var update = Builders<OrderAggregate>.Update
+            .Set("Products.$.Quantity", parameters.NewQuantity)
+            .Set(x => x.UpdatedAt, parameters.UpdatedAt)
+            .Set(x => x.UpdatedBy, parameters.UpdateBy);
+
+        return base.GetCollection<OrderAggregate>().UpdateOneAsync(filterId, update, cancellationToken: cancellationToken);
+    }
+}

package/generators/microservice/templates/microservice/src/domain/CodeDesignPlus.Net.Microservice.Infrastructure/Startup.cs

@@ -0,0 +1,10 @@
+namespace CodeDesignPlus.Net.Microservice.Infrastructure
+{
+    public class Startup : IStartup
+    {
+        public void Initialize(IServiceCollection services, IConfiguration configuration)
+        {
+
+        }
+    }
+}

package/generators/microservice/templates/microservice/src/domain/CodeDesignPlus.Net.Microservice.Infrastructure/Usings.cs

@@ -0,0 +1,15 @@
+global using CodeDesignPlus.Net.Core.Abstractions;
+global using CodeDesignPlus.Net.Mongo.Abstractions.Options;
+global using CodeDesignPlus.Net.Mongo.Repository;
+global using Microsoft.Extensions.Configuration;
+global using Microsoft.Extensions.DependencyInjection;
+global using Microsoft.Extensions.Logging;
+global using Microsoft.Extensions.Options;
+global using MongoDB.Driver;
+global using CodeDesignPlus.Net.Serializers;
+
+global using CodeDesignPlus.Net.Microservice.Domain;
+global using CodeDesignPlus.Net.Microservice.Domain.Entities;
+global using CodeDesignPlus.Net.Microservice.Domain.Enums;
+global using CodeDesignPlus.Net.Microservice.Domain.Repositories;
+global using CodeDesignPlus.Net.Microservice.Domain.DataTransferObjects;

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/CodeDesignPlus.Net.Microservice.AsyncWorker.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <InvariantGlobalization>true</InvariantGlobalization>
+    <PublishAot>false</PublishAot>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="CodeDesignPlus.Net.Microservice.Commons" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Vault" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Redis" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.RabbitMQ" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Logger" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Observability" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Security" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Redis.Cache" Version="0.5.0-beta.60" />
+  </ItemGroup>
+  <ItemGroup>
+    <SonarQubeSetting Include="sonar.coverage.exclusions">
+      <Value>**/Program.cs</Value>
+    </SonarQubeSetting>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\domain\CodeDesignPlus.Net.Microservice.Infrastructure\CodeDesignPlus.Net.Microservice.Infrastructure.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Consumers\" />
+    <Folder Include="DomainEvents\" />
+  </ItemGroup>
+</Project>

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/Program.cs

@@ -0,0 +1,41 @@
+using CodeDesignPlus.Net.Logger.Extensions;
+using CodeDesignPlus.Net.Microservice.Commons.FluentValidation;
+using CodeDesignPlus.Net.Microservice.Commons.MediatR;
+using CodeDesignPlus.Net.Mongo.Extensions;
+using CodeDesignPlus.Net.RabbitMQ.Extensions;
+using CodeDesignPlus.Net.Redis.Cache.Extensions;
+using CodeDesignPlus.Net.Redis.Extensions;
+using CodeDesignPlus.Net.Security.Extensions;
+using CodeDesignPlus.Net.Vault.Extensions;
+using Mapster;
+
+var builder = WebApplication.CreateSlimBuilder(args);
+
+Serilog.Debugging.SelfLog.Enable(Console.Error);
+
+builder.Host.UseSerilog();
+
+builder.Configuration.AddVault();
+
+builder.Services.AddVault(builder.Configuration);
+builder.Services.AddMongo<CodeDesignPlus.Net.Microservice.Infrastructure.Startup>(builder.Configuration);
+builder.Services.AddRedis(builder.Configuration);
+builder.Services.AddRabbitMQ<Program>(builder.Configuration);
+builder.Services.AddSecurity(builder.Configuration);
+builder.Services.AddCache(builder.Configuration);
+builder.Services.AddMapster();
+builder.Services.AddFluentValidation();
+builder.Services.AddMediatR<CodeDesignPlus.Net.Microservice.Application.Startup>();
+
+var app = builder.Build();
+
+var home = app.MapGroup("/home");
+
+home.MapGet("/", () => "Ready");
+
+await app.RunAsync();
+
+public partial class Program
+{
+    protected Program() { }
+}

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/Properties/launchSettings.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "home",
+      "applicationUrl": "http://localhost:5246",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/Usings.cs

@@ -0,0 +1,10 @@
+global using CodeDesignPlus.Net.PubSub.Abstractions;
+global using CodeDesignPlus.Net.RabbitMQ.Attributes;
+global using CodeDesignPlus.Net.Serializers;
+
+global using CodeDesignPlus.Net.Microservice.Domain.DomainEvents;
+
+global using CodeDesignPlus.Net.Core.Abstractions;
+global using CodeDesignPlus.Net.Core.Abstractions.Attributes;
+global using CodeDesignPlus.Net.Microservice.Domain;
+global using CodeDesignPlus.Net.Microservice.Domain.Entities;

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/appsettings.Development.json

@@ -0,0 +1,2 @@
+{
+}

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/appsettings.json

@@ -0,0 +1,129 @@
+{
+  "Core": {
+    "AppName": "ms-archetype",
+    "Version": "v1",
+    "Description": "Microservice Archetype Template",
+    "Business": "CodeDesignPlus",
+    "Contact": {
+      "Name": "CodeDesignPlus",
+      "Email": "codedesignplus@outlook.com"
+    }
+  },
+  "Security": {
+    "Authority": "https://codedesignplus.b2clogin.com/codedesignplus.onmicrosoft.com/B2C_1_CodeDeseignPlus/oauth2/v2.0/",
+    "ClientId": "a74cb192-598c-4757-95ae-b315793bbbca",
+    "IncludeErrorDetails": true,
+    "ValidateAudience": true,
+    "ValidateIssuer": true,
+    "ValidateLifetime": true,
+    "RequireHttpsMetadata": true,
+    "ValidIssuer": "https://codedesignplus.b2clogin.com/3461e311-a66e-46ab-afdf-2bbfb72a5cb0/v2.0/",
+    "ValidAudiences": [
+      "a74cb192-598c-4757-95ae-b315793bbbca"
+    ],
+    "Applications": []
+  },
+  "Redis": {
+    "Instances": {
+      "Core": {
+        "ConnectionString": "localhost:6379"
+      }
+    }
+  },
+  "RedisCache": {
+    "Enable": true,
+    "Expiration": "00:05:00"
+  },
+  "RabbitMQ": {
+    "Enable": true,
+    "Host": "localhost",
+    "Port": 5672,
+    "UserName": "admin",
+    "Password": "password",
+    "EnableDiagnostic": true,
+    "UseQueue": false
+  },
+  "Mongo": {
+    "Enable": true,
+    "ConnectionString": "mongodb://localhost:27017",
+    "Database": "db_archetype",
+    "Diagnostic": {
+      "Enable": true,
+      "EnableCommandText": true
+    }
+  },  
+  "Logger": {
+    "Enable": true,
+    "OTelEndpoint": "http://127.0.0.1:4317"
+  },
+  "Observability": {
+    "Enable": true,
+    "ServerOtel": "http://127.0.0.1:4317",
+    "Trace": {
+      "Enable": true,
+      "AspNetCore": true,
+      "GrpcClient": false,
+      "SqlClient": false,
+      "CodeDesignPlusSdk": true,
+      "Redis": true,
+      "Kafka": false
+    },
+    "Metrics": {
+      "Enable": true,
+      "AspNetCore": true
+    }
+  },
+  "Vault": {
+    "Address": "http://127.0.0.1:8200",
+    "AppName": "ms-archetype",
+    "Solution": "archetype",
+    "Token": "root",
+    "Mongo": {
+      "TemplateConnectionString": "mongodb://{0}:{1}@localhost:27017"
+    }
+  },
+  "Serilog": {
+    "Using": [
+      "Serilog.Sinks.Console"
+    ],
+    "Filter": [
+      {
+        "Name": "ByExcluding",
+        "Args": {
+          "expression": "RequestPath like '/health%'"
+        }
+      }
+    ],
+    "MinimumLevel": {
+      "Default": "Verbose",
+      "Override": {
+        "Microsoft.AspNetCore.Hosting.Diagnostics": "Warning",
+        "Microsoft": "Warning",
+        "System": "Warning"
+      }
+    },
+    "Enrich": [
+      "FromLogContext"
+    ],
+    "Properties": {
+      "Category": "Event"
+    },
+    "WriteTo": [
+      {
+        "Name": "Async",
+        "Args": {
+          "configure": [
+            {
+              "Name": "Console",
+              "Args": {
+                "theme": "Serilog.Sinks.SystemConsole.Themes.AnsiConsoleTheme::Code, Serilog.Sinks.Console",
+                "outputTemplate": "[{Timestamp:HH:mm:ss} {Level:u3}] [{Message:lj}] [{EscapedException}]{NewLine}",
+                "restrictedToMinimumLevel": "Verbose"
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.Rest/CodeDesignPlus.Net.Microservice.Rest.csproj

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <InvariantGlobalization>true</InvariantGlobalization>
+    <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <NoWarn>$(NoWarn);1591</NoWarn>
+    <DockerfileContext>..\..</DockerfileContext>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="CodeDesignPlus.Net.Microservice.Commons" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Vault" Version="0.5.0-beta.60" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="7.2.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="7.2.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="7.2.0" />
+    <PackageReference Include="CodeDesignPlus.Net.Logger" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Redis" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Security" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Observability" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.RabbitMQ" Version="0.5.0-beta.60" />
+    <PackageReference Include="CodeDesignPlus.Net.Redis.Cache" Version="0.5.0-beta.60" />
+  </ItemGroup>
+  <ItemGroup>
+    <InternalsVisibleTo Include="CodeDesignPlus.Net.Microservice.Rest.Test" />
+  </ItemGroup>
+  <ItemGroup>
+    <SonarQubeSetting Include="sonar.coverage.exclusions">
+      <Value>**/SwaggerExtensions.cs, **/Program.cs</Value>
+    </SonarQubeSetting>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\domain\CodeDesignPlus.Net.Microservice.Infrastructure\CodeDesignPlus.Net.Microservice.Infrastructure.csproj" />
+  </ItemGroup>
+</Project>

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.Rest/CodeDesignPlus.Net.Microservice.Rest.csproj.user

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ActiveDebugProfile>http</ActiveDebugProfile>
+    <Controller_SelectedScaffolderID>ApiControllerEmptyScaffolder</Controller_SelectedScaffolderID>
+    <Controller_SelectedScaffolderCategoryPath>root/Common/Api</Controller_SelectedScaffolderCategoryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DebuggerFlavor>ProjectDebugger</DebuggerFlavor>
+  </PropertyGroup>
+</Project>

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.Rest/Controllers/OrderController.cs

@@ -0,0 +1,138 @@
+namespace CodeDesignPlus.Net.Microservice.Rest.Controllers;
+
+/// <summary>
+/// Controller class responsible for handling HTTP requests related to orders.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="OrdersController"/> class.
+/// </remarks>
+/// <param name="mediator">Mediator instance for sending commands and queries.</param>
+/// <param name="mapper">Mapper instance for mapping between DTOs and commands/queries.</param>
+[Route("api/[controller]")]
+[ApiController]
+public class OrdersController(IMediator mediator, IMapper mapper) : ControllerBase
+{
+    /// <summary>
+    /// Retrieves a list of orders based on the specified criteria.
+    /// </summary>
+    /// <param name="criteria">Criteria object used for filtering orders.</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>An `OkObjectResult` containing the list of orders if successful, otherwise an appropriate error response.</returns>
+    [HttpGet]
+    public async Task<IActionResult> GetOrders([FromQuery] C.Criteria criteria, CancellationToken cancellationToken)
+    {
+        var result = await mediator.Send(new GetAllOrdersQuery(criteria), cancellationToken);
+
+        return Ok(result);
+    }
+
+    /// <summary>
+    /// Retrieves a specific order by its unique identifier.
+    /// </summary>
+    /// <param name="id">The unique identifier of the order.</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>An `OkObjectResult` containing the order details if successful, otherwise an appropriate error response.</returns>
+    [HttpGet("{id}")]
+    public async Task<IActionResult> GetOrderById(Guid id, CancellationToken cancellationToken)
+    {
+        var result = await mediator.Send(new FindOrderByIdQuery(id), cancellationToken);
+
+        return Ok(result);
+    }
+
+    /// <summary>
+    /// Creates a new order.
+    /// </summary>
+    /// <param name="data">A DTO containing the order details.</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>A `NoContentResult` indicating successful creation, or an appropriate error response.</returns>
+    [HttpPost]
+    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderDto data, CancellationToken cancellationToken)
+    {
+        await mediator.Send(mapper.Map<CreateOrderCommand>(data), cancellationToken);
+
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Cancels an existing order.
+    /// </summary>
+    /// <param name="id">The unique identifier of the order to cancel.</param>
+    /// <param name="data">A DTO containing cancellation details (may not be required depending on implementation).</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>A `NoContentResult` indicating successful cancellation, or an appropriate error response.</returns>
+    [HttpDelete("{id}/cancel")]
+    public async Task<IActionResult> CancelOrder(Guid id, [FromBody] CancelOrderDto data, CancellationToken cancellationToken)
+    {
+        data.Id = id;
+
+        await mediator.Send(mapper.Map<CancelOrderCommand>(data), cancellationToken);
+
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Marks an existing order as complete.
+    /// </summary>
+    /// <param name="id">The unique identifier of the order to complete.</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>A `NoContentResult` indicating successful completion, or an appropriate error response.</returns>
+    [HttpPatch("{id}/complete")]
+    public async Task<IActionResult> CompleteOrder(Guid id, CancellationToken cancellationToken)
+    {
+        await mediator.Send(new CompleteOrderCommand(id), cancellationToken);
+
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Adds a product to an existing order.
+    /// </summary>
+    /// <param name="id">The unique identifier of the order to add the product to.</param>
+    /// <param name="data">A DTO containing the product details and the quantity to add.</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>A `NoContentResult` indicating successful addition, or an appropriate error response.</returns>
+    [HttpPost("{id}/products")]
+    public async Task<IActionResult> AddProductToOrder(Guid id, [FromBody] AddProductToOrderDto data, CancellationToken cancellationToken)
+    {
+        data.Id = id;
+
+        await mediator.Send(mapper.Map<AddProductToOrderCommand>(data), cancellationToken);
+
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Updates the quantity of a product within an existing order.
+    /// </summary>
+    /// <param name="id">The unique identifier of the order containing the product.</param>
+    /// <param name="productId">The unique identifier of the product to update the quantity for.</param>
+    /// <param name="data">A DTO containing the new quantity for the product.</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>A `NoContentResult` indicating successful update, or an appropriate error response.</returns>
+    [HttpPut("{id}/products/{productId}")]
+    public async Task<IActionResult> UpdateQuantityProduct(Guid id, Guid productId, [FromBody] UpdateQuantityProductDto data, CancellationToken cancellationToken)
+    {
+        data.Id = id;
+        data.ProductId = productId;
+
+        await mediator.Send(mapper.Map<UpdateQuantityProductCommand>(data), cancellationToken);
+
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Removes a product from an existing order.
+    /// </summary>
+    /// <param name="id">The unique identifier of the order containing the product.</param>
+    /// <param name="productId">The unique identifier of the product to remove.</param>
+    /// <param name="cancellationToken">Cancellation token (optional).</param>
+    /// <returns>A `NoContentResult` indicating successful removal, or an appropriate error response.</returns>
+    [HttpDelete("{id}/products/{productId}")]
+    public async Task<IActionResult> RemoveProduct(Guid id, Guid productId, CancellationToken cancellationToken)
+    {
+        await mediator.Send(new RemoveProductCommand(id, productId), cancellationToken);
+
+        return NoContent();
+    }
+}

package/generators/microservice/templates/microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.Rest/Core/Mapster/MapsterConfig.cs

@@ -0,0 +1,12 @@
+namespace CodeDesignPlus.Net.Microservice.Rest.Core.Mapster;
+
+public static class MapsterConfig
+{
+    public static void Configure()
+    {
+        TypeAdapterConfig<AddProductToOrderDto, AddProductToOrderCommand>.NewConfig().TwoWays();
+        TypeAdapterConfig<CancelOrderDto, CancelOrderCommand>.NewConfig().TwoWays();
+        TypeAdapterConfig<CreateOrderDto, CreateOrderCommand>.NewConfig().TwoWays();
+        TypeAdapterConfig<UpdateQuantityProductDto, UpdateQuantityProductCommand>.NewConfig().TwoWays();
+    }
+}