feat: Add new unit tests, domain exceptions, documentation, and various build artifacts across multiple services.

services/order-service-net/src/OrderService.API/Application/Behaviors/LoggingBehavior.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using MediatR;
+
+namespace MyService.API.Application.Behaviors;
+
+/// <summary>
+/// EN: MediatR behavior for logging request handling.
+/// VI: MediatR behavior để logging việc xử lý request.
+/// </summary>
+/// <typeparam name="TRequest">EN: Request type / VI: Loại request</typeparam>
+/// <typeparam name="TResponse">EN: Response type / VI: Loại response</typeparam>
+public class LoggingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly ILogger<LoggingBehavior<TRequest, TResponse>> _logger;
+
+    public LoggingBehavior(ILogger<LoggingBehavior<TRequest, TResponse>> logger)
+    {
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<TResponse> Handle(
+        TRequest request,
+        RequestHandlerDelegate<TResponse> next,
+        CancellationToken cancellationToken)
+    {
+        var requestName = typeof(TRequest).Name;
+
+        _logger.LogInformation(
+            "Handling {RequestName} / Đang xử lý {RequestName}",
+            requestName);
+
+        var stopwatch = Stopwatch.StartNew();
+
+        try
+        {
+            var response = await next();
+
+            stopwatch.Stop();
+
+            _logger.LogInformation(
+                "Handled {RequestName} in {ElapsedMs}ms / Đã xử lý {RequestName} trong {ElapsedMs}ms",
+                requestName, stopwatch.ElapsedMilliseconds);
+
+            return response;
+        }
+        catch (Exception ex)
+        {
+            stopwatch.Stop();
+
+            _logger.LogError(ex,
+                "Error handling {RequestName} after {ElapsedMs}ms / Lỗi xử lý {RequestName} sau {ElapsedMs}ms",
+                requestName, stopwatch.ElapsedMilliseconds);
+
+            throw;
+        }
+    }
+}

services/order-service-net/src/OrderService.API/Application/Behaviors/TransactionBehavior.cs

@@ -0,0 +1,84 @@
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using MyService.Infrastructure;
+
+namespace MyService.API.Application.Behaviors;
+
+/// <summary>
+/// EN: MediatR behavior for handling database transactions.
+/// VI: MediatR behavior để xử lý database transactions.
+/// </summary>
+/// <typeparam name="TRequest">EN: Request type / VI: Loại request</typeparam>
+/// <typeparam name="TResponse">EN: Response type / VI: Loại response</typeparam>
+public class TransactionBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly MyServiceContext _dbContext;
+    private readonly ILogger<TransactionBehavior<TRequest, TResponse>> _logger;
+
+    public TransactionBehavior(
+        MyServiceContext dbContext,
+        ILogger<TransactionBehavior<TRequest, TResponse>> logger)
+    {
+        _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<TResponse> Handle(
+        TRequest request,
+        RequestHandlerDelegate<TResponse> next,
+        CancellationToken cancellationToken)
+    {
+        var requestName = typeof(TRequest).Name;
+
+        // EN: Skip transaction for queries (read operations)
+        // VI: Bỏ qua transaction cho queries (các thao tác đọc)
+        if (requestName.EndsWith("Query"))
+        {
+            return await next();
+        }
+
+        // EN: Skip if already in a transaction
+        // VI: Bỏ qua nếu đã trong transaction
+        if (_dbContext.HasActiveTransaction)
+        {
+            return await next();
+        }
+
+        var strategy = _dbContext.Database.CreateExecutionStrategy();
+
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var transaction = await _dbContext.BeginTransactionAsync();
+
+            _logger.LogInformation(
+                "Begin transaction {TransactionId} for {RequestName} / Bắt đầu transaction {TransactionId} cho {RequestName}",
+                transaction?.TransactionId, requestName);
+
+            try
+            {
+                var response = await next();
+
+                if (transaction != null)
+                {
+                    await _dbContext.CommitTransactionAsync(transaction);
+
+                    _logger.LogInformation(
+                        "Committed transaction {TransactionId} for {RequestName} / Đã commit transaction {TransactionId} cho {RequestName}",
+                        transaction.TransactionId, requestName);
+                }
+
+                return response;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex,
+                    "Error during transaction {TransactionId} for {RequestName} / Lỗi trong transaction {TransactionId} cho {RequestName}",
+                    transaction?.TransactionId, requestName);
+
+                _dbContext.RollbackTransaction();
+                throw;
+            }
+        });
+    }
+}

services/order-service-net/src/OrderService.API/Application/Behaviors/ValidatorBehavior.cs

