Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.order;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.BulkOrderModel;

import com.spice.profitmandi.common.model.LineItemModel;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.common.model.TransactionApprovalModel;

import com.spice.profitmandi.common.util.ExcelUtils;

import com.spice.profitmandi.common.util.Utils;

import com.spice.profitmandi.dao.cart.CartService;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

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

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

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

import com.spice.profitmandi.dao.entity.dtr.User;

import com.spice.profitmandi.dao.entity.transaction.*;

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.enumuration.transaction.TransactionApprovalStatus;

import com.spice.profitmandi.dao.model.CartItem;

import com.spice.profitmandi.dao.model.UserCart;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

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

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.dtr.UserRepository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.transaction.SDCreditRequirementRepository;

import com.spice.profitmandi.dao.repository.transaction.TransactionApprovalRepository;

import com.spice.profitmandi.dao.repository.transaction.TransactionRepository;

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

import com.spice.profitmandi.service.transaction.SDCreditService;

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.apache.poi.ss.usermodel.Cell;

import org.apache.poi.ss.usermodel.Row;

import org.apache.poi.xssf.usermodel.XSSFRow;

import org.apache.poi.xssf.usermodel.XSSFSheet;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.multipart.MultipartFile;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

@Service

@Transactional(rollbackFor = Throwable.class)

public class BulkOrderService {

    private static final Logger LOGGER = LogManager.getLogger(BulkOrderService.class);

    @Autowired

    CartService cartService;

    @Autowired

    TransactionService transactionService;

    @Autowired

    CommonPaymentService commonPaymentService;

    @Autowired

    TagListingRepository tagListingRepository;

    @Autowired

    WalletService walletService;

    @Autowired

    UserRepository userRepository;

    @Autowired

    TransactionRepository transactionRepository;

    @Autowired

    TransactionApprovalRepository transactionApprovalRepository;

    @Autowired

    AddressRepository addressRepository;

    @Autowired

    OrderRepository orderRepository;

    //TODO:Tejus need to check

    @Autowired

    SDCreditRequirementRepository sdCreditRequirementRepository;

    @Autowired

    SDCreditService sdCreditService;

    @Autowired

    private CsService csService;

    @Autowired

    private JavaMailSender mailSender;

    @Autowired

    private AuthRepository authRepository;

    public void parseBulkOrders(MultipartFile file, int creatorId) throws Exception, ProfitMandiBusinessException {

        XSSFWorkbook myWorkBook = new XSSFWorkbook(file.getInputStream());

        myWorkBook.setMissingCellPolicy(Row.MissingCellPolicy.RETURN_BLANK_AS_NULL);

        // Return first sheet from the XLSX workbook

        XSSFSheet mySheet = myWorkBook.getSheetAt(0);

        LOGGER.info("rowCellNum {}", mySheet.getLastRowNum());

        List<BulkOrderModel> bulkOrderModels = new ArrayList<>();

        LOGGER.info("mySheet.getLastRowNum() - {}", mySheet.getLastRowNum());

        for (int rowNumber = 1; rowNumber <= mySheet.getLastRowNum(); rowNumber++) {

            XSSFRow row = mySheet.getRow(rowNumber);

            LOGGER.info("Row - {}", row);

            if (row != null) {

                BulkOrderModel bulkOrderModel = this.createBulkModel(row);

                bulkOrderModels.add(bulkOrderModel);

            } else {

                break;

            }

        }

        this.generatePurchaseOrder(bulkOrderModels, creatorId, ProfitMandiConstants.PO_TYPE.MANUAL);

    }

