Application Services

// Example AutoMapper Profile
public class ShopApplicationAutoMapperProfile : Profile
{
    public ShopApplicationAutoMapperProfile()
    {
        // Product mappings
        CreateMap<Product, ProductDto>()
            .ForMember(d => d.BrandName, opt => opt.MapFrom(s => s.Brand.Name))
            .ForMember(d => d.CategoryIds, opt => opt.Ignore())
            .ForMember(d => d.CategoryNames, opt => opt.Ignore());

        CreateMap<CreateProductDto, Product>()
            .ForMember(d => d.Id, opt => opt.Ignore());

        CreateMap<UpdateProductDto, Product>()
            .ForMember(d => d.Id, opt => opt.Ignore());

        // Order mappings
        CreateMap<Order, OrderDto>()
            .ForMember(d => d.Items, opt => opt.MapFrom(s => s.Items));

        CreateMap<OrderItem, OrderItemDto>();

        CreateMap<CreateOrderDto, Order>()
            .ForMember(d => d.Id, opt => opt.Ignore())
            .ForMember(d => d.OrderNumber, opt => opt.Ignore());
    }
}

public class ProductAppService : ApplicationService, IProductAppService
{
    private readonly IRepository<Product, Guid> _productRepository;
    private readonly IRepository<Brand, Guid> _brandRepository;
    private readonly CacheService _cacheService;

    public async Task<ProductDto> GetAsync(Guid id)
    {
        // Try cache first (2-hour TTL)
        var cacheKey = CacheKeys.GetProductDetailsKey(id);
        var cachedDto = await _cacheService.GetOrCreateAsync(
            cacheKey,
            async () => await GetProductDtoAsync(id),
            TimeSpan.FromHours(2)
        );

        return cachedDto;
    }

    private async Task<ProductDto> GetProductDtoAsync(Guid id)
    {
        var product = await _productRepository.GetAsync(id);
        var dto = ObjectMapper.Map<Product, ProductDto>(product);

        // Load related data
        if (product.BrandId.HasValue)
        {
            var brand = await _brandRepository.FindAsync(product.BrandId.Value);
            dto.BrandName = brand?.Name;
        }

        return dto;
    }

    public async Task<ProductDto> CreateAsync(CreateProductDto input)
    {
        // Validate slug uniqueness
        var existingProduct = await _productRepository
            .FirstOrDefaultAsync(x => x.Slug == input.Slug);

        if (existingProduct != null)
        {
            throw new UserFriendlyException("این نام مستعار قبلاً استفاده شده است");
        }

        // Create entity
        var product = new Product(GuidGenerator.Create(), input.Name, input.Slug);
        product.Price = input.Price;
        product.Description = input.Description;
        // ... set other properties

        await _productRepository.InsertAsync(product);

        // Invalidate related caches
        await _cacheInvalidationService.InvalidateProductCacheAsync(product.Id);

        return ObjectMapper.Map<Product, ProductDto>(product);
    }
}

public class OrderAppService : ApplicationService, IOrderAppService
{
    private readonly IRepository<Order, Guid> _orderRepository;
    private readonly IRepository<Cart, Guid> _cartRepository;
    private readonly IRepository<Product, Guid> _productRepository;
    private readonly ICurrentUser _currentUser;