@@ -0,0 +1,63 @@
+using FluentValidation;
+using MediatR;
+
+namespace MyService.API.Application.Behaviors;
+
+/// <summary>
+/// EN: MediatR behavior for FluentValidation integration.
+/// VI: MediatR behavior để tích hợp FluentValidation.
+/// </summary>
+/// <typeparam name="TRequest">EN: Request type / VI: Loại request</typeparam>
+/// <typeparam name="TResponse">EN: Response type / VI: Loại response</typeparam>
+public class ValidatorBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly IEnumerable<IValidator<TRequest>> _validators;
+    private readonly ILogger<ValidatorBehavior<TRequest, TResponse>> _logger;
+
+    public ValidatorBehavior(
+        IEnumerable<IValidator<TRequest>> validators,
+        ILogger<ValidatorBehavior<TRequest, TResponse>> logger)
+    {
+        _validators = validators ?? throw new ArgumentNullException(nameof(validators));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<TResponse> Handle(
+        TRequest request,
+        RequestHandlerDelegate<TResponse> next,
+        CancellationToken cancellationToken)
+    {
+        var requestName = typeof(TRequest).Name;
+
+        if (!_validators.Any())
+        {
+            return await next();
+        }
+
+        _logger.LogDebug(
+            "Validating {RequestName} / Đang validate {RequestName}",
+            requestName);
+
+        var context = new ValidationContext<TRequest>(request);
+
+        var validationResults = await Task.WhenAll(
+            _validators.Select(v => v.ValidateAsync(context, cancellationToken)));
+
+        var failures = validationResults
+            .SelectMany(r => r.Errors)
+            .Where(f => f != null)
+            .ToList();
+
+        if (failures.Count != 0)
+        {
+            _logger.LogWarning(
+                "Validation failed for {RequestName} with {ErrorCount} errors / Validation thất bại cho {RequestName} với {ErrorCount} lỗi",
+                requestName, failures.Count);
+
+            throw new ValidationException(failures);
+        }
+
+        return await next();
+    }
+}

services/order-service-net/src/OrderService.API/Application/Commands/ChangeSampleStatusCommand.cs

@@ -0,0 +1,14 @@
+using MediatR;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Command to change status of a Sample.
+/// VI: Command để thay đổi trạng thái của Sample.
+/// </summary>
+/// <param name="SampleId">EN: Sample ID / VI: ID sample</param>
+/// <param name="NewStatus">EN: New status (activate, complete, cancel) / VI: Trạng thái mới (activate, complete, cancel)</param>
+public record ChangeSampleStatusCommand(
+    Guid SampleId,
+    string NewStatus
+) : IRequest<bool>;

services/order-service-net/src/OrderService.API/Application/Commands/ChangeSampleStatusCommandHandler.cs

@@ -0,0 +1,70 @@
+using MediatR;
+using MyService.Domain.AggregatesModel.SampleAggregate;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Handler for ChangeSampleStatusCommand.
+/// VI: Handler cho ChangeSampleStatusCommand.
+/// </summary>
+public class ChangeSampleStatusCommandHandler : IRequestHandler<ChangeSampleStatusCommand, bool>
+{
+    private readonly ISampleRepository _sampleRepository;
+    private readonly ILogger<ChangeSampleStatusCommandHandler> _logger;
+
+    public ChangeSampleStatusCommandHandler(
+        ISampleRepository sampleRepository,
+        ILogger<ChangeSampleStatusCommandHandler> logger)
+    {
+        _sampleRepository = sampleRepository ?? throw new ArgumentNullException(nameof(sampleRepository));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<bool> Handle(
+        ChangeSampleStatusCommand request,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogInformation(
+            "Changing status of sample {SampleId} to {NewStatus} / Thay đổi trạng thái sample {SampleId} thành {NewStatus}",
+            request.SampleId, request.NewStatus);
+
+        // EN: Get existing sample / VI: Lấy sample đã tồn tại
+        var sample = await _sampleRepository.GetAsync(request.SampleId);
+
+        if (sample is null)
+        {
+            _logger.LogWarning(
+                "Sample {SampleId} not found / Sample {SampleId} không tìm thấy",
+                request.SampleId);
+            return false;
+        }
+
+        // EN: Change status based on action / VI: Thay đổi trạng thái dựa trên action
+        switch (request.NewStatus.ToLowerInvariant())
+        {
+            case "activate":
+                sample.Activate();
+                break;
+            case "complete":
+                sample.Complete();
+                break;
+            case "cancel":
+                sample.Cancel();
+                break;
+            default:
+                _logger.LogWarning(
+                    "Invalid status action: {NewStatus} / Action trạng thái không hợp lệ: {NewStatus}",
+                    request.NewStatus);
+                return false;
+        }
+
+        // EN: Save changes / VI: Lưu thay đổi
+        await _sampleRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Sample {SampleId} status changed to {NewStatus} / Trạng thái sample {SampleId} đã đổi thành {NewStatus}",
+            request.SampleId, request.NewStatus);
+
+        return true;
+    }
+}

services/order-service-net/src/OrderService.API/Application/Commands/CreateSampleCommand.cs

