gistfile1.txt

package com.kb.service.order;

import com.kb.domain.company.Company;
import com.kb.domain.enums.CompanyType;
import com.kb.domain.enums.PaymentStatus;
import com.kb.domain.order.Order;
import com.kb.domain.order.OrderStatus;
import com.kb.domain.outlet.Outlet;
import com.kb.repository.order.OrderRepository;
import com.kb.repository.outlet.OutletRepository;
import com.kb.repository.payment.PaymentRepository;
import com.kb.security.SecurityService;
import com.kb.service.company.CompanyService;
import com.kb.web.rest.dto.orders.OrderAggregateOutletOverviewDTO;
import com.kb.web.rest.dto.orders.OrderAggregateSupplierOverviewDTO;
import com.kb.web.rest.dto.orders.OrderDeliveryScheduleDTO;
import com.kb.web.rest.dto.orders.OrderOverviewDTO;
import org.joda.time.DateTime;
import org.springframework.stereotype.Component;

import javax.inject.Inject;
import javax.transaction.Transactional;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Created by rdyyak on 04.06.15.
 */
@Component
public class DefaultOrderService implements OrderService {

    @Inject
    private OrderRepository orderRepository;

    @Inject
    private CompanyService companyService;

    @Inject
    private SecurityService securityService;

    @Inject
    private PaymentRepository paymentRepository;

    @Inject
    private OutletRepository outletRepository;

    @Override
    @Transactional
    public List<Order> findOrderByCompanyId(Long id) {
        Company company = companyService.find(id);
        if (company.getCompanyType().equals(CompanyType.SUPPLIER)) {
            return orderRepository.findAllBySupplier(company);
        } else {
            return findOrdersByEatery(company);
        }
    }

    @Override
    @Transactional
    public List<Order> findRejectedOrders() {
        return orderRepository.findAllByStatus(OrderStatus.REJECTED);
    }

    @Override
    @Transactional
    public List<Order> findCompletedOrders() {
        return orderRepository.findAllByStatus(OrderStatus.DELIVERED_AND_PAID);
    }

    @Override
    public List<Order> findOnGoingOrders() {
        Set<OrderStatus> statuses = new HashSet<>(Arrays.asList(OrderStatus.REJECTED, OrderStatus.DELIVERED_AND_PAID));
        return orderRepository.findAllNotInStatuses(statuses);
    }

    @Override
    public List<Order> findOnGoingOrdersByOutlet(Long outletId) {
        Set<OrderStatus> statuses = new HashSet<>(Arrays.asList(OrderStatus.REJECTED, OrderStatus.DELIVERED_AND_PAID));
        return orderRepository.findAllByOutletAndNotInStatuses(outletId, statuses);
    }

    @Override
    public List<Order> findCompletedOrdersByOutletAndDeliveryDate(Long id, Date deliveryDate) {
        Outlet outlet = outletRepository.findOne(id);
        return orderRepository.findAllByOutletAndStatusAndDeliveryDate(outlet, OrderStatus.DELIVERED_AND_PAID, deliveryDate);
    }

    @Override
    @Transactional
    public OrderOverviewDTO getOrderOverviewByEateryId(Long id) {
        Company company = companyService.find(id);
        if (CompanyType.EATERY.equals(company.getCompanyType())) {
            OrderOverviewDTO orderOverviewDTO = new OrderOverviewDTO();
            orderOverviewDTO.setAcceptedYetToDeliver(orderRepository.countByEateryAndStatus(company, OrderStatus.PENDING_DELIVERY));
            orderOverviewDTO.setDeliveredUnpaid(orderRepository.countByEateryAndStatus(company, OrderStatus.DELIVERED_BUT_UNPAID));
            orderOverviewDTO.setOverdue(paymentRepository.countByEateryAndDueDateBefore(company, new DateTime().withTimeAtStartOfDay()));
            orderOverviewDTO.setTotalAmount(paymentRepository.sumOfTotalPaidByEatery(company, PaymentStatus.PAID));
            return orderOverviewDTO;
        }
        return null;
    }

    @Override
    @Transactional
    public OrderOverviewDTO getOrderOverviewBySupplierId(Long id) {
        Company company = companyService.find(id);
        if (CompanyType.SUPPLIER.equals(company.getCompanyType())) {
            OrderOverviewDTO orderOverviewDTO = new OrderOverviewDTO();
            orderOverviewDTO.setAcceptedYetToDeliver(orderRepository.countBySupplierAndStatus(company, OrderStatus.PENDING_DELIVERY));
            orderOverviewDTO.setDeliveredUnpaid(orderRepository.countBySupplierAndStatus(company, OrderStatus.DELIVERED_BUT_UNPAID));
            orderOverviewDTO.setOverdue(paymentRepository.countBySupplierAndDueDateBefore(company, new DateTime().withTimeAtStartOfDay()));
            orderOverviewDTO.setTotalAmount(paymentRepository.sumOfTotalPaidBySupplier(company, PaymentStatus.PAID));
            return orderOverviewDTO;
        }
        return null;
    }

    @Override
    public List<Order> findOrdersByEatery(Company eatery) {
        List<Order> orders = new ArrayList<>();
        if (CompanyType.EATERY.equals(eatery.getCompanyType())) {
            eatery.getOutlets().forEach(outlet ->
                    orders.addAll(orderRepository.findAllByOutlet(outlet))
            );
        }
        return orders;
    }

