‫Domain-Driven Design (DDD)؛ بخش آخر: یک پروژه

• Catalog: این بخش مربوط به مدیریت محصولات است.
• Ordering: این بخش مربوط به فرآیند ثبت و مدیریت سفارش است.
• Payments: این بخش مسئول پردازش پرداخت‌ها است.

• Ordering به Catalog وابسته است تا اطلاعات محصولات را دریافت کند.
• Ordering با Payments برای پردازش پرداخت‌ها ارتباط برقرار می‌کند.

• Aggregate Root:Product
• Value Objects:Price, SKU
• Repository:IProductRepository
• Application Service:CatalogService برای مدیریت نمایش محصولات.

• Aggregate Root:Order
• Entities:OrderItem
• Value Objects:ShippingAddress
• Repository:IOrderRepository
• Domain Service:OrderingService برای هماهنگی فرآیند ثبت سفارش.

• ساختار پروژه: پروژه را به صورت لایه‌ای (Clean Architecture) سازماندهی می‌کنیم تا هر Bounded Context در یک پروژه جداگانه قرار بگیرد.
• نگاشت با EF Core: با استفاده از Owned Entities، private setters و Unit of Work، مدل‌های دامنه‌مان را به دیتابیس نگاشت می‌کنیم.
• ارتباط بین Context ها: از الگوهایی مانند Domain Events برای ارتباط بین Ordering و Payments استفاده می‌کنیم تا وابستگی‌های مستقیم را کاهش دهیم.

• ببینید که مفاهیم DDD چگونه به صورت عملی به یکدیگر متصل می‌شوند.
• تفاوت بین Anemic Model و Rich Model را به صورت عملی لمس کنید.
• با چالش‌های دنیای واقعی، مانند ارتباط بین سرویس‌ها، روبرو شوید و راه‌حل‌های DDD را برای آن‌ها پیاده‌سازی کنید.

• Aggregates: پوشه‌ای برای ریشه‌های تجمیع (Aggregate Roots).
• Entities: پوشه‌ای برای موجودیت‌ها.
• ValueObjects: پوشه‌ای برای اشیاء ارزشی.
• DomainEvents: پوشه‌ای برای رویدادهای دامنه.
• DomainServices: پوشه‌ای برای سرویس‌های دامنه‌ای که منطق مربوط به چندین Aggregate را مدیریت می‌کنند.
• Interfaces: شامل واسط‌هایی مانند IAggregateRoot و IUnitOfWork.

• Commands: پوشه‌ای برای فرمان‌ها. هر فرمان، یک عملیات نوشتن را تعریف می‌کند.
• Queries: پوشه‌ای برای پرس‌وجوها. هر پرس‌وجو، یک عملیات خواندن را تعریف می‌کند.
• Handlers: پوشه‌ای برای CommandHandlers و QueryHandlers که منطق مربوط به هر فرمان و پرس‌وجو را مدیریت می‌کنند.
• Interfaces: واسط‌هایی که Application Services را تعریف می‌کنند.

• DbContext: کلاس اصلی DbContext برای EF Core.
• Repositories: پیاده‌سازی واسط‌های Repository که در لایه Domain تعریف شده‌اند.
• Configurations: پیکربندی‌های نگاشت Entities و Value Objects به دیتابیس.

• Controllers: کنترلرها برای API. این کنترلرها فقط با Application Services (یا Command و Query ها) صحبت می‌کنند و هیچ اطلاعی از لایه‌های داخلی‌تر ندارند.
• Dtos: کلاس‌های DTO (Data Transfer Objects) که برای انتقال داده بین لایه ارائه و Application Services استفاده می‌شوند.

• OrderController یک CreateOrderCommand را از درخواست دریافت می‌کند.
• این Controller، CreateOrderCommand را به CommandHandler مربوطه در لایه Application ارسال می‌کند.

• CreateOrderCommandHandler فرمان را دریافت می‌کند.
• این CommandHandler با استفاده از IOrderRepository، یک نمونه جدید از Aggregate Root به نام Order را ایجاد می‌کند.
• سپس، Order را از طریق Repository به دیتابیس اضافه می‌کند.
• در نهایت، Unit of Work را ذخیره می‌کند تا تغییرات به صورت یکپارچه در دیتابیس اعمال شوند.

• تمام قوانین تجاری مربوط به ایجاد سفارش در داخل Order Aggregate مدیریت می‌شوند. این کلاس تضمین می‌کند که سفارش در یک وضعیت سازگار ایجاد می‌شود.

• OrderRepository (که یک پیاده‌سازی EF Core است) مسئول ذخیره Order Aggregate در دیتابیس است. این پیاده‌سازی در لایه زیرساخت قرار دارد و به لایه‌های بالاتر وابسته نیست.