@@ -0,0 +1,21 @@
+using MediatR;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Command to create a new Sample.
+/// VI: Command để tạo một Sample mới.
+/// </summary>
+/// <param name="Name">EN: Sample name / VI: Tên sample</param>
+/// <param name="Description">EN: Optional description / VI: Mô tả tùy chọn</param>
+public record CreateSampleCommand(
+    string Name,
+    string? Description
+) : IRequest<CreateSampleCommandResult>;
+
+/// <summary>
+/// EN: Result of CreateSampleCommand.
+/// VI: Kết quả của CreateSampleCommand.
+/// </summary>
+/// <param name="Id">EN: Created sample ID / VI: ID sample đã tạo</param>
+public record CreateSampleCommandResult(Guid Id);

services/order-service-net/src/OrderService.API/Application/Commands/CreateSampleCommandHandler.cs

@@ -0,0 +1,46 @@
+using MediatR;
+using MyService.Domain.AggregatesModel.SampleAggregate;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Handler for CreateSampleCommand.
+/// VI: Handler cho CreateSampleCommand.
+/// </summary>
+public class CreateSampleCommandHandler : IRequestHandler<CreateSampleCommand, CreateSampleCommandResult>
+{
+    private readonly ISampleRepository _sampleRepository;
+    private readonly ILogger<CreateSampleCommandHandler> _logger;
+
+    public CreateSampleCommandHandler(
+        ISampleRepository sampleRepository,
+        ILogger<CreateSampleCommandHandler> logger)
+    {
+        _sampleRepository = sampleRepository ?? throw new ArgumentNullException(nameof(sampleRepository));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<CreateSampleCommandResult> Handle(
+        CreateSampleCommand request,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogInformation(
+            "Creating new sample with name: {Name} / Tạo sample mới với tên: {Name}",
+            request.Name);
+
+        // EN: Create domain entity / VI: Tạo domain entity
+        var sample = new Sample(request.Name, request.Description);
+
+        // EN: Add to repository / VI: Thêm vào repository
+        _sampleRepository.Add(sample);
+
+        // EN: Save changes (dispatches domain events) / VI: Lưu thay đổi (dispatch domain events)
+        await _sampleRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Sample created successfully with ID: {SampleId} / Sample đã tạo thành công với ID: {SampleId}",
+            sample.Id);
+
+        return new CreateSampleCommandResult(sample.Id);
+    }
+}

services/order-service-net/src/OrderService.API/Application/Commands/DeleteSampleCommand.cs

@@ -0,0 +1,10 @@
+using MediatR;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Command to delete a Sample.
+/// VI: Command để xóa một Sample.
+/// </summary>
+/// <param name="SampleId">EN: Sample ID to delete / VI: ID sample cần xóa</param>
+public record DeleteSampleCommand(Guid SampleId) : IRequest<bool>;

services/order-service-net/src/OrderService.API/Application/Commands/DeleteSampleCommandHandler.cs

@@ -0,0 +1,54 @@
+using MediatR;
+using MyService.Domain.AggregatesModel.SampleAggregate;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Handler for DeleteSampleCommand.
+/// VI: Handler cho DeleteSampleCommand.
+/// </summary>
+public class DeleteSampleCommandHandler : IRequestHandler<DeleteSampleCommand, bool>
+{
+    private readonly ISampleRepository _sampleRepository;
+    private readonly ILogger<DeleteSampleCommandHandler> _logger;
+
+    public DeleteSampleCommandHandler(
+        ISampleRepository sampleRepository,
+        ILogger<DeleteSampleCommandHandler> logger)
+    {
+        _sampleRepository = sampleRepository ?? throw new ArgumentNullException(nameof(sampleRepository));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<bool> Handle(
+        DeleteSampleCommand request,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogInformation(
+            "Deleting sample {SampleId} / Xóa sample {SampleId}",
+            request.SampleId);
+
+        // EN: Get existing sample / VI: Lấy sample đã tồn tại
+        var sample = await _sampleRepository.GetAsync(request.SampleId);
+
+        if (sample is null)
+        {
+            _logger.LogWarning(
+                "Sample {SampleId} not found / Sample {SampleId} không tìm thấy",
+                request.SampleId);
+            return false;
+        }
+
+        // EN: Delete sample / VI: Xóa sample
+        _sampleRepository.Delete(sample);
+
+        // EN: Save changes / VI: Lưu thay đổi
+        await _sampleRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Sample {SampleId} deleted successfully / Sample {SampleId} đã xóa thành công",
+            request.SampleId);
+
+        return true;
+    }
+}

services/order-service-net/src/OrderService.API/Application/Commands/UpdateSampleCommand.cs