    public void generatePurchaseOrder(List<BulkOrderModel> bulkOrderModels, int creatorId, ProfitMandiConstants.PO_TYPE type) throws Exception,ProfitMandiBusinessException {

        Map<Integer, List<BulkOrderModel>> fofoBulkOrdersMap = bulkOrderModels.stream().collect(Collectors.groupingBy(x -> x.getFofoId()));

        boolean approvalRequired = false;

        for (Map.Entry<Integer, List<BulkOrderModel>> fofoBulkOrderEntry : fofoBulkOrdersMap.entrySet()) {

            int fofoId = fofoBulkOrderEntry.getKey();

            List<BulkOrderModel> fofoBulkOrderModels = fofoBulkOrderEntry.getValue();

            Map<Integer, Long> orderItemCountMap = fofoBulkOrderModels.stream().collect(Collectors.groupingBy(x -> x.getItemId(), Collectors.counting()));

            if (orderItemCountMap.entrySet().stream().filter(x -> x.getValue() > 1).count() > 0) {

                throw new ProfitMandiBusinessException("Fofo ID", fofoId, "Duplicate in items");

            }

            boolean hasZeroQuantity = fofoBulkOrderModels.stream().filter(x -> x.getQuantity() <= 0).count() > 0;

            if (hasZeroQuantity) {

                throw new ProfitMandiBusinessException("Item Quantity", "", "Should be greater than 0");

            }

            List<CartItem> cartItems = new ArrayList<>();

            double totalPayableAmount = 0;

            for (BulkOrderModel fofoBulkOrderModel : fofoBulkOrderModels) {

                CartItem cartItem = new CartItem();

                cartItem.setQuantity(fofoBulkOrderModel.getQuantity());

                cartItem.setItemId(fofoBulkOrderModel.getItemId());

                TagListing tagListing = tagListingRepository.selectByItemId(fofoBulkOrderModel.getItemId());

                if (tagListing == null) {

                    String message = "Pricing Does not exist for " + fofoBulkOrderModel.getItemId() + "(" + fofoBulkOrderModel.getDescription() + ")";

                    throw new ProfitMandiBusinessException(message, message, message);

                }

                double itemSellingPrice = tagListing.getSellingPrice();

                boolean isActualPrice = fofoBulkOrderModel.getItemPrice() == itemSellingPrice;

                boolean isPriceZero = fofoBulkOrderModel.getItemPrice() == 0d;

                double customSellingPrice = fofoBulkOrderModel.getItemPrice();

                int itemId = cartItem.getItemId();

                if (isPriceZero || isActualPrice) {

                    cartItem.setSellingPrice(itemSellingPrice);

                } else {

                    if (customSellingPrice <= tagListing.getMrp() || customSellingPrice <= tagListing.getMop()) {

                        cartItem.setSellingPrice(customSellingPrice);

                        approvalRequired = true;

                    } else {

                        throw new ProfitMandiBusinessException("Given price is greater than selling price for item Id - ", itemId, " it should be less or equal of DP");

                    }

                }

                totalPayableAmount += cartItem.getSellingPrice() * cartItem.getQuantity();

                cartItems.add(cartItem);

            }

            LOGGER.info("totalAmount of item " + totalPayableAmount);

            double walletAmount = walletService.getWalletAmount(fofoId);

            BigDecimal creditAvailability = sdCreditService.getAvailableAmount(fofoId);

            double netAmountInHand = creditAvailability.doubleValue() + walletAmount;

            LOGGER.info("netAmountInHand - " + netAmountInHand);

            if (totalPayableAmount > ProfitMandiConstants.MAX_NEGATIVE_WALLET_VALUE && netAmountInHand < totalPayableAmount) {

                if (type == ProfitMandiConstants.PO_TYPE.MANUAL) {

                    throw new ProfitMandiBusinessException("Skipping order due to insufficient balance for id - ", fofoId, " ,Check wallet Balance once");

                } else {

                    this.notifyPartnerRBM(netAmountInHand, totalPayableAmount, fofoId);

                }

            }

            UserCart userCart = cartService.setCartItems(fofoId, cartItems);

            // createtransactionInternally set the value in transaction table

            double creditAmountRequired = totalPayableAmount - walletAmount;

            int loanId = 0;

            if (creditAmountRequired > ProfitMandiConstants.MAX_NEGATIVE_WALLET_VALUE) {

                Loan loan = sdCreditService.createLoan(userCart.getUserId(), creditAmountRequired, 365, "Credit limit assigned via SD Credit");

                loanId = loan.getId();

            }

            int transactionId = transactionService.createTransactionInternally(userCart, totalPayableAmount, 0);

            //Set here created by

            Transaction transaction = transactionRepository.selectById(transactionId);

            transaction.setCreatedBy(creatorId);

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

            commonPaymentService.payThroughWallet(transactionId);

            if (approvalRequired) {

                this.createApproval(transactionId);

            } else {

                transactionService.processTransaction(transactionId,loanId);

            }

        }

    }

    public void createApproval(int transactionId) {

        TransactionApproval transactionApproval = new TransactionApproval();

        transactionApproval.setId(transactionId);

        transactionApproval.setStatus(TransactionApprovalStatus.PENDING);

        transactionApprovalRepository.persist(transactionApproval);

    }