namespace OnlineStore.Catalog.Domain
{
    public enum ProductStatus
    {
        Available,
        Discontinued
    }
    
    public class Price : ValueObject
    {
        public decimal Value { get; }
        public string Currency { get; }

        public Price(decimal value, string currency)
        {
            if (value < 0) throw new ArgumentException("Price cannot be negative.");
            this.Value = value;
            this.Currency = currency;
        }

        protected override IEnumerable<object> GetEqualityComponents()
        {
            yield return Value;
            yield return Currency;
        }
    }
    
    public class Product : Entity, IAggregateRoot
    {
        public string Name { get; private set; }
        public Price Price { get; private set; }
        public ProductStatus Status { get; private set; }

        // Private constructor for EF Core
        private Product() { }

        public Product(Guid id, string name, Price price)
        {
            this.Id = id;
            this.Name = name;
            this.Price = price;
            this.Status = ProductStatus.Available;
        }

        public void ChangePrice(Price newPrice)
        {
            if (newPrice == null) throw new ArgumentNullException(nameof(newPrice));
            this.Price = newPrice;
            // You could add a Domain Event here: new ProductPriceChangedEvent(this.Id, newPrice);
        }
    }
}

namespace OnlineStore.Catalog.Domain
{
    public interface IProductRepository
    {
        Task<Product> GetByIdAsync(Guid id);
        Task AddAsync(Product product);
        // We will not have a "Remove" method as a product is typically not removed.
    }
}

using Microsoft.EntityFrameworkCore;
using OnlineStore.Catalog.Domain;

namespace OnlineStore.Catalog.Infrastructure
{
    public class ProductRepository : IProductRepository
    {
        private readonly CatalogDbContext _context;

        public ProductRepository(CatalogDbContext context)
        {
            _context = context;
        }

        public async Task<Product> GetByIdAsync(Guid id)
        {
            return await _context.Products.SingleOrDefaultAsync(p => p.Id == id);
        }

        public async Task AddAsync(Product product)
        {
            await _context.Products.AddAsync(product);
        }
    }
}

namespace OnlineStore.Ordering.Domain
{
    public enum OrderStatus
    {
        Pending,
        Paid,
        Shipped,
        Cancelled
    }

    public class OrderItem : Entity
    {
        public Guid ProductId { get; private set; }
        public string ProductName { get; private set; }
        public decimal UnitPrice { get; private set; }
        public int Units { get; private set; }

        private OrderItem() { }

        public OrderItem(Guid productId, string productName, decimal unitPrice, int units)
        {
            this.ProductId = productId;
            this.ProductName = productName;
            this.UnitPrice = unitPrice;
            this.Units = units;
        }
    }

    public class Order : Entity, IAggregateRoot
    {
        public OrderStatus Status { get; private set; }
        public Guid CustomerId { get; private set; }
        public DateTime OrderDate { get; private set; }
        
        private readonly List<OrderItem> _orderItems = new List<OrderItem>();
        public IReadOnlyList<OrderItem> OrderItems => _orderItems.AsReadOnly();

        private Order() { }

        public Order(Guid customerId)
        {
            this.Id = Guid.NewGuid();
            this.CustomerId = customerId;
            this.OrderDate = DateTime.UtcNow;
            this.Status = OrderStatus.Pending;
        }

        public void AddItem(Guid productId, string productName, decimal unitPrice, int units)
        {
            var existingItem = _orderItems.SingleOrDefault(o => o.ProductId == productId);
            if (existingItem != null)
            {
                // Logic to update existing item
            }
            else
            {
                var orderItem = new OrderItem(productId, productName, unitPrice, units);
                _orderItems.Add(orderItem);
            }
        }
        
        public void MarkAsPaid()
        {
            if (this.Status != OrderStatus.Pending)
            {
                throw new InvalidOperationException("Order cannot be marked as paid.");
            }
            this.Status = OrderStatus.Paid;
            // This is a crucial point for a Domain Event
            // AddDomainEvent(new OrderPaidEvent(this.Id, this.OrderItems));
        }
    }
}

namespace OnlineStore.Ordering.Domain
{
    public interface IOrderRepository
    {
        Task<Order> GetByIdAsync(Guid id);
        Task AddAsync(Order order);
    }
}

using Microsoft.EntityFrameworkCore;
using OnlineStore.Ordering.Domain;

namespace OnlineStore.Ordering.Infrastructure
{
    public class OrderRepository : IOrderRepository
    {
        private readonly OrderingDbContext _context;

        public OrderRepository(OrderingDbContext context)
        {
            _context = context;
        }