@@ -0,0 +1,16 @@
+using MediatR;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Command to update an existing Sample.
+/// VI: Command để cập nhật một Sample đã tồn tại.
+/// </summary>
+/// <param name="SampleId">EN: Sample ID to update / VI: ID sample cần cập nhật</param>
+/// <param name="Name">EN: New name / VI: Tên mới</param>
+/// <param name="Description">EN: New description / VI: Mô tả mới</param>
+public record UpdateSampleCommand(
+    Guid SampleId,
+    string Name,
+    string? Description
+) : IRequest<bool>;

services/order-service-net/src/OrderService.API/Application/Commands/UpdateSampleCommandHandler.cs

@@ -0,0 +1,54 @@
+using MediatR;
+using MyService.Domain.AggregatesModel.SampleAggregate;
+
+namespace MyService.API.Application.Commands;
+
+/// <summary>
+/// EN: Handler for UpdateSampleCommand.
+/// VI: Handler cho UpdateSampleCommand.
+/// </summary>
+public class UpdateSampleCommandHandler : IRequestHandler<UpdateSampleCommand, bool>
+{
+    private readonly ISampleRepository _sampleRepository;
+    private readonly ILogger<UpdateSampleCommandHandler> _logger;
+
+    public UpdateSampleCommandHandler(
+        ISampleRepository sampleRepository,
+        ILogger<UpdateSampleCommandHandler> logger)
+    {
+        _sampleRepository = sampleRepository ?? throw new ArgumentNullException(nameof(sampleRepository));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<bool> Handle(
+        UpdateSampleCommand request,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogInformation(
+            "Updating sample {SampleId} / Cập nhật sample {SampleId}",
+            request.SampleId);
+
+        // EN: Get existing sample / VI: Lấy sample đã tồn tại
+        var sample = await _sampleRepository.GetAsync(request.SampleId);
+
+        if (sample is null)
+        {
+            _logger.LogWarning(
+                "Sample {SampleId} not found / Sample {SampleId} không tìm thấy",
+                request.SampleId);
+            return false;
+        }
+
+        // EN: Update sample using domain method / VI: Cập nhật sample sử dụng domain method
+        sample.Update(request.Name, request.Description);
+
+        // EN: Save changes / VI: Lưu thay đổi
+        await _sampleRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Sample {SampleId} updated successfully / Sample {SampleId} đã cập nhật thành công",
+            request.SampleId);
+
+        return true;
+    }
+}

services/order-service-net/src/OrderService.API/Application/Queries/GetSampleQuery.cs

@@ -0,0 +1,23 @@
+using MediatR;
+
+namespace MyService.API.Application.Queries;
+
+/// <summary>
+/// EN: Query to get a Sample by ID.
+/// VI: Query để lấy một Sample theo ID.
+/// </summary>
+/// <param name="SampleId">EN: Sample ID / VI: ID sample</param>
+public record GetSampleQuery(Guid SampleId) : IRequest<SampleViewModel?>;
+
+/// <summary>
+/// EN: Sample view model for API responses.
+/// VI: Sample view model cho API responses.
+/// </summary>
+public record SampleViewModel(
+    Guid Id,
+    string Name,
+    string? Description,
+    string Status,
+    DateTime CreatedAt,
+    DateTime? UpdatedAt
+);

services/order-service-net/src/OrderService.API/Application/Queries/GetSampleQueryHandler.cs

@@ -0,0 +1,39 @@
+using MediatR;
+using MyService.Domain.AggregatesModel.SampleAggregate;
+
+namespace MyService.API.Application.Queries;
+
+/// <summary>
+/// EN: Handler for GetSampleQuery.
+/// VI: Handler cho GetSampleQuery.
+/// </summary>
+public class GetSampleQueryHandler : IRequestHandler<GetSampleQuery, SampleViewModel?>
+{
+    private readonly ISampleRepository _sampleRepository;
+
+    public GetSampleQueryHandler(ISampleRepository sampleRepository)
+    {
+        _sampleRepository = sampleRepository ?? throw new ArgumentNullException(nameof(sampleRepository));
+    }
+
+    public async Task<SampleViewModel?> Handle(
+        GetSampleQuery request,
+        CancellationToken cancellationToken)
+    {
+        var sample = await _sampleRepository.GetAsync(request.SampleId);
+
+        if (sample is null)
+        {
+            return null;
+        }
+
+        return new SampleViewModel(
+            sample.Id,
+            sample.Name,
+            sample.Description,
+            sample.Status.Name,
+            sample.CreatedAt,
+            sample.UpdatedAt
+        );
+    }
+}

services/order-service-net/src/OrderService.API/Application/Queries/GetSamplesQuery.cs

@@ -0,0 +1,9 @@
+using MediatR;
+
+namespace MyService.API.Application.Queries;
+
+/// <summary>
+/// EN: Query to get all Samples.
+/// VI: Query để lấy tất cả Samples.
+/// </summary>
+public record GetSamplesQuery : IRequest<IEnumerable<SampleViewModel>>;

