360 lines
18 KiB
C#
360 lines
18 KiB
C#
// src/Webshop.Application/Services/Customers/CheckoutService.cs
|
|
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Logging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Webshop.Application;
|
|
using Webshop.Application.DTOs.Customers;
|
|
using Webshop.Application.DTOs.Orders;
|
|
using Webshop.Application.DTOs.Shipping;
|
|
using Webshop.Application.Services.Customers.Interfaces;
|
|
using Webshop.Application.Services.Public.Interfaces;
|
|
using Webshop.Application.Services.Public; // Für DiscountCalculationResult
|
|
using Webshop.Domain.Entities;
|
|
using Webshop.Domain.Enums;
|
|
using Webshop.Domain.Interfaces;
|
|
using Webshop.Infrastructure.Data;
|
|
|
|
namespace Webshop.Application.Services.Customers
|
|
{
|
|
public class CheckoutService : ICheckoutService
|
|
{
|
|
private readonly ApplicationDbContext _context;
|
|
private readonly IOrderRepository _orderRepository;
|
|
private readonly ICustomerRepository _customerRepository;
|
|
private readonly IShippingMethodRepository _shippingMethodRepository;
|
|
private readonly ISettingService _settingService;
|
|
private readonly IDiscountService _discountService;
|
|
private readonly ICartService _cartService;
|
|
private readonly IEmailService _emailService;
|
|
private readonly ILogger<CheckoutService> _logger;
|
|
|
|
public CheckoutService(
|
|
ApplicationDbContext context,
|
|
IOrderRepository orderRepository,
|
|
ICustomerRepository customerRepository,
|
|
IShippingMethodRepository shippingMethodRepository,
|
|
ISettingService settingService,
|
|
IDiscountService discountService,
|
|
ICartService cartService,
|
|
IEmailService emailService,
|
|
ILogger<CheckoutService> logger)
|
|
{
|
|
_context = context;
|
|
_orderRepository = orderRepository;
|
|
_customerRepository = customerRepository;
|
|
_shippingMethodRepository = shippingMethodRepository;
|
|
_settingService = settingService;
|
|
_discountService = discountService;
|
|
_cartService = cartService;
|
|
_emailService = emailService;
|
|
_logger = logger;
|
|
}
|
|
|
|
// =================================================================================
|
|
// FIX: Überladung für CartItemDto (Löst den Konvertierungsfehler im Controller)
|
|
// =================================================================================
|
|
public async Task<ServiceResult<IEnumerable<ShippingMethodDto>>> GetCompatibleShippingMethodsAsync(List<CartItemDto> items)
|
|
{
|
|
// Mappe CartItemDto zu CreateOrderItemDto, damit wir die Logik wiederverwenden können
|
|
var mappedItems = items.Select(x => new CreateOrderItemDto
|
|
{
|
|
ProductId = x.ProductId,
|
|
Quantity = x.Quantity,
|
|
ProductVariantId = x.ProductVariantId
|
|
});
|
|
return await GetCompatibleShippingMethodsAsync(mappedItems);
|
|
}
|
|
|
|
// Die Hauptlogik basierend auf CreateOrderItemDto (für den Checkout)
|
|
public async Task<ServiceResult<IEnumerable<ShippingMethodDto>>> GetCompatibleShippingMethodsAsync(IEnumerable<CreateOrderItemDto> items)
|
|
{
|
|
if (items == null || !items.Any())
|
|
return ServiceResult.Ok<IEnumerable<ShippingMethodDto>>(new List<ShippingMethodDto>());
|
|
|
|
var productIds = items.Select(i => i.ProductId).ToList();
|
|
var products = await _context.Products.Where(p => productIds.Contains(p.Id)).ToListAsync();
|
|
|
|
decimal totalWeight = 0;
|
|
foreach (var item in items)
|
|
{
|
|
var product = products.FirstOrDefault(p => p.Id == item.ProductId);
|
|
if (product != null)
|
|
{
|
|
totalWeight += (decimal)(product.Weight ?? 0) * item.Quantity;
|
|
}
|
|
}
|
|
|
|
var allMethods = await _shippingMethodRepository.GetAllAsync();
|
|
var compatibleMethods = allMethods
|
|
.Where(sm => sm.IsActive && totalWeight >= sm.MinWeight && totalWeight <= sm.MaxWeight)
|
|
.Select(sm => new ShippingMethodDto
|
|
{
|
|
Id = sm.Id,
|
|
Name = sm.Name,
|
|
Description = sm.Description,
|
|
Cost = sm.BaseCost,
|
|
IsActive = sm.IsActive,
|
|
MinDeliveryDays = sm.MinDeliveryDays,
|
|
MaxDeliveryDays = sm.MaxDeliveryDays,
|
|
MinWeight = sm.MinWeight,
|
|
MaxWeight = sm.MaxWeight
|
|
})
|
|
.ToList();
|
|
|
|
return ServiceResult.Ok<IEnumerable<ShippingMethodDto>>(compatibleMethods);
|
|
}
|
|
|
|
public async Task<ServiceResult<OrderDetailDto>> CreateOrderAsync(CreateOrderDto orderDto, string? userId)
|
|
{
|
|
await using var transaction = await _context.Database.BeginTransactionAsync();
|
|
try
|
|
{
|
|
// 1.1 Kunde Validieren
|
|
var customer = await _customerRepository.GetByUserIdAsync(userId!);
|
|
if (customer == null)
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.Unauthorized, "Kundenprofil nicht gefunden.");
|
|
|
|
// =================================================================================
|
|
// FIX: E-Mail holen (Passend zu deiner Entity Customer.cs)
|
|
// Customer hat keine Email, aber eine AspNetUserId. Wir holen die Mail aus der Users Tabelle.
|
|
// =================================================================================
|
|
var userEmail = await _context.Users
|
|
.Where(u => u.Id == userId) // userId entspricht customer.AspNetUserId
|
|
.Select(u => u.Email)
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (string.IsNullOrEmpty(userEmail))
|
|
{
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.Failure, "Keine E-Mail-Adresse für den Benutzer gefunden.");
|
|
}
|
|
|
|
// 1.2 Adressen Validieren
|
|
var addresses = await _context.Addresses
|
|
.Where(a => (a.Id == orderDto.ShippingAddressId || a.Id == orderDto.BillingAddressId) && a.CustomerId == customer.Id)
|
|
.ToListAsync();
|
|
|
|
if (!addresses.Any(a => a.Id == orderDto.ShippingAddressId) || !addresses.Any(a => a.Id == orderDto.BillingAddressId))
|
|
{
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.Forbidden, "Die angegebenen Adressen sind ungültig oder gehören nicht zu diesem Konto.");
|
|
}
|
|
|
|
// 1.3 Methoden Validieren
|
|
var shippingMethod = await _shippingMethodRepository.GetByIdAsync(orderDto.ShippingMethodId);
|
|
if (shippingMethod == null || !shippingMethod.IsActive)
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.InvalidInput, "Versandmethode ungültig.");
|
|
|
|
var paymentMethod = await _context.PaymentMethods.FindAsync(orderDto.PaymentMethodId);
|
|
if (paymentMethod == null || !paymentMethod.IsActive)
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.InvalidInput, "Zahlungsmethode ungültig.");
|
|
|
|
// 1.4 Produkte Validieren
|
|
if (orderDto.Items == null || !orderDto.Items.Any())
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.InvalidInput, "Warenkorb ist leer.");
|
|
|
|
var productIds = orderDto.Items.Select(i => i.ProductId).Distinct().ToList();
|
|
var products = await _context.Products.Where(p => productIds.Contains(p.Id)).ToListAsync();
|
|
|
|
var validationErrors = new StringBuilder();
|
|
decimal totalOrderWeight = 0;
|
|
decimal itemsTotal = 0;
|
|
var preparedOrderItems = new List<OrderItem>();
|
|
|
|
foreach (var itemDto in orderDto.Items)
|
|
{
|
|
var product = products.FirstOrDefault(p => p.Id == itemDto.ProductId);
|
|
|
|
if (product == null) { validationErrors.AppendLine($"- Produkt {itemDto.ProductId} fehlt."); continue; }
|
|
if (!product.IsActive) validationErrors.AppendLine($"- '{product.Name}' ist nicht verfügbar.");
|
|
if (product.StockQuantity < itemDto.Quantity) validationErrors.AppendLine($"- '{product.Name}': Zu wenig Bestand.");
|
|
|
|
if (validationErrors.Length == 0)
|
|
{
|
|
totalOrderWeight += (decimal)(product.Weight ?? 0) * itemDto.Quantity;
|
|
var orderItem = new OrderItem
|
|
{
|
|
ProductId = product.Id,
|
|
ProductVariantId = itemDto.ProductVariantId,
|
|
ProductName = product.Name,
|
|
ProductSKU = product.SKU,
|
|
Quantity = itemDto.Quantity,
|
|
UnitPrice = product.Price,
|
|
TotalPrice = product.Price * itemDto.Quantity
|
|
};
|
|
preparedOrderItems.Add(orderItem);
|
|
itemsTotal += orderItem.TotalPrice;
|
|
}
|
|
}
|
|
|
|
if (validationErrors.Length > 0)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.Conflict, $"Fehler:\n{validationErrors}");
|
|
}
|
|
|
|
if (totalOrderWeight < shippingMethod.MinWeight || totalOrderWeight > shippingMethod.MaxWeight)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.InvalidInput, $"Gesamtgewicht ({totalOrderWeight} kg) passt nicht zur Versandart.");
|
|
}
|
|
|
|
// 2. Preise & Rabatte
|
|
decimal discountAmount = 0;
|
|
var discountResult = new DiscountCalculationResult();
|
|
|
|
if (!string.IsNullOrWhiteSpace(orderDto.CouponCode))
|
|
{
|
|
discountResult = await _discountService.CalculateDiscountAsync(preparedOrderItems, orderDto.CouponCode);
|
|
|
|
if (!discountResult.IsValid)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.InvalidInput, $"Gutscheinfehler: {discountResult.ErrorMessage ?? "Code ungültig."}");
|
|
}
|
|
discountAmount = discountResult.TotalDiscountAmount;
|
|
}
|
|
|
|
decimal shippingCost = shippingMethod.BaseCost;
|
|
decimal subTotalBeforeDiscount = itemsTotal + shippingCost;
|
|
if (discountAmount > subTotalBeforeDiscount) discountAmount = subTotalBeforeDiscount;
|
|
|
|
decimal subTotalAfterDiscount = subTotalBeforeDiscount - discountAmount;
|
|
decimal taxRate = await _settingService.GetSettingValueAsync<decimal>("GlobalTaxRate", 0.19m);
|
|
decimal taxAmount = subTotalAfterDiscount * taxRate; // Steuer auf reduzierten Betrag
|
|
decimal orderTotal = subTotalAfterDiscount + taxAmount;
|
|
|
|
// 3. Ausführung (Execution)
|
|
foreach (var itemDto in orderDto.Items)
|
|
{
|
|
var product = products.First(p => p.Id == itemDto.ProductId);
|
|
if (product.StockQuantity < itemDto.Quantity)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.Conflict, "Lagerbestand hat sich während des Vorgangs geändert.");
|
|
}
|
|
product.StockQuantity -= itemDto.Quantity;
|
|
}
|
|
|
|
var newOrder = new Order
|
|
{
|
|
CustomerId = customer.Id,
|
|
OrderNumber = GenerateOrderNumber(),
|
|
OrderDate = DateTimeOffset.UtcNow,
|
|
OrderStatus = OrderStatus.Pending.ToString(),
|
|
PaymentStatus = PaymentStatus.Pending.ToString(),
|
|
OrderTotal = orderTotal,
|
|
ShippingCost = shippingCost,
|
|
TaxAmount = taxAmount,
|
|
DiscountAmount = discountAmount,
|
|
PaymentMethod = paymentMethod.Name,
|
|
PaymentMethodId = paymentMethod.Id,
|
|
ShippingMethodId = shippingMethod.Id,
|
|
BillingAddressId = orderDto.BillingAddressId,
|
|
ShippingAddressId = orderDto.ShippingAddressId,
|
|
OrderItems = preparedOrderItems
|
|
};
|
|
|
|
await _orderRepository.AddAsync(newOrder);
|
|
|
|
if (discountResult.AppliedDiscountIds.Any())
|
|
{
|
|
var appliedDiscounts = await _context.Discounts
|
|
.Where(d => discountResult.AppliedDiscountIds.Contains(d.Id))
|
|
.ToListAsync();
|
|
foreach (var d in appliedDiscounts) d.CurrentUsageCount++;
|
|
}
|
|
|
|
try
|
|
{
|
|
await _context.SaveChangesAsync();
|
|
await transaction.CommitAsync();
|
|
}
|
|
catch (DbUpdateConcurrencyException ex)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
_logger.LogWarning(ex, "Concurrency Konflikt bei Bestellung.");
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.Conflict, "Artikel wurden soeben von einem anderen Kunden gekauft.");
|
|
}
|
|
|
|
// 4. Post-Processing (Warenkorb & Email)
|
|
try { await _cartService.ClearCartAsync(userId!); }
|
|
catch (Exception ex) { _logger.LogError(ex, "Warenkorb konnte nicht geleert werden."); }
|
|
|
|
try { await _emailService.SendOrderConfirmationAsync(newOrder.Id, userEmail); }
|
|
catch (Exception ex) { _logger.LogError(ex, "Bestätigungs-Email fehlgeschlagen."); }
|
|
|
|
// Manuelles Setzen der Navigation Properties für das Mapping
|
|
newOrder.PaymentMethodInfo = paymentMethod;
|
|
newOrder.ShippingAddress = addresses.First(a => a.Id == orderDto.ShippingAddressId);
|
|
newOrder.BillingAddress = addresses.First(a => a.Id == orderDto.BillingAddressId);
|
|
|
|
return ServiceResult.Ok(MapToOrderDetailDto(newOrder));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
_logger.LogError(ex, "Checkout Exception");
|
|
return ServiceResult.Fail<OrderDetailDto>(ServiceResultType.Failure, "Ein unerwarteter Fehler ist aufgetreten.");
|
|
}
|
|
}
|
|
|
|
private string GenerateOrderNumber()
|
|
{
|
|
return $"WS-{DateTime.UtcNow:yyyyMMdd}-{Guid.NewGuid().ToString().Substring(0, 6).ToUpper()}";
|
|
}
|
|
|
|
private OrderDetailDto MapToOrderDetailDto(Order order)
|
|
{
|
|
return new OrderDetailDto
|
|
{
|
|
Id = order.Id,
|
|
OrderNumber = order.OrderNumber,
|
|
OrderDate = order.OrderDate,
|
|
CustomerId = order.CustomerId,
|
|
Status = Enum.TryParse<OrderStatus>(order.OrderStatus, true, out var os) ? os : OrderStatus.Pending,
|
|
TotalAmount = order.OrderTotal,
|
|
ShippingAddress = new AddressDto
|
|
{
|
|
Id = order.ShippingAddress.Id,
|
|
FirstName = order.ShippingAddress.FirstName,
|
|
LastName = order.ShippingAddress.LastName,
|
|
Street = order.ShippingAddress.Street,
|
|
HouseNumber = order.ShippingAddress.HouseNumber,
|
|
City = order.ShippingAddress.City,
|
|
PostalCode = order.ShippingAddress.PostalCode,
|
|
Country = order.ShippingAddress.Country,
|
|
Type = order.ShippingAddress.Type
|
|
},
|
|
BillingAddress = new AddressDto
|
|
{
|
|
Id = order.BillingAddress.Id,
|
|
FirstName = order.BillingAddress.FirstName,
|
|
LastName = order.BillingAddress.LastName,
|
|
Street = order.BillingAddress.Street,
|
|
HouseNumber = order.BillingAddress.HouseNumber,
|
|
City = order.BillingAddress.City,
|
|
PostalCode = order.BillingAddress.PostalCode,
|
|
Country = order.BillingAddress.Country,
|
|
Type = order.BillingAddress.Type
|
|
},
|
|
PaymentMethod = order.PaymentMethodInfo?.Name ?? order.PaymentMethod,
|
|
PaymentStatus = Enum.TryParse<PaymentStatus>(order.PaymentStatus, true, out var ps) ? ps : PaymentStatus.Pending,
|
|
OrderItems = order.OrderItems.Select(oi => new OrderItemDto
|
|
{
|
|
Id = oi.Id,
|
|
ProductId = oi.ProductId,
|
|
ProductVariantId = oi.ProductVariantId,
|
|
ProductName = oi.ProductName,
|
|
ProductSKU = oi.ProductSKU,
|
|
Quantity = oi.Quantity,
|
|
UnitPrice = oi.UnitPrice,
|
|
TotalPrice = oi.TotalPrice
|
|
}).ToList()
|
|
};
|
|
}
|
|
}
|
|
} |