WebSVN – SmartDukaan – Diff – /trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/order/OrderServiceImpl.java

         this.processScratchOffer(fofoOrder);
         return fofoOrder.getId();
+    }
-    @Override
-    public void processScratchOffer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
-        boolean isSmartPhonePurchased = false;
-        float maxPurchaseValue = 0;
-        List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
-        for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
-            Item item = itemRepository.selectById(fofoOrderItem.getItemId());
-            if (item.isSmartPhone()) {
-                LOGGER.info("fofoItem {}", fofoOrderItem);
-                isSmartPhonePurchased = true;
-                maxPurchaseValue = Math.max(fofoOrderItem.getSellingPrice(), maxPurchaseValue);
-            }
-        }
-        LocalDate startDate = ProfitMandiConstants.SCRATCH_OFFER_START_DATE;
-        LocalDate endDate = ProfitMandiConstants.SCRATCH_OFFER_END_DATE;
-        boolean specificPriceOffer = ProfitMandiConstants.SPECIFIC_PRICE_OFFER;
-        boolean randomOffer = ProfitMandiConstants.RANDOM_OFFER;
-        if (isSmartPhonePurchased) {
-            if (LocalDateTime.now().isAfter(startDate.atStartOfDay()) && LocalDateTime.now().isBefore(endDate.atTime(Utils.MAX_TIME))) {
-                Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
+    static Map<Double, List<ScratchedGift>> GIFT_SERIES = new TreeMap<>(Comparator.reverseOrder());
-                try {
-                    this.sendAppDownloadBillingOffer(customer.getMobileNumber());
-                } catch (Exception e) {
-                    // TODO Auto-generated catch block
-                    e.printStackTrace();
-                }
-                if (specificPriceOffer) {
-                    this.createSpecificPriceScratchOffer(fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId(), maxPurchaseValue);
-                } else if (randomOffer) {
-                    this.createRandomScratchOffer(fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId());
-                    LOGGER.info("randomOffer {}", randomOffer);
-                } else {
-                    this.createScratchOffer(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId());
-                }
-            }
-        }
-    }
     private void persistNonSerializedWithCustomSerialNumber(CustomFofoOrderItem customFofoOrderItem, int orderItemId) {
         // Create a new instance of FofoNonSerializeSerial
         for (String accSerialNumber : customFofoOrderItem.getCustomSerialNumbers()) {
             if (!accSerialNumber.isEmpty()) {
                 so2.setUnlockedAt(today9PM);
+            }
             scratchOfferRepository.persist(so2);
+        }
+    }
+    private static Map<ScratchedGift, Integer> GIFT_QUANTITIES = new HashMap<>();
+    static {
+        GIFT_QUANTITIES.put(ScratchedGift.MINI_LUNCH_BOX, 500);
-    static Map<Double, RandomCollection<ScratchedGift>> GIFT_SERIES = new TreeMap<>(Comparator.reverseOrder());
+        GIFT_QUANTITIES.put(ScratchedGift.THREE_SET_CONTAINER, 250);
+        GIFT_QUANTITIES.put(ScratchedGift.CASSROLE, 250);
+        GIFT_QUANTITIES.put(ScratchedGift.INSULATED_FLASK, 250);
+        GIFT_QUANTITIES.put(ScratchedGift.JUICE_JUG, 250);
+        GIFT_QUANTITIES.put(ScratchedGift.JUICER, 11);
+        GIFT_QUANTITIES.put(ScratchedGift.HAIR_DRYER, 16);
+        GIFT_QUANTITIES.put(ScratchedGift.CHOPPER, 20);
+        GIFT_QUANTITIES.put(ScratchedGift.BOTTLE, 12);
+        GIFT_QUANTITIES.put(ScratchedGift.ELECTRIC_KETTLE, 137);
+        GIFT_QUANTITIES.put(ScratchedGift.BOWL_SET, 134);
+        GIFT_QUANTITIES.put(ScratchedGift.BOTTLE_MUG, 28);
+        GIFT_QUANTITIES.put(ScratchedGift.EW, 1000);
+    }
     static {
+        GIFT_SERIES.put(0.0, Arrays.asList(ScratchedGift.MINI_LUNCH_BOX, ScratchedGift.BOWL_SET, ScratchedGift.THREE_SET_CONTAINER, ScratchedGift.BOTTLE, ScratchedGift.BOTTLE_MUG));
+        GIFT_SERIES.put(20001.0, Arrays.asList(ScratchedGift.CASSROLE, ScratchedGift.INSULATED_FLASK, ScratchedGift.JUICE_JUG));
+        GIFT_SERIES.put(25001.0, Arrays.asList(ScratchedGift.ELECTRIC_KETTLE));
+        GIFT_SERIES.put(35001.0, Arrays.asList(ScratchedGift.JUICER, ScratchedGift.HAIR_DRYER, ScratchedGift.CHOPPER));
+    }
+    List<Double> PRICE_RANGE = Arrays.asList(0.0, 20001.0, 25001.0, 35001.0);
+    @Override
+    public void processScratchOffer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
+        boolean isSmartPhonePurchased = false;
+        float maxPurchaseValue = 0;
+        List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
+        for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
+            Item item = itemRepository.selectById(fofoOrderItem.getItemId());
+            if (item.isSmartPhone()) {
+                LOGGER.info("fofoItem {}", fofoOrderItem);
+                isSmartPhonePurchased = true;
+                maxPurchaseValue = Math.max(fofoOrderItem.getSellingPrice(), maxPurchaseValue);
+            }
+        }
+        LocalDate startDate = ProfitMandiConstants.SCRATCH_OFFER_START_DATE;
+        LocalDate endDate = ProfitMandiConstants.SCRATCH_OFFER_END_DATE;
+        boolean specificPriceOffer = ProfitMandiConstants.SPECIFIC_PRICE_OFFER;
+        boolean randomOffer = ProfitMandiConstants.RANDOM_OFFER;
+        if (isSmartPhonePurchased) {
+            if (LocalDateTime.now().isAfter(startDate.atStartOfDay()) && LocalDateTime.now().isBefore(endDate.atTime(Utils.MAX_TIME))) {
+                Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
+                try {
+                    this.sendAppDownloadBillingOffer(customer.getMobileNumber());
+                } catch (Exception e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+                if (specificPriceOffer) {
+                    this.createSpecificPriceScratchOffer(fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId(), maxPurchaseValue);
+                } else if (randomOffer) {
+                    this.createRandomScratchOffer(fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId());
+                    LOGGER.info("randomOffer {}", randomOffer);
+                } else {
+                    this.createScratchOffer(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId());
+                }
+            }
+        }
+    }
+    @Override
+    public ScratchedGift getSelectedGift(double purchaseAmount) {
+        //Iterating map in reverse order of values
+        Map<ScratchedGift, Long> scratchOfferCountMap = scratchOfferRepository.countOffersByDateRange(ProfitMandiConstants.SCRATCH_OFFER_START_DATE, ProfitMandiConstants.SCRATCH_OFFER_END_DATE);
+        RandomCollection<ScratchedGift> giftRandomCollection = createDynamicGiftSeries(scratchOfferCountMap, purchaseAmount);
+        if (giftRandomCollection.size() > 0) {
+            return giftRandomCollection.next();
+        } else {
+            // Default gift if no match found
+            return ScratchedGift.EW;
+        }
+    }
+    public RandomCollection<ScratchedGift> createDynamicGiftSeries(Map<ScratchedGift, Long> soldGiftContMap, Double sellingPrice) {
+        int index = 0;
+        RandomCollection<ScratchedGift> randomCollection = new RandomCollection<>();
+        for (Double price : PRICE_RANGE) {
+            if (sellingPrice >= price) {
+                int divisor = PRICE_RANGE.size() - index;
+                for (ScratchedGift gift : GIFT_SERIES.get(price)) {
+                    int remainingQty = GIFT_QUANTITIES.get(gift) - soldGiftContMap.getOrDefault(gift, 0l).intValue();
+                    if (remainingQty == 0) {
+                        continue;
+                    }
+                    if (remainingQty > divisor) {
+                        randomCollection.add(remainingQty / divisor, gift);
+                    } else {
+                        randomCollection.add(remainingQty, gift);
+                    }
+                }
+                index++;
+            }
+        }
+        return randomCollection;
+    }
+    /*static {
         RandomCollection<ScratchedGift> map1 = new RandomCollection<ScratchedGift>().
                 add(100d, ScratchedGift.GIFT_BOWL);
         GIFT_SERIES.put(0.0, map1);
         //Map<ScratchedGift, Double> map2 = new HashMap<>();
         RandomCollection<ScratchedGift> map2 = new RandomCollection<ScratchedGift>()
         RandomCollection<ScratchedGift> map5 = new RandomCollection<ScratchedGift>()
                 .add(40d, ScratchedGift.SPEAKER)
                 .add(60d, ScratchedGift.SMART_WATCH);
         GIFT_SERIES.put(50001.0, map5);
-    }
+    }*/
     private void createSpecificPriceScratchOffer(String invoiceNumber, int customerId, float purchaseAmount) {
         ScratchedGift selectedGift = getSelectedGift(purchaseAmount);
         List<ScratchOffer> scratchOffers = scratchOfferRepository.selectBycCustomerIdAndDate(customerId, ProfitMandiConstants.SCRATCH_OFFER_START_DATE, ProfitMandiConstants.SCRATCH_OFFER_END_DATE);
             so2.setUnlockedAt(LocalDateTime.now());
             scratchOfferRepository.persist(so2);
+        }
+    }
-    @Override
-    public ScratchedGift getSelectedGift(double purchaseAmount) {
-        //Iterating map in reverse order of values
-        for (Map.Entry<Double, RandomCollection<ScratchedGift>> entry : GIFT_SERIES.entrySet()) {
-            if (purchaseAmount >= entry.getKey()) {
-                return entry.getValue().next();
-            }
-        }
-        return ScratchedGift.BLNT; // Default gift if no match found
-    }
     private ScratchedGift getScratchedGiftRandom(int fofoId, int customerId) throws ProfitMandiBusinessException {
         Map<Integer, ScratchedGift> giftSeries = new HashMap<>();
         giftSeries.put(1, ScratchedGift.MINI_CHOPPER);
         giftSeries.put(2, ScratchedGift.FRUIT_JUICER);
         giftSeries.put(3, ScratchedGift.STEAM_IRON);
                 .add(100d, ScratchedGift.BLUETOOTH_SPEAKER)
                 .add(150d, ScratchedGift.RED_WATER_BOTTLE)
                 .add(200d, ScratchedGift.GIFT_BOWL)
                 .add(100d, ScratchedGift.EARBUDS);
-        ScratchedGift gift = ScratchedGift.RED_WATER_BOTTLE;
-        Random random = new Random();
-        int rand;
+        ScratchedGift gift;
-        while (true) {
-            rand = random.nextInt(6);
-            if (rand != 0) break;
-        }
         List<ScratchOffer> lastScratchOffers = scratchOfferRepository.selectBycCustomerIdAndDate(customerId, ProfitMandiConstants.LAST_SCRATCH_OFFER_START_DATE, ProfitMandiConstants.LAST_SCRATCH_OFFER_END_DATE);
-//
-//        if (lastScratchOffers.isEmpty()) {
+        if (lastScratchOffers.isEmpty()) {
-//            gift = map1.next();
+            gift = map1.next();
-//        } else {
+        } else {
-//            gift = ScratchedGift.RED_WATER_BOTTLE;
+            gift = ScratchedGift.RED_WATER_BOTTLE;
-//            LOGGER.info("RED_WATER_BOTTLE {}", gift);
+            LOGGER.info("RED_WATER_BOTTLE {}", gift);
-//        }
+        }
         return gift;
+    }
     private HygieneData createAndGetHygieneData(int id, int fofoId) {
         HygieneData hygieneData = new HygieneData();
         hygieneDataRepository.persist(hygieneData);
         return hygieneData;
+    }
     @Override
     public String getInvoiceNumber(int fofoId, String fofoStoreCode) {
         InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
         try {
             invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);
         } else {
             throw new ProfitMandiBusinessException("Serial Number", serialNumber, "Serial Number does not exist in our warehouse");
+        }
+    }
-    void modifyDummyModel(FofoOrder fofoOrder, InvoicePdfModel pdfModel, int itemId, String serialNumber) throws ProfitMandiBusinessException {
+    void modifyDummyModel(FofoOrder fofoOrder, InvoicePdfModel pdfModel, int itemId, String serialNumber) throws
+            ProfitMandiBusinessException {
         int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoOrder.getFofoId());
         Address retailerAddress = addressRepository.selectById(retailerAddressId);
         Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
         pdfModel.setTncs(tncs);
         return pdfModel;
+    }
-    private CustomCustomer getCustomCustomer(FofoOrder fofoOrder, CustomAddress retailerAddress) throws ProfitMandiBusinessException {
+    private CustomCustomer getCustomCustomer(FofoOrder fofoOrder, CustomAddress retailerAddress) throws
+            ProfitMandiBusinessException {
         Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
         CustomCustomer customCustomer = new CustomCustomer();
         customCustomer.setFirstName(customer.getFirstName());
         customCustomer.setLastName(customer.getLastName());
         customCustomer.setEmailId(customer.getEmailId());
             throw new ProfitMandiBusinessException("cartData", cartJson, "FFORDR_1006");
+        }
+    }
     @Override