services/order-service-net/src/OrderService.API/Application/Queries/GetSamplesQueryHandler.cs

@@ -0,0 +1,34 @@
+using MediatR;
+using MyService.Domain.AggregatesModel.SampleAggregate;
+
+namespace MyService.API.Application.Queries;
+
+/// <summary>
+/// EN: Handler for GetSamplesQuery.
+/// VI: Handler cho GetSamplesQuery.
+/// </summary>
+public class GetSamplesQueryHandler : IRequestHandler<GetSamplesQuery, IEnumerable<SampleViewModel>>
+{
+    private readonly ISampleRepository _sampleRepository;
+
+    public GetSamplesQueryHandler(ISampleRepository sampleRepository)
+    {
+        _sampleRepository = sampleRepository ?? throw new ArgumentNullException(nameof(sampleRepository));
+    }
+
+    public async Task<IEnumerable<SampleViewModel>> Handle(
+        GetSamplesQuery request,
+        CancellationToken cancellationToken)
+    {
+        var samples = await _sampleRepository.GetAllAsync();
+
+        return samples.Select(sample => new SampleViewModel(
+            sample.Id,
+            sample.Name,
+            sample.Description,
+            sample.Status.Name,
+            sample.CreatedAt,
+            sample.UpdatedAt
+        ));
+    }
+}

services/order-service-net/src/OrderService.API/Application/Validations/CreateSampleCommandValidator.cs

@@ -0,0 +1,25 @@
+using FluentValidation;
+using MyService.API.Application.Commands;
+
+namespace MyService.API.Application.Validations;
+
+/// <summary>
+/// EN: Validator for CreateSampleCommand.
+/// VI: Validator cho CreateSampleCommand.
+/// </summary>
+public class CreateSampleCommandValidator : AbstractValidator<CreateSampleCommand>
+{
+    public CreateSampleCommandValidator()
+    {
+        RuleFor(x => x.Name)
+            .NotEmpty()
+            .WithMessage("Name is required / Tên là bắt buộc")
+            .MaximumLength(200)
+            .WithMessage("Name must be less than 200 characters / Tên phải ít hơn 200 ký tự");
+
+        RuleFor(x => x.Description)
+            .MaximumLength(1000)
+            .WithMessage("Description must be less than 1000 characters / Mô tả phải ít hơn 1000 ký tự")
+            .When(x => x.Description != null);
+    }
+}

services/order-service-net/src/OrderService.API/Application/Validations/UpdateSampleCommandValidator.cs

@@ -0,0 +1,29 @@
+using FluentValidation;
+using MyService.API.Application.Commands;
+
+namespace MyService.API.Application.Validations;
+
+/// <summary>
+/// EN: Validator for UpdateSampleCommand.
+/// VI: Validator cho UpdateSampleCommand.
+/// </summary>
+public class UpdateSampleCommandValidator : AbstractValidator<UpdateSampleCommand>
+{
+    public UpdateSampleCommandValidator()
+    {
+        RuleFor(x => x.SampleId)
+            .NotEmpty()
+            .WithMessage("Sample ID is required / ID sample là bắt buộc");
+
+        RuleFor(x => x.Name)
+            .NotEmpty()
+            .WithMessage("Name is required / Tên là bắt buộc")
+            .MaximumLength(200)
+            .WithMessage("Name must be less than 200 characters / Tên phải ít hơn 200 ký tự");
+
+        RuleFor(x => x.Description)
+            .MaximumLength(1000)
+            .WithMessage("Description must be less than 1000 characters / Mô tả phải ít hơn 1000 ký tự")
+            .When(x => x.Description != null);
+    }
+}

services/order-service-net/src/OrderService.API/Controllers/SamplesController.cs

