Subversion Repositories SmartDukaan

    /*@Override

    public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {

        LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);

        Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);

        // TODO - SCHEME

        PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,

                YearMonth.from(purchase.getCreateTimestamp()));

        // PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,

        // purchase.getCreateTimestamp().toLocalDate());

        List<Scheme> schemes = schemeRepository.selectActiveAll(Arrays.asList(SchemeType.IN), partnerType,

                purchase.getCreateTimestamp().toLocalDate(), false);

        List<Integer> validSchemeIds = schemeRepository.selectSchemesByRetailerIdsSchemeIds(retailerId, schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

        schemes = schemes.stream().filter(x -> validSchemeIds.contains(x.getId())).collect(Collectors.toList());

        float totalCashback = 0;

        if (schemes.isEmpty()) {

            return;

        }

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);

        //Remove imeis from blocked imeis list

        inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toList());

        if (inventoryItems.size() == 0) return;

        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());

        Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        inventoryItems.stream().forEach(x -> x.setItem(itemsMap.get(x.getItemId())));

        LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchaseId);

        Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()

                .filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())

                .collect(Collectors.toSet());

        // Only consider inventory items that were not returned

        inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))

                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD))

                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());

        LOGGER.info(inventoryItems);

        if (inventoryItems.size() == 0)

            return;

        Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,

                inventoryItems);

        if (inventoryItemSchemesMap.isEmpty()) {

            return;

        }

        Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();

        for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {

            Set<Scheme> allSchemes = new HashSet<>();

            for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {

                allSchemes.add(scheme);

            }

            allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);

        }

        //

        int itemsCount = 0;

        for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap

                .entrySet()) {

            float inventoryItemCashback = 0;

            for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {

                InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();

                float cashback = this.createSchemeInOut(null, inventoryItem, partnerType);

                inventoryItemCashback += cashback;

            }

            if (inventoryItemCashback > 0) {

                totalCashback += inventoryItemCashback;

                itemsCount++;

            }

        }

        LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);

        if (itemsCount > 0) {

            walletService.addAmountToWallet(

                    retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "

                            + purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",

                    totalCashback, purchase.getCreateTimestamp());

            LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,

                    purchase.getPurchaseReference(), itemsCount);

            purchase.setCashback(purchase.getCashback() + totalCashback);

            purchaseRepository.persist(purchase);

        }

    }*/

                    float newAmount = getAmount(ii, scheme);

                    if (Math.abs(schemeInOut.getAmount() - newAmount) >= 0.01f) {

                        SchemeInOut sioNew = new SchemeInOut();

                        sioNew.setAmount(newAmount);

                        sioNew.setStatus(schemeInOut.getStatus());

                        sioNew.setStatusDescription(schemeInOut.getStatusDescription());

                        sioNew.setInventoryItemId(schemeInOut.getInventoryItemId());

                        sioNew.setSchemeId(schemeInOut.getSchemeId());

                        sioNew.setCreditTimestamp(LocalDateTime.now());

                        schemeInOutRepository.persist(sioNew);

                            amountToCredit += sioNew.getAmount();

                        }

            if (amountToCredit > 0) {

                walletService.addAmountToWallet(fofoId, purchaseId, WalletReferenceType.SCHEME_IN,

                        MessageFormat.format(reversalReason, purchaseInventoryItemList.size()), amountToCredit,

                        priceDrop.getAffectedOn());

            }