-    public Map<String, Object> getSaleHistory(int fofoId, SearchType searchType, String searchValue, LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
+    public Map<String, Object> getSaleHistory(int fofoId, SearchType searchType, String searchValue, LocalDateTime
+            startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
         long countItems = 0;
         List<FofoOrder> fofoOrders = new ArrayList<>();
         if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
             fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, null, null, offset, limit);
             map.put("end", offset + limit);
+        }
         return map;
+    }
-    public ResponseEntity<?> downloadReportInCsv(org.apache.commons.io.output.ByteArrayOutputStream baos, List<List<?>> rows, String fileName) {
+    public ResponseEntity<?> downloadReportInCsv(org.apache.commons.io.output.ByteArrayOutputStream
+                                                         baos, List<List<?>> rows, String fileName) {
         final HttpHeaders headers = new HttpHeaders();
         headers.set("Content-Type", "text/csv");
         headers.set("Content-disposition", "inline; filename=" + fileName + ".csv");
         headers.setContentLength(baos.toByteArray().length);
         return new ResponseEntity<>(inputStreamResource, headers, HttpStatus.OK);
+    }
     @Override
+    public Map<String, Object> getSaleHistoryPaginated(int fofoId, SearchType searchType, String
-    public Map<String, Object> getSaleHistoryPaginated(int fofoId, SearchType searchType, String searchValue, LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
+            searchValue, LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws
+            ProfitMandiBusinessException {
         List<FofoOrder> fofoOrders = new ArrayList<>();
         if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
             fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, startDate, endDate, offset, limit);
         } else if (searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()) {
         return serialNumbers;
+    }
     static final List<String> MOP_VOILATED_BRANDS = Arrays.asList("Live Demo", "Almost New");
+    private void validateDpPrice(int fofoId, Map<
-    private void validateDpPrice(int fofoId, Map<Integer, PriceModel> itemIdMopPriceMap, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
+            Integer, PriceModel> itemIdMopPriceMap, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws
+            ProfitMandiBusinessException {
         if (pricingService.getMopVoilatedRetailerIds().contains(fofoId)) return;
         for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoLineItemMap.entrySet()) {
             int itemId = entry.getKey();
             CustomFofoOrderItem customFofoOrderItem = entry.getValue();
             LOGGER.info("CustomFofoOrderItem -- {}", customFofoOrderItem);
+                }
+            }
+        }
+    }
+    private void validateMopPrice(int fofoId, Map<
-    private void validateMopPrice(int fofoId, Map<Integer, PriceModel> itemIdMopPriceMap, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
+            Integer, PriceModel> itemIdMopPriceMap, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws
+            ProfitMandiBusinessException {
         if (pricingService.getMopVoilatedRetailerIds().contains(fofoId)) return;
         Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
         for (Map.Entry<Integer, PriceModel> entry : itemIdMopPriceMap.entrySet()) {
             CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoLineItemMap.get(entry.getKey());
             Item item = itemRepository.selectById(customFofoOrderItem.getItemId());
             throw new ProfitMandiBusinessException("invalidMopItemIdPrice", invalidMopItemIdPriceMap, "FFORDR_1010");
+        }
+    }
-    private void updateInventoryItemsAndScanRecord(Set<InventoryItem> inventoryItems, int fofoId, Map<Integer, Integer> inventoryItemQuantityUsed, int fofoOrderId) {
+    private void updateInventoryItemsAndScanRecord(Set<InventoryItem> inventoryItems, int fofoId, Map<
+            Integer, Integer> inventoryItemQuantityUsed, int fofoOrderId) {
         for (InventoryItem inventoryItem : inventoryItems) {
             inventoryItem.setLastScanType(ScanType.SALE);
             inventoryItem.setUpdateTimestamp(LocalDateTime.now());
             ScanRecord scanRecord = new ScanRecord();
             scanRecord.setInventoryItemId(inventoryItem.getId());
             purchaseReturnItemRepository.deleteById(inventoryItem.getId());
+        }
+    }
+    private void createFofoLineItem(int fofoOrderItemId, Set<
-    private void createFofoLineItem(int fofoOrderItemId, Set<InventoryItem> inventoryItems, Map<Integer, Integer> inventoryItemIdQuantityUsed) {
+            InventoryItem> inventoryItems, Map<Integer, Integer> inventoryItemIdQuantityUsed) {
         for (InventoryItem inventoryItem : inventoryItems) {
             FofoLineItem fofoLineItem = new FofoLineItem();
             fofoLineItem.setFofoOrderItemId(fofoOrderItemId);
             fofoLineItem.setSerialNumber(inventoryItem.getSerialNumber());
             fofoLineItem.setInventoryItemId(inventoryItem.getId());
             fofoLineItem.setQuantity(inventoryItemIdQuantityUsed.get(inventoryItem.getId()));
             fofoLineItemRepository.persist(fofoLineItem);
+        }
+    }
-    private FofoOrderItem createAndGetFofoOrderItem(CustomFofoOrderItem customFofoOrderItem, int fofoOrderId, Map<Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Integer stateId) throws ProfitMandiBusinessException {
+    private FofoOrderItem createAndGetFofoOrderItem(CustomFofoOrderItem customFofoOrderItem, int fofoOrderId, Map<
+            Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Integer stateId) throws
+            ProfitMandiBusinessException {
         FofoOrderItem fofoOrderItem = new FofoOrderItem();
         fofoOrderItem.setItemId(customFofoOrderItem.getItemId());
         fofoOrderItem.setQuantity(customFofoOrderItem.getQuantity());
         fofoOrderItem.setSellingPrice(customFofoOrderItem.getSellingPrice());
         fofoOrderItem.setOrderId(fofoOrderId);
         fofoOrderItem.setColor(item.getColor());
         fofoOrderItemRepository.persist(fofoOrderItem);
         return fofoOrderItem;
+    }
-    private FofoOrderItem getDummyFofoOrderItem(int itemId, int fofoOrderId, String serialNumber, Integer stateId) throws ProfitMandiBusinessException {
+    private FofoOrderItem getDummyFofoOrderItem(int itemId, int fofoOrderId, String serialNumber, Integer stateId) throws
+            ProfitMandiBusinessException {
         Item item = itemRepository.selectById(itemId);
         TagListing tl = tagListingRepository.selectByItemId(itemId);
         FofoOrderItem fofoOrderItem = new FofoOrderItem();
         fofoOrderItem.setItemId(itemId);
         fofoOrderItem.setQuantity(1);
         fofoOrderItem.setFofoLineItems(fofoLineItems);
         return fofoOrderItem;
+    }
-    private void updateCurrentInventorySnapshot(List<CurrentInventorySnapshot> currentInventorySnapshots, int fofoId, int itemId, int quantity) throws ProfitMandiBusinessException {
+    private void updateCurrentInventorySnapshot(List<CurrentInventorySnapshot> currentInventorySnapshots,
+                                                int fofoId, int itemId, int quantity) throws ProfitMandiBusinessException {
         for (CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
             if (currentInventorySnapshot.getItemId() == itemId && currentInventorySnapshot.getFofoId() == fofoId) {
                 currentInventorySnapshotRepository.updateAvailabilityByItemIdAndFofoId(itemId, fofoId, currentInventorySnapshot.getAvailability() - quantity);
+            }
+        }
+    }
-    private void createPaymentOptions(FofoOrder fofoOrder, Set<CustomPaymentOption> customPaymentOptions) throws ProfitMandiBusinessException {
+    private void createPaymentOptions(FofoOrder fofoOrder, Set<CustomPaymentOption> customPaymentOptions) throws
+            ProfitMandiBusinessException {
         for (CustomPaymentOption customPaymentOption : customPaymentOptions) {
             if (customPaymentOption.getAmount() > 0) {
                 PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();
                 LOGGER.error("error", fofoOrder.getId());
                 paymentOptionTransaction.setReferenceId(fofoOrder.getId());
                 paymentOptionTransactionRepository.persist(paymentOptionTransaction);
+            }
+        }
+    }
-    private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId, String documentNumber, float totalAmount, int customerAddressId) {
+    private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId, String
+            documentNumber, float totalAmount, int customerAddressId) {
         FofoOrder fofoOrder = new FofoOrder();
         fofoOrder.setCustomerGstNumber(customerGstNumber);
         fofoOrder.setCustomerId(customerId);
         fofoOrder.setFofoId(fofoId);
         fofoOrder.setInvoiceNumber(documentNumber);
         fofoOrder.setCustomerAddressId(customerAddressId);
         fofoOrderRepository.persist(fofoOrder);
         return fofoOrder;
+    }
+    private void validateItemsSerializedNonSerialized
-    private void validateItemsSerializedNonSerialized(List<Item> items, Map<Integer, CustomFofoOrderItem> customFofoOrderItemMap) throws ProfitMandiBusinessException {
+            (List<Item> items, Map<Integer, CustomFofoOrderItem> customFofoOrderItemMap) throws
+            ProfitMandiBusinessException {
         List<Integer> invalidItemIdSerialNumbers = new ArrayList<Integer>();
         List<Integer> itemIdNonSerializedSerialNumbers = new ArrayList<Integer>();
         for (Item i : items) {
             CustomFofoOrderItem customFofoOrderItem = customFofoOrderItemMap.get(i.getId());
             if (i.getType().equals(ItemType.SERIALIZED)) {
             // itemId's are non serialized you are saying these are serialized
             throw new ProfitMandiBusinessException("itemIdNonSerializedSerialNumbers", itemIdNonSerializedSerialNumbers, "FFORDR_1014");
+        }
+    }
+    private void validateCurrentInventorySnapshotQuantities
-    private void validateCurrentInventorySnapshotQuantities(List<CurrentInventorySnapshot> currentInventorySnapshots, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap) throws ProfitMandiBusinessException {
+            (List<CurrentInventorySnapshot> currentInventorySnapshots, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap) throws
+            ProfitMandiBusinessException {
         if (itemIdCustomFofoOrderItemMap.keySet().size() != currentInventorySnapshots.size()) {
             throw new ProfitMandiBusinessException("quantiiesSize", currentInventorySnapshots.size(), "");
+        }
         List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); // this is for error
         LOGGER.info("currentInventorySnapshots " + currentInventorySnapshots);
             LOGGER.error("Requested quantities should not be greater than currently available quantities {}", itemIdQuantityAvailabilities);
             throw new ProfitMandiBusinessException("itemIdQuantityAvailabilities", itemIdQuantityAvailabilities, "FFORDR_1015");
+        }
+    }
-    private int getItemIdFromSerialNumber(Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap, String serialNumber) {
+    private int getItemIdFromSerialNumber(Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap, String
+            serialNumber) {
         int itemId = 0;
         for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoOrderItemMap.entrySet()) {
             Set<SerialNumberDetail> serialNumberDetails = entry.getValue().getSerialNumberDetails();
             for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {
                 if (serialNumberDetail.getSerialNumber().equals(serialNumber)) {
         customAddress.setCountry(customerAddress.getCountry());
         customAddress.setPhoneNumber(customerAddress.getPhoneNumber());
         return customAddress;
+    }
-    private CustomAddress createCustomAddressWithoutId(CustomCustomer customerAddress, CustomAddress retailerAddress) {
+    private CustomAddress createCustomAddressWithoutId(CustomCustomer customerAddress, CustomAddress
+            retailerAddress) {
         CustomAddress customAddress = new CustomAddress();
         customAddress.setName(customerAddress.getFirstName());
         customAddress.setLastName(customerAddress.getLastName());
         customAddress.setLine1("");
         customAddress.setLine2("");
         customAddress.setCountry("");
         customAddress.setPhoneNumber(customerAddress.getMobileNumber());
         return customAddress;
+    }
-    private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions, float totalAmount) throws ProfitMandiBusinessException {
+    private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions,
+                                                      float totalAmount) throws ProfitMandiBusinessException {
         Set<Integer> paymentOptionIds = new HashSet<>();
         float calculatedAmount = 0;
         for (CustomPaymentOption customPaymentOption : customPaymentOptions) {
             paymentOptionIds.add(customPaymentOption.getPaymentOptionId());
+            }
         };
         return fofoOrderItems.stream().map(fofoOrderItemToFofoOrderItemIdFunction).collect(Collectors.toSet());
+    }
-    private Map<Integer, Set<FofoLineItem>> toFofoOrderItemIdFofoLineItems(List<FofoOrderItem> fofoOrderItems) throws ProfitMandiBusinessException {
+    private Map<Integer, Set<FofoLineItem>> toFofoOrderItemIdFofoLineItems(List<FofoOrderItem> fofoOrderItems) throws
+            ProfitMandiBusinessException {
         Set<Integer> fofoOrderItemIds = this.toFofoOrderItemIds(fofoOrderItems);
         List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);
         Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = new HashMap<>();
         for (FofoLineItem fofoLineItem : fofoLineItems) {
             if (!fofoOrderItemIdFofoLineItemsMap.containsKey(fofoLineItem.getFofoOrderItemId())) {
+        }
         return fofoOrderItemIdFofoLineItemsMap;
+    }
     @Override
-    public void updateCustomerDetails(CustomCustomer customCustomer, String invoiceNumber) throws ProfitMandiBusinessException {
+    public void updateCustomerDetails(CustomCustomer customCustomer, String invoiceNumber) throws
+            ProfitMandiBusinessException {
         FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
         Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
         customer.setFirstName(customCustomer.getFirstName());
         customer.setLastName(customCustomer.getLastName());
         customer.setMobileNumber(customCustomer.getMobileNumber());
+        }
         this.setCustomerAddress(customerAddress, customCustomer.getAddress());
         fofoOrder.setCustomerGstNumber(customCustomer.getGstNumber());
+    }
-    private void resetTaxation(int fofoId, CustomerAddress customerAddress, List<FofoOrderItem> fofoOrderItems) throws ProfitMandiBusinessException {
+    private void resetTaxation(int fofoId, CustomerAddress customerAddress, List<FofoOrderItem> fofoOrderItems) throws
+            ProfitMandiBusinessException {
         int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoId);
         Address retailerAddress = addressRepository.selectById(retailerAddressId);
         Integer stateId = null;
             fofoOrderItem.setIgstRate(rate.getIgstRate());
+        }
+    }
     @Override
-    public CustomerCreditNote badReturn(int fofoId, FoiBadReturnRequest foiBadReturnRequest) throws ProfitMandiBusinessException {
+    public CustomerCreditNote badReturn(int fofoId, FoiBadReturnRequest foiBadReturnRequest) throws
+            ProfitMandiBusinessException {
         FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());
         FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(foi.getOrderId());
         if (fofoOrder.getFofoId() != fofoId) {
             throw new ProfitMandiBusinessException("Partner Auth", "", "Invalid Order");
+        }
         fofoOrder.setCancelledTimestamp(LocalDateTime.now());
         this.reverseScheme(fofoOrder);
         return creditNote;
+    }
+    private CustomerCreditNote generateCreditNote(FofoOrder
-    private CustomerCreditNote generateCreditNote(FofoOrder fofoOrder, List<CustomerReturnItem> customerReturnItems) throws ProfitMandiBusinessException {
+                                                          fofoOrder, List<CustomerReturnItem> customerReturnItems) throws ProfitMandiBusinessException {
         InvoiceNumberGenerationSequence sequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoOrder.getFofoId());
         sequence.setCreditNoteSequence(sequence.getCreditNoteSequence() + 1);
         invoiceNumberGenerationSequenceRepository.persist(sequence);
     public CreditNotePdfModel getCreditNotePdfModel(int customerCreditNoteId) throws ProfitMandiBusinessException {
         CustomerCreditNote creditNote = customerCreditNoteRepository.selectById(customerCreditNoteId);
         return getCreditNotePdfModel(creditNote);
+    }
-    private CreditNotePdfModel getCreditNotePdfModel(CustomerCreditNote creditNote) throws ProfitMandiBusinessException {
+    private CreditNotePdfModel getCreditNotePdfModel(CustomerCreditNote creditNote) throws
+            ProfitMandiBusinessException {
         FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(creditNote.getFofoOrderId());
         List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository.selectAllByCreditNoteId(creditNote.getId());
         CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
         CustomCustomer customCustomer = getCustomCustomer(fofoOrder, customRetailer.getAddress());
+            }
+        }
+    }
     @Override
-    public boolean refundOrder(int orderId, String refundedBy, String refundReason) throws ProfitMandiBusinessException {
+    public boolean refundOrder(int orderId, String refundedBy, String refundReason) throws
+            ProfitMandiBusinessException {
         /*def refund_order(order_id, refunded_by, reason):
         """
         If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
 . Creates a refund request for batch processing.
 . Creates a return order for the warehouse executive to return the shipped material.

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/order/OrderServiceImpl.java – Rev 33554 → 33665