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.CustomerOffer;

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

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.*;

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

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

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

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.model.ItemWiseCustomerOfferSummaryModel;

import com.spice.profitmandi.dao.model.hdfc.IrnResetOrderModel;

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

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

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.dao.service.ScratchService;

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.bharti.model.PlanVariant;

import com.spice.profitmandi.service.integrations.icicilombard.IciciLombardService;

import com.spice.profitmandi.service.integrations.pinelabs.PinelabsOfferCacheService;

import com.spice.profitmandi.service.integrations.pinelabs.dto.Tenure;

import com.spice.profitmandi.service.integrations.icicilombard.model.AfinityQuoteModel;

import com.spice.profitmandi.service.integrations.icicilombard.model.AfinityQuoteResponseModel;

import com.spice.profitmandi.service.integrations.oneassist.OneAssistService;

import com.spice.profitmandi.service.integrations.oneassist.model.CancelPlanRequestModel;

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.SDCreditService;

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.*;

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

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 static final 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

    private CatalogRepository catalogRepository;

    @Autowired

    private CustomerOfferRepository customerOfferRepository;

    @Autowired

    private CustomerOfferItemRepository customerOfferItemRepository;

    @Autowired

    private WebOfferRepository webOfferRepository;

    @Autowired

    PositionRepository positionRepository;

    @Autowired

    PendingOrderPlanRepository pendingOrderPlanRepository;

    @Autowired

    PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

    @Autowired

    SDCreditService sdCreditService;

    @Autowired

    IciciPolicyTrackerRepository iciciPolicyTrackerRepository;

    @Autowired

    ScratchService scratchService;

    @Autowired

    IciciLombardService iciciLombardService;

    @Autowired

    PinelabsOfferCacheService pinelabsOfferCacheService;

    @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.error("Could not send whatsapp message for order {}", orderId, e);

        }

        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);

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

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

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

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

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

        Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = new HashMap<>();

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

        for (FofoOrderItem foi : fofoOrderItems) {

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

                    .selectAllByOrderItemId(foi.getId());

            foiIdCustomerReturnInventoryItemsMap.put(foi.getId(), customerReturnItems);

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

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

            }

            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 {

        LOGGER.info("CustomCustomer {}", customCustomer);

        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);

        if (fofoOrder == null) {

            throw new ProfitMandiBusinessException("invalid invoice number", "invoice - " + invoiceNumber, "Please enter valid invoice number");

        }

        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());

        Set<Integer> searchItemIds = fofoOrderItems.stream().map(FofoOrderItem::getItemId).collect(Collectors.toSet());

        Map<Integer, Item> itemsMap = itemRepository.selectByIds(searchItemIds).stream()

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

        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 = new HashMap<>();

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

        for (FofoOrderItem foi : fofoOrderItems) {

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

                    .selectAllByOrderItemId(foi.getId());

            foiIdCustomerReturnInventoryItemsMap.put(foi.getId(), customerReturnItems);

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

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

            }

            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 = "/checkplans", method = RequestMethod.GET)

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

                                     @RequestParam int itemId, @RequestParam int poiId) throws ProfitMandiBusinessException {

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

        try {

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

            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 = "/getPlanQuote", method = RequestMethod.GET)

    public String getPlanQuote(HttpServletRequest request, Model model,

                               @RequestParam String planCode, @RequestParam int sumInsured, @RequestParam String manufacturedDate, @RequestParam int itemId, @RequestParam String planName) throws ProfitMandiBusinessException {

        try {

            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");

            LocalDate manufactured = LocalDate.parse(manufacturedDate, formatter);

            PlanVariant planVariant = insuranceService.getICICIPremiumByVariantId(planCode);

            LOGGER.info("planVariant111 {}", planVariant);

            String correlationId = UUID.randomUUID().toString();

            IciciPolicyTracker policyTracker = new IciciPolicyTracker();

            policyTracker.setCorrelationId(correlationId);

            iciciPolicyTrackerRepository.persist(policyTracker);

            // Policy validity (1 year from today)

            LocalDate today = LocalDate.now();

            LocalDate oneYearLater = today.plusYears(1);

            String itemBrand = itemRepository.selectById(itemId).getBrand();

            AfinityQuoteModel quoteModel = new AfinityQuoteModel();

            quoteModel.setProductCode(iciciLombardService.PRODUCT_CODE_STAGGING);

            quoteModel.setPlanCode(String.valueOf(planVariant.getOurPlanId()));

            quoteModel.setPlanName(planName);

            quoteModel.setSumInsured((int) sumInsured);

            quoteModel.setPolicyStartDate(today.toString());          // format: yyyy-MM-dd

            quoteModel.setPolicyEndDate(oneYearLater.toString());

            quoteModel.setTaxEffectiveDate(today.toString());

            quoteModel.setPolicyType("New");

            quoteModel.setIlgicStateName(iciciLombardService.PARTY_STATE_NAME);

            quoteModel.setPartyStateName(iciciLombardService.PARTY_STATE_NAME);

            quoteModel.setUserLevel("UW3");

            quoteModel.setNoOfClaimsAllowed(999);

            quoteModel.setMakeAndModelOfGadget("High");

            quoteModel.setPremiumBeforeEndorsementCancellation(0);

            quoteModel.setGeographicalLimit("WithinIndia");

            quoteModel.setTransactionDate(today.toString());

            quoteModel.setEndorsementEffectiveDate(today.toString());

            quoteModel.setRegisteredCustomer(true);

            quoteModel.setCorrelationId(correlationId);

            // Set cover details

            AfinityQuoteModel.CoverDetail coverDetail = new AfinityQuoteModel.CoverDetail();

            coverDetail.setName("Accidental Damage");

            coverDetail.setPremium(0);

            // Set risk details

            AfinityQuoteModel.RiskDetail riskDetail = new AfinityQuoteModel.RiskDetail();

            riskDetail.setRiskSIComponent("MOBILE");

            riskDetail.setCoverDetails(Arrays.asList(coverDetail));

            quoteModel.setRisksDetails(Arrays.asList(riskDetail));

            AfinityQuoteResponseModel afinityQuoteResponseModel = iciciLombardService.hitAfinityQuote(quoteModel);

            float planDp = insuranceService.getPlanDp(afinityQuoteResponseModel.getTotalPremium(), planVariant.getCoverage());

            Map<String, Object> responseMap = new HashMap<>();

            responseMap.put("afinityQuoteModel", afinityQuoteResponseModel);

            responseMap.put("planDp", planDp);

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

        } catch (Exception e) {

            // TODO Auto-generated catch block

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

            throw new ProfitMandiBusinessException("Plans", "Plans Quote", "Error qutotation insurance plans");

        }

        return "response";

    }

    private boolean sendWhatsappInvoice(FofoOrder fofoOrder) throws Exception {

        return this.sendWhatsappInvoice(fofoOrder, "");

    }

    private boolean sendWhatsappInvoice(FofoOrder fofoOrder, String whatsAppNo) throws Exception {

        boolean shouldSendWhatsappMessage = notificationService.shouldSendWhatsappMessage(whatsAppNo);

        boolean isSend = false;

        if (shouldSendWhatsappMessage) {

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

            String mobileNumber;

            if (!whatsAppNo.isEmpty()) {

                mobileNumber = whatsAppNo;

            } else {

                mobileNumber = customer.getMobileNumber();

            }

            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());

            isSend = notificationService.sendWhatsappMediaMessage(message, mobileNumber, this.getPublicInvoiceUrl(fofoOrder.getInvoiceNumber()),

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

        }

        return isSend;

    }

    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(fofoDetails.getEmailId(), 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);

        }

        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        // Step 1: Generate invoice PDF

        ByteArrayOutputStream invoiceOutput = new ByteArrayOutputStream();

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

        byte[] invoicePdf = invoiceOutput.toByteArray();

        // Step 2: Load all policy certificate PDFs

        List<byte[]> pdfFiles = new ArrayList<>();

        pdfFiles.add(invoicePdf); // first add invoice

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

            if (insurancePolicy.getProviderId() == 6) {

                String policyNumber = insurancePolicy.getPolicyNumber();

                String safePolicyNo = policyNumber.replace("/", "-");

                String filePath = "/uploads/policy-certificate-" + safePolicyNo + ".pdf";

                File file = new File(filePath);

                if (file.exists()) {

                    try {

                        byte[] policyPdf = Files.readAllBytes(file.toPath());

                        pdfFiles.add(policyPdf);

                    } catch (IOException e) {

                        LOGGER.error("Failed to read policy PDF: {}", filePath, e);

                    }

                } else {

                    LOGGER.warn("Policy PDF not found: {}", filePath);

                }

            }

        }

        // Step 3: Merge all PDFs

        byte[] mergedPdf;

        try {

            mergedPdf = PdfUtils.mergePdfFiles(pdfFiles);

        } catch (Exception e) {

            LOGGER.error("Error merging PDFs", e);

            throw new ProfitMandiBusinessException("Failed to generate merged PDF", "", "");

        }

        // Step 4: Return merged PDF as response

        HttpHeaders headers = new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

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

        headers.setContentLength(mergedPdf.length);

        InputStreamResource resource = new InputStreamResource(new ByteArrayInputStream(mergedPdf));

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

    }

   /* @RequestMapping(value = "/generateInvoice")

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

                                             @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, @RequestParam(required = false) PrinterType printerType) throws ProfitMandiBusinessException {

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

                ProfitMandiConstants.ORDER_ID, orderId);

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        InvoicePdfModel pdfModel = null;

        int fofoId;

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

            pdfModel = orderService.getInvoicePdfModel(orderId);

            fofoId = pdfModel.getCustomer().getCustomerId();

        } else {

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

            fofoId = fofoDetails.getFofoId();

        }

        if (printerType == null) {

            FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

            //printerType = fs.getPrinterType();

        }

        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        // Step 1: Generate invoice PDF

        ByteArrayOutputStream invoiceOutput = new ByteArrayOutputStream();

        PdfUtils.generateAndWrite(Arrays.asList(pdfModel), printerType, invoiceOutput);

        byte[] invoicePdf = invoiceOutput.toByteArray();

        // Step 2: Load all policy certificate PDFs

        List<byte[]> pdfFiles = new ArrayList<>();

        pdfFiles.add(invoicePdf); // first add invoice

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

            if (insurancePolicy.getProviderId() == 6) {

                String policyNumber = insurancePolicy.getPolicyNumber();

                String safePolicyNo = policyNumber.replace("/", "-");

                String filePath = "/uploads/policy-certificate-" + safePolicyNo + ".pdf";

                File file = new File(filePath);

                if (file.exists()) {

                    try {

                        byte[] policyPdf = Files.readAllBytes(file.toPath());

                        pdfFiles.add(policyPdf);

                    } catch (IOException e) {

                        LOGGER.error("Failed to read policy PDF: {}", filePath, e);

                    }

                } else {

                    LOGGER.warn("Policy PDF not found: {}", filePath);

                }

            }

        }

        // Step 3: Merge all PDFs

        byte[] mergedPdf;

        try {

            mergedPdf = PdfUtils.mergePdfFiles(pdfFiles);

        } catch (Exception e) {

            LOGGER.error("Error merging PDFs", e);

            throw new ProfitMandiBusinessException("Failed to generate merged PDF", "", "");

        }

        // Step 4: Return merged PDF as response

        HttpHeaders headers = new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

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

        headers.setContentLength(mergedPdf.length);

        InputStreamResource resource = new InputStreamResource(new ByteArrayInputStream(mergedPdf));

        return new ResponseEntity<>(resource, 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,