Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

import com.spice.profitmandi.common.enumuration.SearchType;

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

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

import com.spice.profitmandi.common.solr.SolrService;

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

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

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

import com.spice.profitmandi.common.web.util.ResponseSender;

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

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

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

import com.spice.profitmandi.dao.entity.cs.Position;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.fofo.*;

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

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

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

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

import com.spice.profitmandi.service.EmailService;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.integrations.zest.InsuranceService;

import com.spice.profitmandi.service.integrations.zest.MobileInsurancePlan;

import com.spice.profitmandi.service.order.BulkOrderService;

import com.spice.profitmandi.service.order.OrderService;

import com.spice.profitmandi.service.pricing.PricingService;

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

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.service.wallet.WalletService;

import com.spice.profitmandi.service.whatsapp.WhatsappMessageService;

import com.spice.profitmandi.service.whatsapp.WhatsappMessageType;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

import in.shop2020.model.v1.order.WalletReferenceType;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONObject;

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

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.*;

import org.springframework.web.multipart.MultipartFile;

import javax.mail.MessagingException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.nio.charset.StandardCharsets;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.time.temporal.ChronoUnit;

import java.util.*;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class OrderController {

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

    private static final List<String> offlineOrders = Arrays.asList("EMIOD", "POD");

    private static final List<String> allowedDoaImeis = Arrays.asList("863903054378477");

    @Autowired

    NotificationService notificationService;

    @Autowired

    TransactionApprovalRepository transactionApprovalRepository;

    @Autowired

    LineItemRepository lineItemRepository;

    @Autowired

    AuthRepository authRepository;

    @Autowired

    TransactionService transactionService;

    @Autowired

    BulkOrderService bulkOrderService;

    @Autowired

    private CustomerRepository customerRepository;

    private boolean accessoriesDeals = true;

    @Autowired

    private RoleManager roleManager;

    @Autowired

    private Gson gson;

    @Autowired

    private CustomerReturnItemRepository customerReturnItemRepository;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private PaymentOptionRepository paymentOptionRepository;

    @Autowired

    private StateRepository stateRepository;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private InsuranceService insuranceService;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private CustomerAddressRepository customerAddressRepository;

    @Autowired

    private InsurancePolicyRepository insurancePolicyRepository;

    @Autowired

    private InsuranceProviderRepository insuranceProviderRepository;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private PricingService pricingService;

    @Autowired

    private OrderService orderService;

    @Autowired

    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    @Autowired

    private AddressRepository addressRepository;

    @Autowired

    private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

    @Autowired

    private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

    @Autowired

    private ResponseSender<?> responseSender;

    @Autowired

    private PendingOrderRepository pendingOrderRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private PendingOrderItemRepository pendingOrderItemRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private PendingOrderService pendingOrderService;

    @Autowired

    private EmailService emailService;

    @Autowired

    private SolrService commonSolrService;

    @Autowired

    private MouRepository mouRepository;

    @Autowired

    private WhatsappMessageService whatsappMessageService;

    @Autowired

    private TransactionRepository transactionRepository;

    @Autowired

    WalletService walletService;

    @Autowired

    CartRepository cartRepository;

    @Autowired

    UserWalletRepository userWalletRepository;

    @Autowired

    PositionRepository positionRepository;

    @RequestMapping(value = "/checkplans", method = RequestMethod.GET)

    public String getInsurancePrices(HttpServletRequest request, @RequestParam float price, Model model,

                                     @RequestParam int itemId) throws ProfitMandiBusinessException {

        LOGGER.info("Request received at url : {}", request.getRequestURI());

        try {

            String response = mvcResponseSender.createResponseString(this.getPlans(price, itemId));

            model.addAttribute("response1", response);

        } catch (Exception e) {

            // TODO Auto-generated catch block

            LOGGER.info(e.getMessage(), e);

            throw new ProfitMandiBusinessException("Plans", "Plans API", "Error formatting insurance plans");

        }

        return "response";

    }

    @RequestMapping(value = "/wa-send-invoice", method = RequestMethod.GET)

    public String sendWhatsappMessage(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) {

        try {

            this.sendWhatsappInvoice(fofoOrderRepository.selectByOrderId(orderId));

        } catch (Exception e) {

            LOGGER.info("Could not send whatsapp message");

            e.printStackTrace();

        }

        model.addAttribute("response1", true);

        return "response";

    }

    @RequestMapping(value = "/get-order", method = RequestMethod.GET)

    public String getOrder(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId,

                           Model model) throws ProfitMandiBusinessException {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);

        List<FofoOrderItem> fofoLineItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

        CustomerAddress customerAddress = null;

        if (fofoOrder.getCustomerAddressId() != 0) {

            customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

        }

        Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

        if (customerAddress != null) {

            customerAddress.setPhoneNumber(customer.getMobileNumber());

        }

        LOGGER.info("Added to get invoice - {}, {}", customer, 123);

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

                .selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        this.addInsuranceProvider(insurancePolicies);

        model.addAttribute("fofoOrder", fofoOrder);

        model.addAttribute("fofoLineItems", fofoLineItems);

        if (customerAddress != null) {

            model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));

        } else {

            model.addAttribute("customerBillingAddress", "");

        }

        model.addAttribute("customerBillingAddressObj", customerAddress);

        model.addAttribute("customerDetailsObj", customer);

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

        model.addAttribute("insurancePolicies", insurancePolicies);

        return "order-details";

    }

    private Map<Integer, InsuranceProvider> toInsuranceProviderIdInsuranceProvider(

            List<InsuranceProvider> insuranceProviders) {

        Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = new HashMap<>();

        for (InsuranceProvider insuranceProvider : insuranceProviders) {

            insuranceProviderIdInsuranceProviderMap.put(insuranceProvider.getId(), insuranceProvider);

        }

        return insuranceProviderIdInsuranceProviderMap;

    }

    private void addInsuranceProvider(List<InsurancePolicy> insurancePolicies) throws ProfitMandiBusinessException {

        if (insurancePolicies.isEmpty()) {

            return;

        }

        Set<Integer> insuranceProviderIds = new HashSet<>();

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

            insuranceProviderIds.add(insurancePolicy.getProviderId());

        }

        LOGGER.info("insuranceProviderIds {}", insuranceProviderIds);

        List<InsuranceProvider> insuranceProviders = insuranceProviderRepository.selectByIds(insuranceProviderIds);

        Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = this

                .toInsuranceProviderIdInsuranceProvider(insuranceProviders);

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

            insurancePolicy

                    .setInsuranceProvider(insuranceProviderIdInsuranceProviderMap.get(insurancePolicy.getProviderId()));

        }

    }

    @RequestMapping(value = "/saleDetails", method = RequestMethod.GET)

    public String getSaleDetails(HttpServletRequest request,

                                 @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) throws Exception {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        boolean isAdmin = roleManager.isAdmin(fofoDetails.getRoleIds());

        FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);

        List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

        CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

                .selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);

        // Added Migration info as we lost it.

        if (paymentOptionTransactions == null || paymentOptionTransactions.size() == 0) {

            PaymentOptionTransaction pot = new PaymentOptionTransaction();

            pot.setAmount(fofoOrder.getTotalAmount());

            pot.setCreateTimestamp(fofoOrder.getCreateTimestamp());

            // Mark it paid through cash

            pot.setPaymentOptionId(1);

            pot.setReferenceType(PaymentOptionReferenceType.ORDER);

            paymentOptionTransactionRepository.persist(pot);

            paymentOptionTransactions.add(pot);

            LOGGER.info("Added to get invoice");

        }

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        this.addInsuranceProvider(insurancePolicies);

        Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {

            try {

                return itemRepository.selectById(x.getItemId());

            } catch (ProfitMandiBusinessException e) {

                // TODO Auto-generated catch block

                return null;

            }

        }));

        Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()

                .collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));

        Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()

                .collect(Collectors.toMap(foi -> foi.getId(),

                        foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));

        Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();

        for (FofoOrderItem foi : fofoOrderItems) {

            for (FofoLineItem fli : foi.getFofoLineItems()) {

                inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());

            }

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

                    .selectAllByOrderItemId(foi.getId());

            this.markDoa(fofoOrder, foi, isAdmin);

            for (CustomerReturnItem customerReturnItem : customerReturnItems) {

                inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

                        inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);

            }

        }

        LOGGER.info("fofoOrderItemIdLineItemMap {}", fofoOrderItemIdLineItemMap);

        model.addAttribute("fofoOrder", fofoOrder);

        model.addAttribute("itemsMap", itemsMap);

        model.addAttribute("fofoOrderItemIdLineItemsMap", StringUtils.toString(fofoOrderItemIdLineItemMap));

        model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

                StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

        model.addAttribute("fofoOrderItemIdLineItemMap", fofoOrderItemIdLineItemMap);

        model.addAttribute("fofoOrderItems", fofoOrderItems);

        model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));

        if (customerAddress != null) {

            model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));

        } else {

            model.addAttribute("customerBillingAddress", "");

        }

        model.addAttribute("customerBillingAddressObj", customerAddress);

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

        model.addAttribute("insurancePolicies", insurancePolicies);

        model.addAttribute("markDefective", this.markDefective(fofoOrder));

        return "sale-details";

    }

    private void markDoa(FofoOrder fofoOrder, FofoOrderItem foi, boolean isAdmin) {

        if (isAdmin) {

            foi.setDoa(true);

            return;

        }

        boolean isImei = foi.getFofoLineItems().stream()

                .anyMatch(x -> org.apache.commons.lang3.StringUtils.isNotEmpty(x.getSerialNumber())

                        && allowedDoaImeis.contains(x.getSerialNumber()));

        LocalDateTime buyDate = fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS);

        LocalDateTime curDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);

        if (buyDate.isAfter(curDate.minusDays(45)) || isImei) {

            foi.setDoa(true);

        } else

            foi.setDoa(

                    foi.getBrand().equals("Nokia") && foi.getCost() < 4990 && buyDate.isAfter(curDate.minusYears(1)));

    }

    private boolean markDefective(FofoOrder fofoOrder) {

        return fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS).plusDays(180)

                .isAfter(LocalDateTime.now().truncatedTo(ChronoUnit.DAYS));

    }

    @RequestMapping(value = "/getSearchOrder")

    public String getSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

        return "search-order";

    }

    @RequestMapping(value = "/getInvoiceSearchOrder")

    public String getInvoiceSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

        return "invoices-cancel";

    }

    @RequestMapping(value = "/customerDetails", method = RequestMethod.PUT)

    public String updateCustomerDetails(HttpServletRequest request, @RequestBody CustomCustomer customCustomer,

                                        @RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)

            throws Exception {

        orderService.updateCustomerDetails(customCustomer, invoiceNumber);

        return this.getSearchOrderDetails(request, invoiceNumber, model);

    }

    @RequestMapping(value = "/searchOrderDetails", method = RequestMethod.GET)

    public String getSearchOrderDetails(HttpServletRequest request,

                                        @RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)

            throws Exception {

        FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

        List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

        Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

        CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = paymentOptionRepository.selectActiveOption().stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        List<Integer> fofoPartnerPaymentOptions = new ArrayList<>(paymentOptionIdPaymentOptionMap.keySet());

        Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {

            try {

                return itemRepository.selectById(x.getItemId());

            } catch (ProfitMandiBusinessException e) {

                // TODO Auto-generated catch block

                return null;

            }

        }));

        LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

                .selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);

        LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);

        Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

                .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

        LOGGER.info("paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        this.addInsuranceProvider(insurancePolicies);

        model.addAttribute("fofoOrder", fofoOrder);

        for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

            fofoOrderItem.setDoa(true);

        }

        Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()

                .collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));

        Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()

                .collect(Collectors.toMap(foi -> foi.getId(),

                        foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));

        Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();

        for (FofoOrderItem foi : fofoOrderItems) {

            for (FofoLineItem fli : foi.getFofoLineItems()) {

                inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());

            }

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

                    .selectAllByOrderItemId(foi.getId());

            for (CustomerReturnItem customerReturnItem : customerReturnItems) {

                inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

                        inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);

            }

        }

        model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

                StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

        model.addAttribute("fofoOrderItems", fofoOrderItems);

        model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));

        model.addAttribute("fofoOrderItemIdLineItemsMap", StringUtils.toString(fofoOrderItemIdLineItemMap));

        model.addAttribute("itemsMap", itemsMap);

        model.addAttribute("markDefective", true);

        model.addAttribute("customer", customer);

        model.addAttribute("customerAddress", customerAddress);

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

        model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);

        model.addAttribute("insurancePolicies", insurancePolicies);

        model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);

        model.addAttribute("totalNumberOfPaymentOptionId", fofoPartnerPaymentOptions.size());

        model.addAttribute("stateNames",

                stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));

        return "search-order-details";

    }

    private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(

            List<PaymentOptionTransaction> paymentOptionTransactions) throws ProfitMandiBusinessException {

        Set<Integer> paymentOptionIds = new HashSet<>();

        for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

            paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());

        }

        List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(paymentOptionIds);

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();

        for (PaymentOption paymentOption : paymentOptions) {

            paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);

        }

        return paymentOptionIdPaymentOptionMap;

    }

    private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(

            List<Integer> fofoPartnerPaymentOptions) throws ProfitMandiBusinessException {

        List<PaymentOption> paymentOptions = paymentOptionRepository

                .selectByIds(new HashSet<>(fofoPartnerPaymentOptions));

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();

        for (PaymentOption paymentOption : paymentOptions) {

            paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);

        }

        return paymentOptionIdPaymentOptionMap;

    }

    private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(

            List<PaymentOptionTransaction> paymentOptionTransactions) {

        Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = new HashMap<>();

        for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

            paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),

                    paymentOptionTransaction);

        }

        return paymentOptionIdPaymentOptionTransactionMap;

    }

    @RequestMapping(value = "/order")

    public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model)

            throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());

        Address address = addressRepository.selectById(addressId);

        List<CartFofo> cartItems = orderService.cartCheckout(cartData);

        Set<Integer> itemIds = new HashSet<>();

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

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

        for (CartFofo cartFofo : cartItems) {

            itemIds.add(cartFofo.getItemId());

            if (cartFofo.getPoId() != 0) {

                poIds.add(cartFofo.getPoId());

                poItemIds.add(cartFofo.getPoItemId());

            }

        }

        PendingOrder po = null;

        Customer customer = null;

        PendingOrderItem poi = null;

        Map<Integer, PriceModel> mopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIds,

                loginDetails.getFofoId());

        List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository

                .selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());

        if (!poIds.isEmpty()) {

            po = pendingOrderRepository.selectById(poIds.get(0));

            customer = customerRepository.selectById(po.getCustomerId());

            if (!offlineOrders.contains(po.getPayMethod())) {

                paymentOptionIds.add(23);

            }

        }

        if (!poItemIds.isEmpty()) {

            poi = pendingOrderItemRepository.selectById(poItemIds.get(0));

        }

        // List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new

        // HashSet<>(paymentOptionIds));

        List<PaymentOption> paymentOptions = paymentOptionRepository.selectActiveOption();

        LOGGER.info("pendingOrder" + po);

        LOGGER.info("pendingOrderItem" + poi);

        int onlineSellingPrice = 0;

        Map<Integer, PendingOrderItem> itemIdAndPoiMap = new HashMap<>();

        if (po != null) {

            List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(po.getId());

            for (PendingOrderItem poItem : pendingOrderItems) {

                onlineSellingPrice += poItem.getSellingPrice();

            }

            itemIdAndPoiMap = pendingOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> pendingOrderItemRepository.selectById(x.getId())));

        }

        LOGGER.info("itemIdAndPoiMap {}", itemIdAndPoiMap);

        LOGGER.info("mopPriceMap {}", mopPriceMap);

        model.addAttribute("stateNames",

                stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));

        model.addAttribute("retailerStateName", address.getState());

        model.addAttribute("pendingPOCustomer", gson.toJson(customer));

        model.addAttribute("pendingPO", gson.toJson(po));

        model.addAttribute("cartItems", cartItems);

        model.addAttribute("pendingOrder", po);

        model.addAttribute("pendingOrderItem", poi);

        model.addAttribute("itemIdAndPoiMap", itemIdAndPoiMap);

        model.addAttribute("onlineSellingPrice", onlineSellingPrice);

        model.addAttribute("mopPriceMap", mopPriceMap);

        model.addAttribute("paymentOptions", paymentOptions);

        model.addAttribute("accessoriesDeals", accessoriesDeals);

        return "order-index";

    }

    private void sendWhatsappInvoice(FofoOrder fofoOrder) throws Exception {

        Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

        CustomRetailer retailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());

        String message = String.format("Dear %s,\n" +

                "Thank you for your purchase from SmartDukaan store - %s, %s.\n" +

                "Your purchase invoice is attached for your reference.\n" +

                "\n" +

                "Download our app for offers and updates on new products.\n" +

                "https://www.smartdukaan.com/b2c\n" +

                "\n" +

                "Best Regards\n" +

                "SmartDukaan", customer.getFirstName(), retailer.getBusinessName(), retailer.getAddress().getCity());

        boolean shouldSendWhatsappMessage = notificationService.shouldSendWhatsappMessage(customer.getMobileNumber());

        if (shouldSendWhatsappMessage) {

            notificationService.sendWhatsappMediaMessage(message, customer.getMobileNumber(), this.getPublicInvoiceUrl(fofoOrder.getInvoiceNumber()),

                    this.getFileName(fofoOrder.getInvoiceNumber()), WhatsappMessageType.DOCUMENT);

        }

    }

    private String getFileName(String invoiceNumber) {

        return "INV-" + invoiceNumber.replace("/", "-") + ".pdf";

    }

    private String getPublicInvoiceUrl(String invoiceNumber) {

        String base64Encoded = Base64.getMimeEncoder().encodeToString(invoiceNumber.getBytes(StandardCharsets.UTF_8));

        String publicUrl = "https://partners.smartdukaan.com/wa-invoice-send/" + base64Encoded + ".pdf";

        LOGGER.info("Public Whatsapp Url for Invoice Message - {}", publicUrl);

        return publicUrl;

    }

    @RequestMapping(value = "/order/bad_return", method = RequestMethod.POST)

    public ResponseEntity<?> badReturn(HttpServletRequest request, @RequestBody FoiBadReturnRequest foiBadReturnRequest,

                                       Model model) throws ProfitMandiBusinessException {

        LOGGER.info("request at uri {} body {}", request.getRequestURI(), foiBadReturnRequest);

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        CustomerCreditNote custmoerCreditNote;

        if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

            FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());

            FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());

            custmoerCreditNote = orderService.badReturn(fo.getFofoId(), foiBadReturnRequest);

        } else {

            custmoerCreditNote = orderService.badReturn(fofoDetails.getFofoId(), foiBadReturnRequest);

        }

        return responseSender.ok(custmoerCreditNote.getId());

    }

    @GetMapping(value = "/wa-invoice-send/{invoiceHash}")

    public ResponseEntity<?> generateInvoice(@PathVariable String invoiceHash) throws ProfitMandiBusinessException {

        String decodedInvoiceNumber = new String(Base64.getMimeDecoder().decode(invoiceHash));

        LOGGER.info("Invoice Hash {}", invoiceHash);

        FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(decodedInvoiceNumber);

        InvoicePdfModel pdfModel = orderService.getInvoicePdfModel(fofoOrder.getId());

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);

        final HttpHeaders headers = new HttpHeaders();

        //headers.setContentDispositionFormData("inline", number + ".pdf");

        headers.add(HttpHeaders.CONTENT_DISPOSITION, "inline;filename=" + pdfModel.getInvoiceNumber() + ".pdf");

        int contentLength = byteArrayOutputStream.toByteArray().length;

        final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

        return ResponseEntity.ok()

                .headers(headers)

                .contentLength(contentLength)

                .contentType(MediaType.parseMediaType("application/pdf"))

                .body(inputStreamResource);

    }

    @RequestMapping(value = "/wa-listen", method = RequestMethod.POST)

    public ResponseEntity<?> listenWhatsappStatus(@RequestBody String whatsappJsonResponse) {

        LOGGER.info("whatsappJsonResponse {}", whatsappJsonResponse);

        //jaihind

        //  String jsonString = "[{\"srcAddr\":\"TESTSM\",\"channel\":\"WHATSAPP\",\"externalId\":\"4977024756456780043-180044363908187691\",\"cause\":\"SUCCESS\",\"errorCode\":\"000\",\"destAddr\":\"919813272029\",\"eventType\":\"DELIVERED\",\"eventTs\":1692848106000}]";

        JSONArray jsonArray = new JSONArray(whatsappJsonResponse);

        for (int i = 0; i < jsonArray.length(); i++) {

            JSONObject jsonObject = jsonArray.getJSONObject(i);

            String externalId = jsonObject.getString("externalId");

            String destAddr = jsonObject.getString("destAddr");

            String eventType = jsonObject.getString("eventType");

            whatsappMessageService.setWhatsappResponse(externalId, destAddr, eventType);

        }

        //jaihind

        return responseSender.ok("Success");

    }

    @RequestMapping(value = "/generateInvoice")

    public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,

                                             @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId) throws ProfitMandiBusinessException {

        LOGGER.info("Request received at url {} with params [{}={}] ", request.getRequestURI(),

                ProfitMandiConstants.ORDER_ID, orderId);

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        InvoicePdfModel pdfModel = null;

        if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

            pdfModel = orderService.getInvoicePdfModel(orderId);

        } else {

            pdfModel = orderService.getInvoicePdfModel(fofoDetails.getFofoId(), orderId);

        }

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);

        LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);

        final HttpHeaders headers = new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

        headers.setContentDispositionFormData("inline", "invoice-" + pdfModel.getInvoiceNumber() + ".pdf");

        headers.setContentLength(byteArrayOutputStream.toByteArray().length);

        final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

        return new ResponseEntity<>(inputStreamResource, headers, HttpStatus.OK);

    }

    @RequestMapping(value = "/generateInvoices")

    public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,

                                             @RequestParam LocalDateTime startDate, @RequestParam LocalDateTime endDate, @RequestParam int partnerId)

            throws ProfitMandiBusinessException {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        List<InvoicePdfModel> pdfModels = new ArrayList<>();

        if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

            List<Integer> orderIds = fofoOrderRepository.selectByFofoId(partnerId, startDate, endDate, 0, 0).stream()

                    .map(x -> x.getId()).collect(Collectors.toList());

            for (int orderId : orderIds) {

                pdfModels.add(orderService.getInvoicePdfModel(orderId));

            }

            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

            PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

            LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);

            final HttpHeaders headers = new HttpHeaders();

            headers.setContentType(MediaType.APPLICATION_PDF);

            headers.set("Content-disposition", "inline; filename=invoice-" + partnerId + ".pdf");

            headers.setContentLength(byteArrayOutputStream.toByteArray().length);

            final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

            final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

            return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

        } else {

            throw new ProfitMandiBusinessException("Auth", fofoDetails.getEmailId(), "Unauthorised access");

        }

    }

    @RequestMapping(value = "/saleHistory")

    public String saleHistory(HttpServletRequest request,

                              @RequestParam(name = "searchValue", defaultValue = "") String searchValue,

                              @RequestParam(name = "searchType", defaultValue = "") SearchType searchType,

                              @RequestParam(required = false) LocalDateTime startTime,

                              @RequestParam(required = false) LocalDateTime endTime,

                              @RequestParam(name = "offset", defaultValue = "0") int offset,

                              @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

            throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,

                startTime, endTime, offset, limit);

        model.addAllAttributes(map);

        return "sale-history";

    }

    @RequestMapping(value = "/downloadInvoices")

    public ResponseEntity<?> downloadInvoices(HttpServletRequest request,

                                              @RequestParam(name = "searchValue", defaultValue = "") String searchValue,

                                              @RequestParam(name = "searchType", defaultValue = "") SearchType searchType,

                                              @RequestParam(required = false) LocalDateTime startTime,

                                              @RequestParam(required = false) LocalDateTime endTime,

                                              @RequestParam(name = "offset", defaultValue = "0") int offset,

                                              @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

            throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,

                startTime, endTime, offset, 100);

        List<FofoOrder> fofoOrders = (List<FofoOrder>) map.get("saleHistories");

        if (fofoOrders.size() == 0) {

            throw new ProfitMandiBusinessException("Search criteria", "", "No orders found for criteria");

        }

        final HttpHeaders headers = new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

        headers.set("Content-disposition", "inline; filename=invoices.pdf");

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        List<InvoicePdfModel> pdfModels = new ArrayList<>();

        for (FofoOrder fofoOrder : fofoOrders) {

            try {

                pdfModels.add(orderService.getInvoicePdfModel(fofoOrder.getId()));

            } catch (Exception e) {

                LOGGER.info("could not create invoice for {}, invoice number {}", fofoOrder.getId(),

                        fofoOrder.getInvoiceNumber());

            }

        }

        PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

        headers.setContentLength(byteArrayOutputStream.toByteArray().length);

        final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

    }

    @RequestMapping(value = "/credit-note/{creditNoteId}")

    public ResponseEntity<?> downloadCreditNote(HttpServletRequest request, @PathVariable int creditNoteId)

            throws ProfitMandiBusinessException {

        CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        PdfUtils.generateAndWriteCustomerCreditNotes(Arrays.asList(creditNotePdfModel), byteArrayOutputStream);

        LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);

        final HttpHeaders headers = new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

        headers.set("Content-disposition",

                "inline; filename=invoice-" + creditNotePdfModel.getCreditNoteNumber() + ".pdf");

        headers.setContentLength(byteArrayOutputStream.toByteArray().length);

        final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

    }

    @RequestMapping(value = "/getPaginatedSaleHistory")

    public String getSaleHistoryPaginated(HttpServletRequest request,

                                          @RequestParam(name = "searchValue", defaultValue = "") String searchValue,

                                          @RequestParam(name = "searchType", defaultValue = "") SearchType searchType,

                                          @RequestParam(required = false) LocalDateTime startTime,

                                          @RequestParam(required = false) LocalDateTime endTime,

                                          @RequestParam(name = "offset", defaultValue = "0") int offset,

                                          @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

            throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Map<String, Object> map = orderService.getSaleHistoryPaginated(loginDetails.getFofoId(), searchType,

                searchValue, startTime, endTime, offset, limit);

        model.addAllAttributes(map);

        return "sale-history-paginated";

    }

    @PutMapping(value = "/updatePaymentTransaction")

    public String updateTransactionDetails(HttpServletRequest request, @RequestParam String referenceType,

                                           @RequestParam int fofoId, @RequestParam int referenceId,

                                           @RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,

                                           @RequestParam float totalAmount, Model model) throws Exception {

        List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel

                .getPaymentOptionTransactionModel();

        LOGGER.info(paymentOptionTransactionModels);

        FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, referenceId);

        LOGGER.info("sdssd" + fofoOrder);

        fofoOrder.setTotalAmount(totalAmount);

        List<FofoItemIdAmountModel> fofoItemIdAmountModel = partnerOptionsAndItemAmountModel.getItemAmountModel();

        for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {

            LOGGER.info("fim" + fim.getFofoItemId());

            LOGGER.info("fimAmount" + fim.getAmount());

            Item item = itemRepository.selectById(fim.getItemId());

            TagListing tagListing = tagListingRepository.selectByItemId(item.getId());

            FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(fim.getFofoItemId());

            LOGGER.info("category" + item.getCategoryId());

            if (item.getCategoryId() == ProfitMandiConstants.MOBILE_CATEGORY_ID) {

                if (fofoOrderItem.getMop() <= fim.getAmount()) {

                    if (fim.getAmount() <= tagListing.getMrp()) {

                        fofoOrderItem.setSellingPrice(fim.getAmount());

                    } else {

                        throw new ProfitMandiBusinessException("Amount", fim.getAmount(),

                                "Sum of amount is not less than  to MRP");

                    }

                    LOGGER.info("fofoOrderItem2" + fofoOrderItem);

                } else {

                    // TODO below mop condition need to added added

                    fofoOrderItem.setSellingPrice(fim.getAmount());

                }

            } else {

                fofoOrderItem.setSellingPrice(fim.getAmount());

                LOGGER.info("fofoOrderItem1" + fofoOrderItem);

            }

            LOGGER.info("fofoOrderItem" + fofoOrderItem);

        }

        /*

         * for (PaymentOptionTransactionModel paymentOptionTransactionModel :

         * paymentOptionTransactionModels) { amount = amount +

         * paymentOptionTransactionModel.getAmount(); } LOGGER.info("FofoOrder amount" +

         * fofoOrder.getUnitPrice() + "amount" + amount); if (amount ==

         * fofoOrder.getUnitPrice()) {

         */

        if (paymentOptionTransactionModels.size() > 0) {

            List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

                    .selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);

            Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

                    .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

            LOGGER.info(

                    "paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

            for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {

                if (paymentOptionIdPaymentOptionTransactionMap

                        .containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {

                    PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap

                            .get(paymentOptionTransactionModel.getPaymentOptionId());

                    if (paymentOptionTransactionModel.getAmount() == 0) {

                        paymentOptionTransactionRepository.delete(paymentOptionTransaction);

                        LOGGER.info("deleted successfully");

                    } else {

                        paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

                        paymentOptionTransactionRepository.persist(paymentOptionTransaction);

                        LOGGER.info("updated successfully");

                    }

                } else {

                    if (paymentOptionTransactionModel.getAmount() > 0) {

                        PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();

                        paymentOptionTransaction.setReferenceId(referenceId);

                        paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);

                        paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());

                        paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

                        paymentOptionTransaction.setFofoId(fofoId);

                        paymentOptionTransaction.setCreateTimestamp(fofoOrder.getCreateTimestamp());

                        paymentOptionTransactionRepository.persist(paymentOptionTransaction);

                        LOGGER.info("inserted successfully");

                    }

                }

            }

            model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        }

        /*

         * else

         *

         * { throw new ProfitMandiBusinessException("Amount", amount,

         * "Sum of amount is not equal to total amount"); }

         */

        return "response";

    }

    private Map<String, List<MobileInsurancePlan>> getPlans(float sellingPrice, int itemId)

            throws ProfitMandiBusinessException {

        try {

            Map<String, List<MobileInsurancePlan>> productDurationPlans = insuranceService.getAllPlans(itemId,

                    sellingPrice);

            return productDurationPlans;

        } catch (Exception e) {

            LOGGER.info(e, e);

            throw new ProfitMandiBusinessException("Fetch Insurance Plans", "Insurance",

                    "Could not fetch insurance Plans");

        }

    }

    @GetMapping("/insuranceDetails")

    public String getInsuranceDetails(HttpServletRequest request,

                                      @RequestParam(name = "offset", defaultValue = "0") int offset,

                                      @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

            throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        long size = 0;

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),

                offset, limit);

        size = insurancePolicyRepository.selectCountByRetailerId(loginDetails.getFofoId());

        Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository

                .selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))

                .stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));

        if (size < limit) {

            model.addAttribute("end", offset + size);

        } else {

            model.addAttribute("end", offset + limit);

        }

        model.addAttribute("start", offset + 1);

        model.addAttribute("size", size);

        model.addAttribute("insurancePolicies", insurancePolicies);

        model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);