        public async Task<Order> GetByIdAsync(Guid id)
        {
            return await _context.Orders.SingleOrDefaultAsync(o => o.Id == id);
        }

        public async Task AddAsync(Order order)
        {
            await _context.Orders.AddAsync(order);
        }
    }
}

using OnlineStore.Ordering.Domain;
using OnlineStore.Ordering.Infrastructure;

namespace OnlineStore.Ordering.Application
{
    public class OrderingService
    {
        private readonly IOrderRepository _orderRepository;
        // Other repositories or domain services might be injected here

        public OrderingService(IOrderRepository orderRepository)
        {
            _orderRepository = orderRepository;
        }

        public async Task CreateOrder(Guid customerId, List<OrderItemDto> items)
        {
            var order = new Order(customerId);
            foreach (var item in items)
            {
                order.AddItem(item.ProductId, item.ProductName, item.UnitPrice, item.Units);
            }
            
            await _orderRepository.AddAsync(order);
            // The DbContext SaveChanges would be handled by a Unit of Work
        }
    }
}

// File: Application/Commands/CreateOrderCommand.cs

using OnlineStore.Ordering.Application.Dtos;
using MediatR; // We use MediatR for clean command handling

namespace OnlineStore.Ordering.Application.Commands
{
    public class CreateOrderCommand : IRequest<Guid>
    {
        public Guid CustomerId { get; set; }
        public List<OrderItemDto> Items { get; set; }
    }

    public class OrderItemDto
    {
        public Guid ProductId { get; set; }
        public string ProductName { get; set; }
        public decimal UnitPrice { get; set; }
        public int Units { get; set; }
    }
}

// File: Application/Handlers/CreateOrderCommandHandler.cs

using MediatR;
using OnlineStore.Ordering.Application.Commands;
using OnlineStore.Ordering.Domain;
using OnlineStore.Core.Domain; // Assume IUnitOfWork is here

namespace OnlineStore.Ordering.Application.Handlers
{
    public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, Guid>
    {
        private readonly IOrderRepository _orderRepository;
        private readonly IUnitOfWork _unitOfWork;

        public CreateOrderCommandHandler(IOrderRepository orderRepository, IUnitOfWork unitOfWork)
        {
            _orderRepository = orderRepository;
            _unitOfWork = unitOfWork;
        }

        public async Task<Guid> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
        {
            // 1. Create the Order Aggregate
            var order = new Order(request.CustomerId);

            foreach (var itemDto in request.Items)
            {
                order.AddItem(
                    itemDto.ProductId,
                    itemDto.ProductName,
                    itemDto.UnitPrice,
                    itemDto.Units);
            }

            // 2. Add the Aggregate to the Repository
            await _orderRepository.AddAsync(order);

            // 3. Save changes using Unit of Work
            await _unitOfWork.SaveAsync(cancellationToken);

            return order.Id;
        }
    }
}

// File: Infrastructure/UnitOfWork.cs

using OnlineStore.Ordering.Infrastructure.Context;
using OnlineStore.Core.Domain;
using System.Threading.Tasks;

namespace OnlineStore.Ordering.Infrastructure
{
    public class UnitOfWork : IUnitOfWork
    {
        private readonly OrderingDbContext _context;

        public UnitOfWork(OrderingDbContext context)
        {
            _context = context;
        }

        public async Task SaveAsync(CancellationToken cancellationToken = default)
        {
            await _context.SaveChangesAsync(cancellationToken);
        }
    }
}

// File: WebApi/Controllers/OrdersController.cs

using MediatR;
using Microsoft.AspNetCore.Mvc;
using OnlineStore.Ordering.Application.Commands;

namespace OnlineStore.WebApi.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class OrdersController : ControllerBase
    {
        private readonly IMediator _mediator;

        public OrdersController(IMediator mediator)
        {
            _mediator = mediator;
        }

        [HttpPost("create")]
        public async Task<IActionResult> CreateOrder([FromBody] CreateOrderCommand command)
        {
            var orderId = await _mediator.Send(command);
            return Ok(new { OrderId = orderId });
        }
    }
}

// File: WebApi/Program.cs (or Startup.cs)

using OnlineStore.Ordering.Application.Handlers;
using OnlineStore.Ordering.Domain;
using OnlineStore.Ordering.Infrastructure;
using OnlineStore.Ordering.Infrastructure.Context;
using MediatR;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();

// Configure MediatR
builder.Services.AddMediatR(typeof(CreateOrderCommandHandler).Assembly);

// Add DbContext
builder.Services.AddDbContext<OrderingDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("OrderingDb")));

// Register our Repositories and Unit of Work
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();

var app = builder.Build();

// Configure the HTTP request pipeline.
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();