    @Override
    public OrderAggregateOutletOverviewDTO getOrderAggregateOverviewByOutletId(Long id) {
        Outlet outlet = outletRepository.findOne(id);

        OrderAggregateOutletOverviewDTO orderAggregateOutletOverviewDTO = new OrderAggregateOutletOverviewDTO();

        DateTime today = new DateTime();
        DateTime threeDaysLater = new DateTime().plusDays(3);

        orderAggregateOutletOverviewDTO.setAcknowledgeDelivery(orderRepository.findAllByOutletAndStatus(outlet, OrderStatus.AWAITING_SUPPLIER_ACCEPTANCE));
        List<Order> paymentsDueThreeDays = orderRepository.findAllByOutletAndStatusAndDueDateBetween(outlet, OrderStatus.DELIVERED_BUT_UNPAID, today, threeDaysLater);
        orderAggregateOutletOverviewDTO.setPaymentDueThreeDays(paymentsDueThreeDays);
        List<Order> paymentsDue = orderRepository.findAllByOutletAndStatus(outlet, OrderStatus.DELIVERED_BUT_UNPAID);
        paymentsDue.removeAll(paymentsDueThreeDays);
        orderAggregateOutletOverviewDTO.setPaymentDue(paymentsDue);
        orderAggregateOutletOverviewDTO.setRejectedOrder(orderRepository.findAllByOutletAndStatus(outlet, OrderStatus.REJECTED));
        orderAggregateOutletOverviewDTO.setStandingOrder(orderRepository.findAllByOutletAndStatus(outlet, OrderStatus.PENDING_EATERY_CONFIRMATION));

        return orderAggregateOutletOverviewDTO;
    }

    @Override
    public OrderAggregateSupplierOverviewDTO getOrderAggregateOverviewBySupplier(Company supplier) {
        OrderAggregateSupplierOverviewDTO orderAggregateSupplierOverviewDTO = new OrderAggregateSupplierOverviewDTO();

        DateTime today = new DateTime();
        DateTime threeDaysLater = new DateTime().plusDays(3);

        orderAggregateSupplierOverviewDTO.setAcknowledgeDelivery(orderRepository.findAllBySupplierAndStatus(supplier, OrderStatus.PENDING_EATERY_CONFIRMATION));
        orderAggregateSupplierOverviewDTO.setNewOrders(orderRepository.findAllBySupplierAndStatus(supplier, OrderStatus.AWAITING_SUPPLIER_ACCEPTANCE));

        List<Order> paymentsDueThreeDays = orderRepository.findAllBySupplierAndStatusAndDueDateBetween(supplier, OrderStatus.DELIVERED_BUT_UNPAID, today, threeDaysLater);
        orderAggregateSupplierOverviewDTO.setPaymentDueThreeDays(paymentsDueThreeDays);
        List<Order> paymentsDue = orderRepository.findAllBySupplierAndStatus(supplier, OrderStatus.DELIVERED_BUT_UNPAID);
        paymentsDue.removeAll(paymentsDueThreeDays);
        orderAggregateSupplierOverviewDTO.setPaymentDue(paymentsDue);

        return orderAggregateSupplierOverviewDTO;
    }

    @Override
    public List<Order> findOrdersBySupplierAndEatery(Company supplier, Company eatery) {
        return findOrdersByEatery(eatery).stream().filter(order -> order.getSupplier().equals(supplier)).collect(Collectors.toList());
    }

    @Override
    @Transactional
    public Order save(Order order) {
        return orderRepository.save(order);
    }

    @Override
    public List<OrderDeliveryScheduleDTO> getDeliverySchedule(Integer monthCount) {
        Company company = securityService.getCurrentUser().getCompany();

        List<OrderDeliveryScheduleDTO> orderDeliveryScheduleDTOs = new ArrayList<>();

        if (company.getCompanyType().equals(CompanyType.SUPPLIER)) {
            DateTime currentTime = new DateTime();
            DateTime start = currentTime.withTimeAtStartOfDay().plusMonths(monthCount).withDayOfMonth(1);
            DateTime end = currentTime.withTimeAtStartOfDay().plusMonths(monthCount + 1).withDayOfMonth(1).minusDays(1);

            List<Order> orders = orderRepository.findBySupplierAndDueDateBetween(company, start, end);

            while (start.compareTo(end) <= 0) {
                OrderDeliveryScheduleDTO orderDeliveryScheduleDTO = new OrderDeliveryScheduleDTO();
                orderDeliveryScheduleDTO.setDay(start);
                orderDeliveryScheduleDTO.setOrders(new ArrayList<>());
                orderDeliveryScheduleDTOs.add(orderDeliveryScheduleDTO);
                start = start.plusDays(1);
            }

            for (Order order : orders) {
                int dayNumber = order.getDueDate().getDayOfMonth();
                orderDeliveryScheduleDTOs.get(dayNumber - 1).getOrders().add(order);
                if (order.getStatus().equals(OrderStatus.PENDING_DELIVERY)) {
                    orderDeliveryScheduleDTOs.get(dayNumber - 1).setAcceptedOrderCount(orderDeliveryScheduleDTOs.get(dayNumber).getAcceptedOrderCount() + 1);
                }
            }
        }
        return orderDeliveryScheduleDTOs;
    }

}