@@ -0,0 +1,200 @@
+using Asp.Versioning;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using MyService.API.Application.Commands;
+using MyService.API.Application.Queries;
+
+namespace MyService.API.Controllers;
+
+/// <summary>
+/// EN: Controller for Sample CRUD operations using CQRS pattern.
+/// VI: Controller cho các thao tác CRUD Sample sử dụng pattern CQRS.
+/// </summary>
+[ApiController]
+[ApiVersion("1.0")]
+[Route("api/v{version:apiVersion}/[controller]")]
+[Produces("application/json")]
+public class SamplesController : ControllerBase
+{
+    private readonly IMediator _mediator;
+    private readonly ILogger<SamplesController> _logger;
+
+    public SamplesController(IMediator mediator, ILogger<SamplesController> logger)
+    {
+        _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// EN: Get all samples.
+    /// VI: Lấy tất cả samples.
+    /// </summary>
+    /// <returns>EN: List of samples / VI: Danh sách samples</returns>
+    [HttpGet]
+    [ProducesResponseType(typeof(IEnumerable<SampleViewModel>), StatusCodes.Status200OK)]
+    public async Task<IActionResult> GetSamples()
+    {
+        var samples = await _mediator.Send(new GetSamplesQuery());
+        return Ok(new { success = true, data = samples });
+    }
+
+    /// <summary>
+    /// EN: Get a sample by ID.
+    /// VI: Lấy một sample theo ID.
+    /// </summary>
+    /// <param name="id">EN: Sample ID / VI: ID sample</param>
+    /// <returns>EN: Sample details / VI: Chi tiết sample</returns>
+    [HttpGet("{id:guid}")]
+    [ProducesResponseType(typeof(SampleViewModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetSample(Guid id)
+    {
+        var sample = await _mediator.Send(new GetSampleQuery(id));
+
+        if (sample is null)
+        {
+            return NotFound(new
+            {
+                success = false,
+                error = new
+                {
+                    code = "SAMPLE_NOT_FOUND",
+                    message = $"Sample with ID {id} not found / Sample với ID {id} không tìm thấy"
+                }
+            });
+        }
+
+        return Ok(new { success = true, data = sample });
+    }
+
+    /// <summary>
+    /// EN: Create a new sample.
+    /// VI: Tạo một sample mới.
+    /// </summary>
+    /// <param name="request">EN: Create request / VI: Request tạo</param>
+    /// <returns>EN: Created sample ID / VI: ID sample đã tạo</returns>
+    [HttpPost]
+    [ProducesResponseType(typeof(CreateSampleCommandResult), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<IActionResult> CreateSample([FromBody] CreateSampleRequest request)
+    {
+        var command = new CreateSampleCommand(request.Name, request.Description);
+        var result = await _mediator.Send(command);
+
+        return CreatedAtAction(
+            nameof(GetSample),
+            new { id = result.Id },
+            new { success = true, data = result });
+    }
+
+    /// <summary>
+    /// EN: Update an existing sample.
+    /// VI: Cập nhật một sample đã tồn tại.
+    /// </summary>
+    /// <param name="id">EN: Sample ID / VI: ID sample</param>
+    /// <param name="request">EN: Update request / VI: Request cập nhật</param>
+    /// <returns>EN: Success status / VI: Trạng thái thành công</returns>
+    [HttpPut("{id:guid}")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> UpdateSample(Guid id, [FromBody] UpdateSampleRequest request)
+    {
+        var command = new UpdateSampleCommand(id, request.Name, request.Description);
+        var result = await _mediator.Send(command);
+
+        if (!result)
+        {
+            return NotFound(new
+            {
+                success = false,
+                error = new
+                {
+                    code = "SAMPLE_NOT_FOUND",
+                    message = $"Sample with ID {id} not found / Sample với ID {id} không tìm thấy"
+                }
+            });
+        }
+
+        return Ok(new { success = true, message = "Sample updated successfully / Sample đã cập nhật thành công" });
+    }
+
+    /// <summary>
+    /// EN: Delete a sample.
+    /// VI: Xóa một sample.
+    /// </summary>
+    /// <param name="id">EN: Sample ID / VI: ID sample</param>
+    /// <returns>EN: Success status / VI: Trạng thái thành công</returns>
+    [HttpDelete("{id:guid}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> DeleteSample(Guid id)
+    {
+        var command = new DeleteSampleCommand(id);
+        var result = await _mediator.Send(command);
+
+        if (!result)
+        {
+            return NotFound(new
+            {
+                success = false,
+                error = new
+                {
+                    code = "SAMPLE_NOT_FOUND",
+                    message = $"Sample with ID {id} not found / Sample với ID {id} không tìm thấy"
+                }
+            });
+        }
+
+        return NoContent();
+    }
+
+    /// <summary>
+    /// EN: Change sample status.
+    /// VI: Thay đổi trạng thái sample.
+    /// </summary>
+    /// <param name="id">EN: Sample ID / VI: ID sample</param>
+    /// <param name="request">EN: Status change request / VI: Request thay đổi trạng thái</param>
+    /// <returns>EN: Success status / VI: Trạng thái thành công</returns>
+    [HttpPatch("{id:guid}/status")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> ChangeSampleStatus(Guid id, [FromBody] ChangeStatusRequest request)
+    {
+        var command = new ChangeSampleStatusCommand(id, request.Status);
+        var result = await _mediator.Send(command);
+
+        if (!result)
+        {
+            return BadRequest(new
+            {
+                success = false,
+                error = new
+                {
+                    code = "STATUS_CHANGE_FAILED",
+                    message = "Failed to change sample status / Thay đổi trạng thái sample thất bại"
+                }
+            });
+        }
+
+        return Ok(new { success = true, message = "Sample status changed successfully / Trạng thái sample đã thay đổi thành công" });
+    }
+}
+
+/// <summary>
+/// EN: Request model for creating a sample.
+/// VI: Model request để tạo sample.
+/// </summary>
+public record CreateSampleRequest(string Name, string? Description);
+
+/// <summary>
+/// EN: Request model for updating a sample.
+/// VI: Model request để cập nhật sample.
+/// </summary>
+public record UpdateSampleRequest(string Name, string? Description);
+
+/// <summary>
+/// EN: Request model for changing sample status.
+/// VI: Model request để thay đổi trạng thái sample.
+/// </summary>
+public record ChangeStatusRequest(string Status);

services/order-service-net/src/OrderService.API/OrderService.API.csproj

@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <AssemblyName>MyService.API</AssemblyName>
+    <RootNamespace>MyService.API</RootNamespace>
+    <Description>Web API layer with CQRS pattern</Description>
+    <UserSecretsId>myservice-api</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- EN: MediatR for CQRS / VI: MediatR cho CQRS -->
+    <PackageReference Include="MediatR" Version="12.4.1" />
+    
+    <!-- EN: FluentValidation for request validation / VI: FluentValidation cho validation request -->
+    <PackageReference Include="FluentValidation" Version="11.11.0" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.11.0" />
+    
+    <!-- EN: Swagger/OpenAPI / VI: Swagger/OpenAPI -->
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="7.2.0" />
+    
+    <!-- EN: API Versioning / VI: API Versioning -->
+    <PackageReference Include="Asp.Versioning.Mvc" Version="8.1.0" />
+    <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.0" />
+    
+    <!-- EN: Health checks / VI: Health checks -->
+    <PackageReference Include="AspNetCore.HealthChecks.NpgSql" Version="8.0.2" />
+    <PackageReference Include="AspNetCore.HealthChecks.Redis" Version="8.0.1" />
+    
+    <!-- EN: Problem Details (RFC 7807) / VI: Problem Details (RFC 7807) -->
+    <PackageReference Include="Hellang.Middleware.ProblemDetails" Version="6.5.1" />
+    
+    <!-- EN: Serilog for structured logging / VI: Serilog cho structured logging -->
+    <PackageReference Include="Serilog.AspNetCore" Version="8.0.3" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.Seq" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MyService.Domain\MyService.Domain.csproj" />
+    <ProjectReference Include="..\MyService.Infrastructure\MyService.Infrastructure.csproj" />
+  </ItemGroup>
+
+</Project>

services/order-service-net/src/OrderService.API/Program.cs

@@ -0,0 +1,144 @@
+using Asp.Versioning;
+using FluentValidation;
+using Hellang.Middleware.ProblemDetails;
+using MyService.API.Application.Behaviors;
+using MyService.Infrastructure;
+using Serilog;
+
+// EN: Configure Serilog early / VI: Cấu hình Serilog sớm
+Log.Logger = new LoggerConfiguration()
+    .WriteTo.Console()
+    .CreateBootstrapLogger();
+
+try
+{
+    Log.Information("Starting MyService API / Khởi động MyService API");
+
+    var builder = WebApplication.CreateBuilder(args);
+
+    // EN: Configure Serilog / VI: Cấu hình Serilog
+    builder.Host.UseSerilog((context, services, configuration) => configuration
+        .ReadFrom.Configuration(context.Configuration)
+        .ReadFrom.Services(services)
+        .Enrich.FromLogContext()
+        .WriteTo.Console());
+
+    // EN: Add Infrastructure services / VI: Thêm Infrastructure services
+    builder.Services.AddInfrastructure(builder.Configuration);
+
+    // EN: Add MediatR with behaviors / VI: Thêm MediatR với behaviors
+    builder.Services.AddMediatR(cfg =>
+    {
+        cfg.RegisterServicesFromAssemblyContaining<Program>();
+        cfg.AddOpenBehavior(typeof(LoggingBehavior<,>));
+        cfg.AddOpenBehavior(typeof(ValidatorBehavior<,>));
+        cfg.AddOpenBehavior(typeof(TransactionBehavior<,>));
+    });
+
+    // EN: Add FluentValidation / VI: Thêm FluentValidation
+    builder.Services.AddValidatorsFromAssemblyContaining<Program>();
+
+    // EN: Add API versioning / VI: Thêm API versioning
+    builder.Services.AddApiVersioning(options =>
+    {
+        options.DefaultApiVersion = new ApiVersion(1, 0);
+        options.AssumeDefaultVersionWhenUnspecified = true;
+        options.ReportApiVersions = true;
+        options.ApiVersionReader = ApiVersionReader.Combine(
+            new UrlSegmentApiVersionReader(),
+            new HeaderApiVersionReader("X-Api-Version"));
+    })
+    .AddApiExplorer(options =>
+    {
+        options.GroupNameFormat = "'v'VVV";
+        options.SubstituteApiVersionInUrl = true;
+    });
+
+    // EN: Add controllers / VI: Thêm controllers
+    builder.Services.AddControllers();
+
+    // EN: Add ProblemDetails middleware (RFC 7807) / VI: Thêm ProblemDetails middleware
+    builder.Services.AddProblemDetails(options =>
+    {
+        options.IncludeExceptionDetails = (ctx, ex) =>
+            builder.Environment.IsDevelopment();
+    });
+
+    // EN: Add Swagger / VI: Thêm Swagger
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen(options =>
+    {
+        options.SwaggerDoc("v1", new()
+        {
+            Title = "MyService API",
+            Version = "v1",
+            Description = "MyService microservice API / API microservice MyService"
+        });
+    });
+
+    // EN: Add health checks / VI: Thêm health checks
+    builder.Services.AddHealthChecks()
+        .AddNpgSql(
+            builder.Configuration.GetConnectionString("DefaultConnection")
+                ?? builder.Configuration["DATABASE_URL"]
+                ?? "",
+            name: "postgresql",
+            tags: ["db", "postgresql"]);
+
+    // EN: Add CORS / VI: Thêm CORS
+    builder.Services.AddCors(options =>
+    {
+        options.AddDefaultPolicy(policy =>
+        {
+            policy.AllowAnyOrigin()
+                  .AllowAnyMethod()
+                  .AllowAnyHeader();
+        });
+    });
+
+    var app = builder.Build();
+
+    // EN: Configure middleware pipeline / VI: Cấu hình middleware pipeline
+    app.UseSerilogRequestLogging();
+    app.UseProblemDetails();
+
+    if (app.Environment.IsDevelopment())
+    {
+        app.UseSwagger();
+        app.UseSwaggerUI(c =>
+        {
+            c.SwaggerEndpoint("/swagger/v1/swagger.json", "MyService API v1");
+            c.RoutePrefix = "swagger";
+        });
+    }
+
+    app.UseCors();
+    app.UseRouting();
+
+    // EN: Map health check endpoints / VI: Map health check endpoints
+    app.MapHealthChecks("/health");
+    app.MapHealthChecks("/health/live", new()
+    {
+        Predicate = _ => false // EN: Just checks app is running / VI: Chỉ kiểm tra app đang chạy
+    });
+    app.MapHealthChecks("/health/ready");
+
+    // EN: Map controllers / VI: Map controllers
+    app.MapControllers();
+
+    // EN: Run the application / VI: Chạy ứng dụng
+    app.Run();
+}
+catch (Exception ex)
+{
+    Log.Fatal(ex, "Application terminated unexpectedly / Ứng dụng kết thúc bất ngờ");
+    throw;
+}
+finally
+{
+    Log.CloseAndFlush();
+}
+
+// EN: Make Program class accessible for integration tests
+// VI: Làm cho class Program có thể truy cập cho integration tests
+public partial class Program { }

services/order-service-net/src/OrderService.API/Properties/launchSettings.json

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

services/order-service-net/src/OrderService.API/appsettings.Development.json

@@ -0,0 +1,19 @@
+{
+    "Logging": {
+        "LogLevel": {
+            "Default": "Debug",
+            "Microsoft.AspNetCore": "Information",
+            "Microsoft.EntityFrameworkCore.Database.Command": "Information"
+        }
+    },
+    "Serilog": {
+        "MinimumLevel": {
+            "Default": "Debug",
+            "Override": {
+                "Microsoft": "Information",
+                "Microsoft.EntityFrameworkCore.Database.Command": "Information",
+                "System": "Information"
+            }
+        }
+    }
+}

services/order-service-net/src/OrderService.API/appsettings.json

@@ -0,0 +1,46 @@
+{
+    "Logging": {
+        "LogLevel": {
+            "Default": "Information",
+            "Microsoft.AspNetCore": "Warning",
+            "Microsoft.EntityFrameworkCore": "Warning"
+        }
+    },
+    "Serilog": {
+        "MinimumLevel": {
+            "Default": "Information",
+            "Override": {
+                "Microsoft": "Warning",
+                "Microsoft.EntityFrameworkCore": "Warning",
+                "System": "Warning"
+            }
+        },
+        "WriteTo": [
+            {
+                "Name": "Console",
+                "Args": {
+                    "outputTemplate": "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj} {Properties:j}{NewLine}{Exception}"
+                }
+            }
+        ],
+        "Enrich": [
+            "FromLogContext",
+            "WithMachineName",
+            "WithThreadId"
+        ]
+    },
+    "ConnectionStrings": {
+        "DefaultConnection": "Host=localhost;Port=5432;Database=myservice_db;Username=postgres;Password=postgres"
+    },
+    "Redis": {
+        "ConnectionString": "localhost:6379"
+    },
+    "Jwt": {
+        "Secret": "your-super-secret-key-min-32-characters",
+        "Issuer": "goodgo-platform",
+        "Audience": "goodgo-services",
+        "AccessTokenExpiryMinutes": 15,
+        "RefreshTokenExpiryDays": 7
+    },
+    "AllowedHosts": "*"
+}