Subversion Repositories SmartDukaan

import com.spice.profitmandi.dao.entity.catalog.Category;

import com.spice.profitmandi.dao.entity.user.CartLine;

import com.spice.profitmandi.dao.repository.catalog.CategoryRepository;

import com.spice.profitmandi.dao.repository.user.CartLineRepository;

    CategoryRepository categoryRepository;

    @Autowired

    CartLineRepository cartLineRepository;

    @Autowired

            // Refurbished (margin scheme) lines are invoiced on their own RF- series, so they must not share a

            // transaction with regular lines - one billing group per invoice. Everything above (pricing, combo,

            // credit availability) still validates the order as a whole; only the transaction is raised per group.

            List<List<CartLine>> cartLineGroups = this.splitCartLinesByMarginScheme(userCart.getCartId());

            // A loan settles against an invoice, so each group needs its own. Wallet is consumed in group order,

            // so only what a group cannot fund from the balance left to it is borrowed.

            List<Integer> groupLoanIds = new ArrayList<>();

            double remainingWalletAmount = walletAmount;

            for (List<CartLine> groupCartLines : cartLineGroups) {

                double groupPayableAmount = this.getPayableAmount(groupCartLines);

                double walletUsedByGroup = Math.min(remainingWalletAmount, groupPayableAmount);

                remainingWalletAmount -= walletUsedByGroup;

                    }

                groupLoanIds.add(loanId);

                for (int groupIndex = 0; groupIndex < cartLineGroups.size(); groupIndex++) {

                    List<CartLine> groupCartLines = cartLineGroups.get(groupIndex);

                    int loanId = groupLoanIds.get(groupIndex);

                    double groupPayableAmount = this.getPayableAmount(groupCartLines);

                    LOGGER.info("totalPayableAmount - {}", groupPayableAmount);

                    int transactionId = transactionService.createTransactionForCartLines(userCart, groupCartLines, groupPayableAmount, 0);

                    //Set here created by

                    Transaction transaction = transactionRepository.selectById(transactionId);

                    transaction.setCreatedBy(creatorId);

                    LOGGER.info("transaction created by {}", transaction.getCreatedBy());

                    commonPaymentService.payThroughWallet(transactionId);

                        }

                    } else {

                        transactionService.processTransaction(transactionId, loanId);

                                }

                        } catch (Exception e) {

                            LOGGER.error("Failed to track PO_CREATION timeline for fofoId: " + fofoId, e);

    /**

     * Splits the cart into billing groups: regular lines and margin-scheme (refurbished) lines. Returns one

     * group when the cart is homogeneous - which is the common case - so a single-kind bulk order behaves

     * exactly as it did before. Lines whose item or category cannot be resolved stay with the regular group.

     */

    private List<List<CartLine>> splitCartLinesByMarginScheme(int cartId) throws ProfitMandiBusinessException {

        List<CartLine> cartLines = cartLineRepository.selectAllByCart(cartId);

        Set<Integer> itemIds = cartLines.stream().map(CartLine::getItemId).collect(Collectors.toSet());

        Map<Integer, Item> itemMap = itemRepository.selectByIds(itemIds).stream()

                .collect(Collectors.toMap(Item::getId, x -> x));

        List<Integer> categoryIds = itemMap.values().stream().map(Item::getCategoryId).distinct().collect(Collectors.toList());

        Map<Integer, Category> categoryMap = categoryRepository.selectByIds(categoryIds).stream()

                .collect(Collectors.toMap(Category::getId, x -> x));

        List<CartLine> regularCartLines = new ArrayList<>();

        List<CartLine> marginSchemeCartLines = new ArrayList<>();

        for (CartLine cartLine : cartLines) {

            Item item = itemMap.get(cartLine.getItemId());

            Category category = (item == null) ? null : categoryMap.get(item.getCategoryId());

            if (category != null && category.isMarginOnly()) {

                marginSchemeCartLines.add(cartLine);

            } else {

                regularCartLines.add(cartLine);

            }

        }

        List<List<CartLine>> cartLineGroups = new ArrayList<>();

        if (!regularCartLines.isEmpty()) {

            cartLineGroups.add(regularCartLines);

        }

        if (!marginSchemeCartLines.isEmpty()) {

            cartLineGroups.add(marginSchemeCartLines);

        }

        return cartLineGroups;

    }

    /**

     * Cart value of a billing group, matching the rule createTransactionForWarehouse validates against - the

     * 0.01 carry bag is excluded - so the amount passed in always reconciles with the lines it is passed with.

     */

    private double getPayableAmount(List<CartLine> cartLines) {

        BigDecimal payableAmount = new BigDecimal(0);

        for (CartLine cartLine : cartLines) {

            if (cartLine.getItemId() == ProfitMandiConstants.ITEM_CARRY_BAG

                    && Utils.compareDouble(cartLine.getActualPrice(), 0.01) == 0) {

                continue;

            }

            payableAmount = payableAmount.add(BigDecimal.valueOf(cartLine.getActualPrice())

                    .multiply(BigDecimal.valueOf(cartLine.getQuantity())));

        }

        return payableAmount.doubleValue();

    }