Discount calculation.

Author: AlexanderNikitin

src/main/java/an/kte/repository/DiscountRepository.java

@@ -4,7 +4,9 @@
 import org.springframework.data.repository.ListCrudRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.Optional;
+
 @Repository
 public interface DiscountRepository extends ListCrudRepository<Discount, Long> {
-    Discount findTopByOrderByIdDesc();
+    Optional<Discount> findTopByOrderByIdDesc();
 }

src/main/java/an/kte/service/DiscountService.java

@@ -1,17 +1,58 @@
 package an.kte.service;
 
+import an.kte.model.Client;
 import an.kte.model.Discount;
+import an.kte.model.Product;
+import an.kte.repository.ClientRepository;
 import an.kte.repository.DiscountRepository;
+import an.kte.repository.ProductRepository;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Scope;
 import org.springframework.data.repository.ListCrudRepository;
 import org.springframework.stereotype.Service;
 
+import java.util.Objects;
+import java.util.Optional;
+
 @Service
-public class DiscountService implements CommonService {
+@Scope("singleton")
+public class DiscountService implements CommonService<Discount> {
+    private final double MAX_DISCOUNT_PERCENT = .18;
+    private final long SECOND_DISCOUNT_THRESHOLD = 5;
     @Autowired
     private DiscountRepository discountRepository;
+    @Autowired
+    private ProductRepository productRepository;
+    @Autowired
+    private ClientRepository clientRepository;
+
+    public long getPositionPrice(Long clientId, Long productId, Long count) {
+        Optional<Product> product = productRepository.findById(productId);
+        Optional<Client> client = clientRepository.findById(clientId);
+        Optional<Discount> actualDiscount = getActualDiscount();
+        if (product.isPresent()) {
+            long price = count * product.get().getPrice();
+            double percent = 0;
+            if (actualDiscount.isPresent() && Objects.equals(productId, actualDiscount.get().getProductId())) {
+                percent += actualDiscount.get().getPercent();
+            }
+            if (client.isPresent()) {
+                if (count >= SECOND_DISCOUNT_THRESHOLD && client.get().getDiscount2() != null && client.get().getDiscount2() != 0) {
+                    percent += client.get().getDiscount2();
+                } else if (client.get().getDiscount1() != null) {
+                    percent += client.get().getDiscount1();
+                }
+            }
+            if (percent > MAX_DISCOUNT_PERCENT) {
+                percent = MAX_DISCOUNT_PERCENT;
+            }
+            return (long) (price * (1 - percent));
+        } else {
+            return 0;
+        }
+    }
 
-    public Discount findTopByOrderByIdDesc() {
+    public Optional<Discount> getActualDiscount() {
         return discountRepository.findTopByOrderByIdDesc();
     }
 

src/main/java/an/kte/service/OrderService.java

@@ -26,6 +26,8 @@ public class OrderService implements CommonService<OrderDocument> {
     private OrderRepository orderRepository;
     @Autowired
     private PositionRepository positionRepository;
+    @Autowired
+    private DiscountService discountService;
 
     public OrderDocument constructOrder(Long clientId, List<ProductIdCount> productCountList) {
         Optional<OrderDocument> lastOrder = orderRepository.findTopByOrderByIdDesc();
@@ -49,7 +51,10 @@ public OrderDocument saveOrder(Long clientId, List<ProductIdCount> productCountL
         final OrderDocument savedOrderDocument = save(orderDocument);
         productCountList.stream()
                 .map(idCount -> {
-                    long price = calculatePositionPrice(idCount.getProductId(), idCount.getCount());
+                    long price = discountService.getPositionPrice(
+                            clientId,
+                            idCount.getProductId(),
+                            idCount.getCount());
                     long sourcePrice = getProductPrice(idCount.getProductId());
                     return Position.builder()
                             .orderId(savedOrderDocument.getId())
@@ -66,13 +71,12 @@ public OrderDocument saveOrder(Long clientId, List<ProductIdCount> productCountL
 
     private long calculateOrderPrice(Long clientId, List<ProductIdCount> productCountList) {
         return productCountList.stream()
-                .map(idCount -> calculatePositionPrice(idCount.getProductId(), idCount.getCount()))
-                .reduce(Long::sum).orElse(0L);
-    }
-
-    private long calculatePositionPrice(Long productId, Long count) {
-        Optional<Product> product = productRepository.findById(productId);
-        return product.map(value -> value.getPrice() * count).orElse(0L);
+                .map(idCount -> discountService.getPositionPrice(
+                        clientId,
+                        idCount.getProductId(),
+                        idCount.getCount()))
+                .reduce(Long::sum)
+                .orElse(0L);
     }
 
     private long getProductPrice(Long productId) {

src/main/java/an/kte/service/StatisticService.java

@@ -5,6 +5,7 @@
 import an.kte.repository.ClientStatisticRepository;
 import an.kte.repository.ProductStatisticRepository;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Scope;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -15,6 +16,7 @@
 import java.sql.SQLException;
 
 @Service
+@Scope("singleton")
 public class StatisticService {
     @Autowired
     private DataSource dataSource;