Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.service;

import com.spice.profitmandi.common.model.BulkOrderModel;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.dao.cart.CartService;
import com.spice.profitmandi.dao.entity.catalog.Bid;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.catalog.Liquidation;
import com.spice.profitmandi.dao.entity.inventory.SaholicCISTable;
import com.spice.profitmandi.dao.model.CartItem;
import com.spice.profitmandi.dao.model.UserCart;
import com.spice.profitmandi.dao.repository.catalog.BidRepository;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.LiquidationRepository;
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
import com.spice.profitmandi.dao.repository.inventory.SaholicCISTableRepository;
import com.spice.profitmandi.service.order.BulkOrderService;
import com.spice.profitmandi.service.transaction.TransactionService;
import com.spice.profitmandi.service.wallet.CommonPaymentService;
import com.spice.profitmandi.service.wallet.WalletService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@Component
public class LiquidationService {
    private static final Logger LOGGER = LogManager.getLogger(LiquidationService.class);

    @Autowired
    BidRepository bidRepository;

    @Autowired
    LiquidationRepository liquidationRepository;

    @Autowired
    private ItemRepository itemRepository;

    @Autowired
    private UserAccountRepository userAccountRepository;

    @Autowired
    private TransactionService transactionService;

    @Autowired
    private CommonPaymentService commonPaymentService;

    @Autowired
    private CartService cartService;

    @Autowired
    SaholicCISTableRepository saholicCISTableRepository;

    @Autowired
    WalletService walletService;

    @Autowired
    private BulkOrderService bulkOrderService;

    public void processBids(ProfitMandiConstants.BID_CRON_ENUM type) throws Exception {
        List<Liquidation> liquidations;
        if (type.equals(ProfitMandiConstants.BID_CRON_ENUM.YESTERDAY)){
            liquidations = liquidationRepository.selectAllByEndDate(LocalDateTime.now().minusDays(1));
        } else {
            liquidations = liquidationRepository.selectAllByEndDate(LocalDateTime.now());
        }
        LOGGER.info("liquidations: {}",liquidations);

        if (liquidations.size() > 0) {
            for (Liquidation liquidation : liquidations) {
                List<Item> items = itemRepository.selectAllByCatalogItemId(liquidation.getCatalogId());
                if (items.size() > 0) {
                    long remainingQty = 0;
                    for (Item item : items) {
                        List<SaholicCISTable> saholicCISTable = saholicCISTableRepository.selectAllByItemId(item.getId());
                        remainingQty += saholicCISTable.stream().filter(x -> x.getNetAvailability() > 0).count();
                    }
                    List<Bid> bids = bidRepository.selectAllBidByLiquidationIdAndStatus(liquidation.getId(), Arrays.asList(ProfitMandiConstants.BID_ENUM.PENDING, ProfitMandiConstants.BID_ENUM.PROCESSING));

                    for (Bid bid : bids) {
                        if (remainingQty >= bid.getQuantity()) {
                            List<BulkOrderModel> bulkOrderModels = new ArrayList<>();
                            BulkOrderModel bulkOrderModel = new BulkOrderModel();
                            bulkOrderModel.setFofoId(bid.getFofoId());
                            bulkOrderModel.setItemId(items.get(0).getId());
                            bulkOrderModel.setQuantity(bid.getQuantity());
                            bulkOrderModel.setDescription(items.get(0).getItemDescription());
                            bulkOrderModel.setItemPrice(bid.getBiddingAmount());

                            bulkOrderModels.add(bulkOrderModel);

                            bulkOrderService.generatePurchaseOrder(bulkOrderModels, bid.getFofoId(), ProfitMandiConstants.PO_TYPE.AUTO);
                            remainingQty -= bid.getQuantity();
                            //this.generatePurchaseOrder(liquidation, bid, item, remainingQty, type);
                        }
                    }
                    liquidation.setQuantity((int) remainingQty);
                    liquidation.setStatus(ProfitMandiConstants.LIQUIDATION_ENUM.CLOSED);
                }
            }
        }
    }

    public void generatePurchaseOrder(Liquidation liquidation, Bid bid, Item item, long remainingQty, ProfitMandiConstants.BID_CRON_ENUM type) throws Exception {
        UserCart uc = userAccountRepository.getUserCart(bid.getFofoId());
        double walletAmount = walletService.getWalletAmount(uc.getUserId());
        double orderAmount = (bid.getBiddingAmount() * bid.getQuantity());

        if (walletAmount >= orderAmount) {
            List<CartItem> cartItems = new ArrayList<>();
            CartItem cartItem = new CartItem();
            cartItem.setItemId(item.getId());
            cartItem.setQuantity(bid.getQuantity());
            cartItem.setSellingPrice(bid.getBiddingAmount());
            cartItems.add(cartItem);
            cartService.addItemsToCart(uc.getCartId(), cartItems);
            liquidation.setQuantity((int) remainingQty - bid.getQuantity());
            bid.setStatus(ProfitMandiConstants.BID_ENUM.CLOSED);
            int transactionId = transactionService.createTransaction(uc, orderAmount, 0);
            commonPaymentService.payThroughWallet(transactionId);
        } else {
            if (remainingQty <= bid.getQuantity() || (type.equals(ProfitMandiConstants.BID_CRON_ENUM.YESTERDAY))){
                bid.setStatus(ProfitMandiConstants.BID_ENUM.CANCELLED);
            } else {
                bid.setStatus(ProfitMandiConstants.BID_ENUM.PROCESSING);
                liquidation.setQuantity((int) remainingQty - bid.getQuantity());
                bulkOrderService.notifyPartnerRBM(walletAmount, orderAmount, bid.getFofoId());
            }
        }
    }

    
}