src/service/OrderService.java - master - itokar98/HomeWorkPatternsSolidTask1

src/service/OrderService.java
107 строк4 KB
Ilya Tokar
first_commit
19 ноя 2025, 01:14
19 ноя 2025, 01:148a62050
package service;

import model.Cart;
import model.Order;
import model.Product;
import repository.OrderRepository;

import java.util.List;
import java.util.stream.Collectors;

public class OrderService {
    private final OrderRepository orderRepository;
    private final CartService cartService;

    public OrderService(OrderRepository orderRepository, CartService cartService) {
        this.orderRepository = orderRepository;
        this.cartService = cartService;
    }

    public Order createOrderFromCart(Long userId) {
        Cart cart = cartService.getCartForUser(userId);
        List<Product> cartItems = cart.getItems();
        
        if (cartItems.isEmpty()) {
            throw new IllegalStateException("Cannot create order from empty cart");
        }
        
        Order order = new Order(null, userId, cartItems);
        Order savedOrder = orderRepository.save(order);
        
        // Clear the cart after successful order
        cartService.clearCart(userId);
        
        return savedOrder;
    }

    public Order getOrderById(Long orderId) {
        Order order = orderRepository.findById(orderId);
        if (order == null) {
            throw new IllegalArgumentException("Order not found with id: " + orderId);
        }
        return order;
    }

    public List<Order> getOrdersByUserId(Long userId) {
        return orderRepository.findByUserId(userId);
    }

    public List<Order> getAllOrders() {
        return orderRepository.findAll();
    }

    public void updateOrderStatus(Long orderId, model.OrderStatus status) {
        Order order = getOrderById(orderId);
        order.setStatus(status);
        // In a real application, we might want to save the order back to the repository
        // For now, since we're using in-memory storage, the reference is already updated
    }

    public void cancelOrder(Long orderId) {
        Order order = getOrderById(orderId);
        if (order.getStatus() == model.OrderStatus.DELIVERED) {
            throw new IllegalStateException("Cannot cancel delivered order");
        }
        order.setStatus(model.OrderStatus.CANCELLED);
    }

    public List<Product> getRecommendedProducts(Long userId) {
        List<Order> userOrders = getOrdersByUserId(userId);
        
        if (userOrders.isEmpty()) {
            // Return popular products if no order history
            return getAllOrders().stream()
                    .flatMap(o -> o.getProducts().stream())
                    .collect(Collectors.groupingBy(Product::getId, Collectors.counting()))
                    .entrySet().stream()
                    .sorted(java.util.Map.Entry.<Long, Long>comparingByValue().reversed())
                    .limit(5)
                    .map(entry -> orderRepository.findAll().stream()
                            .flatMap(o -> o.getProducts().stream())
                            .filter(p -> p.getId().equals(entry.getKey()))
                            .findFirst()
                            .orElse(null))
                    .filter(java.util.Objects::nonNull)
                    .toList();
        }
        
        // For simplicity, recommend products from the same categories as user's previous purchases
        List<String> userCategories = userOrders.stream()
                .flatMap(order -> order.getProducts().stream())
                .map(Product::getCategory)
                .distinct()
                .toList();
                
        return userCategories.stream()
                .flatMap(category -> orderRepository.findAll().stream()
                    .flatMap(o -> o.getProducts().stream())
                    .filter(p -> p.getCategory().equalsIgnoreCase(category) && 
                                !userOrders.stream()
                                    .flatMap(order -> order.getProducts().stream())
                                    .anyMatch(purchased -> purchased.getId().equals(p.getId())))
                )
                .distinct()
                .limit(5)
                .toList();
    }
}