    public async Task<OrderDto> CreateFromCartAsync(CreateOrderFromCartDto input)
    {
        // Authorize
        if (!_currentUser.IsAuthenticated)
        {
            throw new UserFriendlyException("لطفاً وارد حساب کاربری خود شوید");
        }

        // Get user's cart
        var cart = await _cartRepository
            .Include(c => c.Items)
            .FirstOrDefaultAsync(c => c.UserId == _currentUser.Id && c.IsActive);

        if (cart == null || !cart.Items.Any())
        {
            throw new UserFriendlyException("سبد خرید شما خالی است");
        }

        // Validate stock availability
        foreach (var item in cart.Items)
        {
            var product = await _productRepository.GetAsync(item.ProductId);
            if (product.StockQuantity < item.Quantity)
            {
                throw new UserFriendlyException($"محصول {product.Name} موجود نیست");
            }
        }

        // Create order
        var orderNumber = await GenerateOrderNumberAsync();
        var order = new Order(GuidGenerator.Create(), orderNumber);
        order.UserId = _currentUser.Id;
        order.CustomerName = input.CustomerName;
        order.CustomerEmail = input.CustomerEmail;
        order.CustomerPhone = input.CustomerPhone;
        order.ShippingAddress = input.ShippingAddress;
        order.Subtotal = cart.Subtotal;
        order.Total = cart.Total;
        order.Status = OrderStatus.Pending;

        // Add order items from cart
        foreach (var cartItem in cart.Items)
        {
            var orderItem = new OrderItem(GuidGenerator.Create());
            orderItem.OrderId = order.Id;
            orderItem.ProductId = cartItem.ProductId;
            orderItem.ProductName = cartItem.ProductName;
            orderItem.Quantity = cartItem.Quantity;
            orderItem.UnitPrice = cartItem.Price;
            orderItem.LineTotal = cartItem.Quantity * cartItem.Price;

            order.Items.Add(orderItem);

            // Decrease product stock
            var product = await _productRepository.GetAsync(cartItem.ProductId);
            product.DecreaseStock(cartItem.Quantity);
            await _productRepository.UpdateAsync(product);
        }

        await _orderRepository.InsertAsync(order);

        // Clear cart
        cart.IsActive = false;
        await _cartRepository.UpdateAsync(cart);

        // Send notification
        await _notificationService.SendOrderConfirmationAsync(order.Id);

        return ObjectMapper.Map<Order, OrderDto>(order);
    }

    private async Task<string> GenerateOrderNumberAsync()
    {
        // Generate unique order number: ORD-20251004-0001
        var date = DateTime.Now.ToString("yyyyMMdd");
        var count = await _orderRepository
            .CountAsync(o => o.OrderNumber.StartsWith($"ORD-{date}"));

        return $"ORD-{date}-{(count + 1):D4}";
    }
}

public async Task<CartDto> ApplyDiscountCodeAsync(string code)
{
    // Get user's cart
    var cart = await GetOrCreateCartAsync();

    // Validate discount code
    var discount = await _discountRepository
        .FirstOrDefaultAsync(d => d.Code == code && d.IsActive);

    if (discount == null)
    {
        throw new UserFriendlyException("کد تخفیف معتبر نیست");
    }

    // Check date range
    if (discount.StartDate > DateTime.Now || discount.EndDate < DateTime.Now)
    {
        throw new UserFriendlyException("کد تخفیف منقضی شده است");
    }

    // Check minimum order amount
    if (discount.MinimumOrderAmount.HasValue &&
        cart.Subtotal < discount.MinimumOrderAmount.Value)
    {
        throw new UserFriendlyException(
            $"حداقل مبلغ سفارش برای این کد تخفیف {discount.MinimumOrderAmount:N0} تومان است"
        );
    }

    // Calculate discount amount
    decimal discountAmount = 0;
    if (discount.DiscountType == DiscountType.Percentage)
    {
        discountAmount = cart.Subtotal * (discount.DiscountValue / 100);
        if (discount.MaximumDiscountAmount.HasValue)
        {
            discountAmount = Math.Min(discountAmount, discount.MaximumDiscountAmount.Value);
        }
    }
    else
    {
        discountAmount = discount.DiscountValue;
    }

    // Apply discount
    cart.DiscountCode = code;
    cart.DiscountAmount = discountAmount;
    cart.Total = cart.Subtotal - discountAmount;

    await _cartRepository.UpdateAsync(cart);

    // Invalidate cache
    await _cacheInvalidationService.InvalidateUserCacheAsync(_currentUser.Id.Value);

    return ObjectMapper.Map<Cart, CartDto>(cart);
}