    private BulkOrderModel createBulkModel(XSSFRow row) throws ProfitMandiBusinessException {

        BulkOrderModel bulkOrderModel = new BulkOrderModel();

        int i = 0;

        bulkOrderModel.setRowIndex(row.getRowNum());

        try {

            Cell partnerName = row.getCell(i++);

            if (partnerName == null)

                bulkOrderModel.setPartnerName("");

            else

                bulkOrderModel.setPartnerName(partnerName.getStringCellValue().trim());

            Cell description = row.getCell(i++);

            if (description == null)

                bulkOrderModel.setDescription("");

            else

                bulkOrderModel.setDescription(description.getStringCellValue().trim());

            bulkOrderModel.setFofoId((int) row.getCell(i++).getNumericCellValue());

            bulkOrderModel.setItemId((int) row.getCell(i++).getNumericCellValue());

            bulkOrderModel.setItemPrice(row.getCell(i++).getNumericCellValue());

            bulkOrderModel.setQuantity((int) row.getCell(i++).getNumericCellValue());

        } catch (Throwable e) {

            LOGGER.info(e.getCause());

            throw new ProfitMandiBusinessException("Field", "Field at row - " + row.getRowNum() + ", column - " + (i - 1), "Invalid field value at - " + ExcelUtils.toAlphabet(i - 1) + (row.getRowNum() + 1) + ", " + ExcelUtils.getCellValue(row.getCell(i - 1)));

        }

        LOGGER.info(bulkOrderModel);

        return bulkOrderModel;

    }

    // create model for transaction Approval so that finance team see all order and approve

    public List<TransactionApprovalModel> getAllPendingTransactionApproval() throws ProfitMandiBusinessException {

        List<TransactionApproval> transactionApprovals = transactionApprovalRepository.selectAllPending();

        LOGGER.info("list of Approval transaction Id " + transactionApprovals);

        List<TransactionApprovalModel> approvalModelList = new ArrayList<>();

        for (TransactionApproval transactionApproval : transactionApprovals) {

            List<Order> orderList = orderRepository.selectAllByTransactionId(transactionApproval.getId());

            Transaction transaction = transactionRepository.selectById(transactionApproval.getId());

            List<LineItemModel> lineItemModelList = new ArrayList<>();

            for (Order order : orderList) {

                LineItem lineItem = order.getLineItem();

                LineItemModel lineItemModel = new LineItemModel();

                lineItemModel.setItemId(lineItem.getItemId());

                lineItemModel.setItemName(lineItem.getItem().getItemDescription());

                lineItemModel.setItemQuantity(lineItem.getQuantity());

                lineItemModel.setSellingPrice(lineItem.getUnitPrice());

                lineItemModel.setDp(tagListingRepository.selectByItemId(lineItem.getItemId()).getSellingPrice());

                lineItemModelList.add(lineItemModel);

            }

            AuthUser authUser = authRepository.selectById(transaction.getCreatedBy());

            TransactionApprovalModel transactionApprovalModel = new TransactionApprovalModel();

            String retailerName = " ";

            retailerName = orderList.get(0).getRetailerName();

            transactionApprovalModel.setRetailerName(retailerName);

            transactionApprovalModel.setCreatedBy(authUser.getFullName());

            transactionApprovalModel.setCreatedOn(transaction.getCreateTimestamp());

            transactionApprovalModel.setTransactionId(transactionApproval.getId());

            transactionApprovalModel.setLineItemModels(lineItemModelList);

            approvalModelList.add(transactionApprovalModel);

        }

        return approvalModelList;

    }

    public void notifyPartnerRBM(double netAmountInHand, double totalPayableAmount, int fofoId) throws Exception, ProfitMandiBusinessException {

        User user = userRepository.selectById(fofoId);

        int rbmId = csService.getAuthUserId(ProfitMandiConstants.TICKET_CATEGORY_RBM, EscalationType.L1, fofoId);

        AuthUser authUser = authRepository.selectById(rbmId);

        //String[] emailTo = new String[] { authUser.getEmailId() };

        String[] emailTo = new String[] { "vjangra856@gmail.com" };

        String[] ccTo = {"vikas.jangra@smartdukaan.com"};

        String subject = "Dispatch On Hold(Bidding)";

        String message = String.format(

                "Dear Team, \n"

                        + "This is to inform you that the material for %s with the value Rs.%s "

                        + "purchase is hold till the money against the stock will receive. Kindly inform the partner "

                        + "about wallet topup with amount of Rs.%s. The material will be dispatched.",

                user.getFirstName(), totalPayableAmount, (totalPayableAmount - netAmountInHand)

        );

        LOGGER.info("mailMessage: {}",message);

        Utils.sendMailWithAttachments(mailSender, emailTo, ccTo, subject, message);

    }

}