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.FormattingUtils;
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.catalog.Item;
import com.spice.profitmandi.dao.entity.catalog.TagListing;
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.user.Address;
import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;
import com.spice.profitmandi.dao.enumuration.transaction.OrderStatus;
import com.spice.profitmandi.dao.model.*;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
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.OrderRepository;
import com.spice.profitmandi.dao.repository.user.AddressRepository;
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.OrderService;
import com.spice.profitmandi.service.pricing.PricingService;
import com.spice.profitmandi.service.user.RetailerService;
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 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 javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
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
    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;

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

        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("mopPriceMap", mopPriceMap);
        model.addAttribute("paymentOptions", paymentOptions);
        model.addAttribute("accessoriesDeals", accessoriesDeals);
        return "order-index";
    }

    @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 = "/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) {
        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) {
        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) {
        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 = "/create-order", method = RequestMethod.POST)
    public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest,
                              Model model) throws ProfitMandiBusinessException {
        // throw new ProfitMandiBusinessException("Billing is on hold temporarily",
        // "Billing is on hold temporarily", "Billing is on hold temporarily");
        LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        int fofoOrderId = orderService.createOrder(createOrderRequest, fofoDetails.getFofoId(), accessoriesDeals);

        LOGGER.info("Order has been created successfully...");
        try {
            this.sendWhatsappInvoice(fofoOrderRepository.selectByOrderId(fofoOrderId));
        } catch (Exception e) {
            LOGGER.info("Could not send whatsapp message");
            e.printStackTrace();
        }
        return "redirect:/get-order/?orderId=" + fofoOrderId;
    }

    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 sentMessage = notificationService.isWhatMessageSend(customer.getMobileNumber());
        if (sentMessage) {
            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);
        return "insurance-details";
    }

    @GetMapping("/insuranceDetailsPaginated")
    public String getInsuranceDetailsPaginated(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);
        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),
                offset, limit);
        Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository
                .selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))
                .stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));
        model.addAttribute("insurancePolicies", insurancePolicies);
        model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);
        return "insurance-details-paginated";
    }

    @GetMapping("/getMouForm")
    public String getMouForm(HttpServletRequest request, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());
        if (mou != null) {
            if (mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
            } else {
                model.addAttribute("response1", mvcResponseSender.createResponseString(false));
            }

        } else {
            model.addAttribute("response1", mvcResponseSender.createResponseString(false));

        }
        return "response";

    }

    @GetMapping("/pendingOrders")
    public String getPendingOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
        Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());
        if (mou == null) {
            mou = new Mou();
            mou.setFofoId(loginDetails.getFofoId());
            mou.setCreateTimestamp(LocalDateTime.now());
            mou.setUpdateTimestamp(LocalDateTime.now());
            mouRepository.persist(mou);
        } else if (!mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {
            mou.setUpdateTimestamp(LocalDateTime.now());
        }

        List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.PROCESSING,
                loginDetails.getFofoId());

        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItems, loginDetails.getFofoId());
        model.addAttribute("inventoryMap", map.get("inventoryMap"));
        model.addAttribute("pendingOrderItems", (List<PendingOrderItem>)map.get("pendingOrderItems"));

        model.addAttribute("isAdmin", isAdmin);
        return "pending_fofo_order";

    }

    @GetMapping("/billedOrders")
    public String getBilledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        List<PendingOrderItem> pendingOrderItem;

        if (isAdmin) {

            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.BILLED);

        } else {
            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.BILLED,
                    loginDetails.getFofoId());
        }

        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());

        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
        model.addAttribute("isAdmin", isAdmin);
        return "billed_order_item";
    }

    @GetMapping("/settledOrders")
    public String getSettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        List<PendingOrderItem> pendingOrderItem = null;

        if (isAdmin) {

            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.SETTLED);

        } else {
            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.SETTLED,
                    loginDetails.getFofoId());
        }

        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());

        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
        model.addAttribute("isAdmin", isAdmin);
        return "settled_order_item";
    }

    @GetMapping("/unsettledOrders")
    public String getunsettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        List<PendingOrderItem> pendingOrderItem = null;

        if (isAdmin) {

            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.UNSETTLED);

        } else {
            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.UNSETTLED,
                    loginDetails.getFofoId());
        }

        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());

        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
        model.addAttribute("isAdmin", isAdmin);
        return "unsettled_order_item";
    }

    @GetMapping("/claimedOrders")
    public String getclaimedOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
        List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
                .collect(Collectors.toList());

        List<PendingOrderItem> pendingOrderItem = null;

        if (isAdmin) {

            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.CLAIMED);
            Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

            Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
                    .filter(x -> x != null).collect(Collectors.toList()).stream()
                    .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
            model.addAttribute("customRetailersMap", customRetailersMap);

        } else {
            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.CLAIMED,
                    loginDetails.getFofoId());
        }

        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());

        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
        model.addAttribute("isAdmin", isAdmin);
        return "claim_raised_order_item";
    }

    @GetMapping("/getPendingOrderItem")
    public String getPendingOrderItem(HttpServletRequest request, @RequestParam int orderId, Model model)
            throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        Map<Integer, Item> itemMap = new HashMap<>();
        Map<Integer, CurrentInventorySnapshot> inventoryMap = new HashMap<>();
        PendingOrder pendingPO = pendingOrderRepository.selectById(orderId);
        Customer customer = customerRepository.selectById(pendingPO.getCustomerId());
        List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(orderId);
        for (PendingOrderItem pendingOrderItem : pendingOrderItems) {
            Item item = itemRepository.selectById(pendingOrderItem.getItemId());
            CurrentInventorySnapshot cis = currentInventorySnapshotRepository
                    .selectByItemAndFofoId(pendingOrderItem.getItemId(), pendingPO.getFofoId());
            itemMap.put(pendingOrderItem.getItemId(), item);
            LOGGER.info("cis" + cis);
            inventoryMap.put(pendingOrderItem.getItemId(), cis);
        }

        LOGGER.info("inventoryMap" + inventoryMap);
        model.addAttribute("pendingOrderItems", pendingOrderItems);
        model.addAttribute("itemMap", itemMap);
        model.addAttribute("inventoryMap", inventoryMap);
        model.addAttribute("pendingPO", gson.toJson(pendingPO));
        model.addAttribute("pendingPOCustomer", gson.toJson(customer));
        model.addAttribute("isAdmin", roleManager.isAdmin(loginDetails.getRoleIds()));
        return "pending-order-item";
    }

    @RequestMapping(value = "/getPendingOrderItemById", method = RequestMethod.GET)
    public String getPendingOrderItemById(HttpServletRequest request, @RequestParam int id, Model model)
            throws Exception {

        PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
        model.addAttribute("pendingOrderItem", pendingOrderItem);
        return "cancel-pending-order";
    }

    @RequestMapping(value = "/getPendingOrderChangePartnerById", method = RequestMethod.GET)
    public String getPendingOrderChangePartnerById(HttpServletRequest request, @RequestParam int id, Model model)
            throws Exception {

        PendingOrder pendingOrder = pendingOrderRepository.selectById(id);
        Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(true);
        model.addAttribute("customRetailersMap", customRetailersMap);
        model.addAttribute("pendingOrder", pendingOrder);
        return "change-partner-po";
    }

    @RequestMapping(value = "/changePendingOrderPartner", method = RequestMethod.POST)
    public String changePendingOrderPartner(HttpServletRequest request, @RequestParam int id, @RequestParam int fofoId,
                                            Model model) throws Exception {

        PendingOrder pendingOrder = pendingOrderRepository.selectById(id);
        pendingOrder.setFofoId(fofoId);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        return "response";
    }

    @RequestMapping(value = "/cancelPendingOrderItem", method = RequestMethod.POST)
    public String cancelPendingOrderItem(HttpServletRequest request, @RequestParam int id, @RequestParam String reason,
                                         Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);

        pendingOrderItem.setStatus(OrderStatus.CANCELLED);
        pendingOrderItem.setStatusDescription(loginDetails.getEmailId());
        pendingOrderItem.setRemark(reason);
        pendingOrderItem.setCancelledTimestamp(LocalDateTime.now());
        PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());

        List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
                .map(x -> x.getStatus()).collect(Collectors.toList());

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

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

        Item item = itemRepository.selectById(pendingOrderItem.getItemId());
        pendingOrderItem.setItemName(item.getItemDescription());
        catalogIds.add(item.getCatalogItemId());

        Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
        JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
        pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
        pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
        CustomerAddress customerAddress = customerAddressRepository.selectById(pendingOrder.getCustomerAddressId());

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy h:mm a");

        Map<String, Object> emailModel = new HashMap<>();
        emailModel.put("customer", customerAddress);
        emailModel.put("pendingOrder", pendingOrder);
        emailModel.put("date", dateTimeFormatter);
        LOGGER.info("emal" + customer.getEmailId());
        String[] customerEmail = null;
        if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
            customerEmail = new String[]{customer.getEmailId()};

            List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");

            emailService.sendMailWithAttachments("Order Cancellation", "order-cancellation.vm", emailModel,
                    customerEmail, null, bccTo.toArray(new String[0]));

        }

        if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.PROCESSING)
                && !status.contains(OrderStatus.BILLED) && !status.contains(OrderStatus.UNSETTLED)
                && !status.contains(OrderStatus.CLAIMED)) {
            pendingOrder.setStatus(OrderStatus.CLOSED);
        }
        pendingOrderItemRepository.persist(pendingOrderItem);

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

        return "response";
    }

    @RequestMapping(value = "/deliveredPendingOrderItem", method = RequestMethod.POST)
    public String deliveredPendingOrderItem(HttpServletRequest request, @RequestParam int id, Model model)
            throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
        PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());

        if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
            pendingOrderItem.setStatus(OrderStatus.UNSETTLED);
            pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());

        } else {
            pendingOrderItem.setStatus(OrderStatus.SETTLED);
            pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());

        }

        List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
                .map(x -> x.getStatus()).collect(Collectors.toList());

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

        Item item = itemRepository.selectById(pendingOrderItem.getItemId());
        pendingOrderItem.setItemName(item.getItemDescription());
        catalogIds.add(item.getCatalogItemId());

        Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
        JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
        pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
        pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
        CustomerAddress customerAddress = customerAddressRepository.selectById(pendingOrder.getCustomerAddressId());

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy h:mm a");

        Map<String, Object> emailModel = new HashMap<>();
        emailModel.put("customer", customerAddress);
        emailModel.put("pendingOrder", pendingOrder);
        emailModel.put("date", dateTimeFormatter);
        Customer customer = customerRepository.selectById(pendingOrder.getCustomerId());
        String[] customerEmail = null;
        if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
            customerEmail = new String[]{customer.getEmailId()};
            List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");

            emailService.sendMailWithAttachments("Order Delivered with SmartDukaan", "order-delivered.vm", emailModel,
                    customerEmail, null, bccTo.toArray(new String[0]));

        }
        if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.PROCESSING)
                && !status.contains(OrderStatus.BILLED) && !status.contains(OrderStatus.UNSETTLED)
                && !status.contains(OrderStatus.CLAIMED)) {
            pendingOrder.setStatus(OrderStatus.CLOSED);
        }
        pendingOrderItemRepository.persist(pendingOrderItem);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        return "response";
    }

    @RequestMapping(value = "/raiseClaimOrderItem", method = RequestMethod.POST)
    public String raiseClaimOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
        PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());

        if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
            pendingOrderItem.setStatus(OrderStatus.CLAIMED);
            pendingOrderItem.setClaimedTimestamp(LocalDateTime.now());

        }
        pendingOrderItemRepository.persist(pendingOrderItem);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        return "response";
    }

    @RequestMapping(value = "/verifyOrderItem", method = RequestMethod.POST)
    public String verifyOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
        pendingOrderItem.setVerifiedTimestamp(LocalDateTime.now());

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

        return "response";
    }

    @RequestMapping(value = "/cancelOrderByInvoice", method = RequestMethod.POST)
    public String cancelOrder(HttpServletRequest request, @RequestParam List<String> invoiceNumbers, Model model)
            throws Exception {
        orderService.cancelOrder(invoiceNumbers);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        return "response";
    }

    @RequestMapping(value = "/getOnlineOrder", method = RequestMethod.GET)
    public String cancelOrder(HttpServletRequest request, Model model) throws Exception {
        return "online-order";
    }

    @GetMapping("/getAllOrdersByStatus")
    public String getAllOrdersByStatus(HttpServletRequest request, @RequestParam OrderStatus status,
                                       @RequestParam(required = false) LocalDateTime startTime,
                                       @RequestParam(required = false) LocalDateTime endTime, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        LOGGER.info("startTime {}", startTime);
        LOGGER.info("endTime {}", endTime);

        List<PendingOrderItem> pendingOrderItems;
        if (startTime == null) {
            pendingOrderItems = pendingOrderItemRepository.selectOrderItemByStatus(status);
        } else {
            List<OrderStatus> statusList = new ArrayList<>();
            if (status.equals(OrderStatus.DELIVERED)) {
                statusList.add(OrderStatus.SETTLED);
                statusList.add(OrderStatus.UNSETTLED);
            } else {
                statusList.add(status);
            }
            pendingOrderItems = pendingOrderItemRepository.selectByStatusAndCreateTimestamp(statusList,
                    startTime.toLocalDate().atStartOfDay(), endTime);
        }

        List<Integer> pendingOrderIds = pendingOrderItems.stream().map(x -> x.getOrderId()).collect(Collectors.toList());

        List<Integer> fofoIds = pendingOrderRepository.selectByIds(pendingOrderIds)
                .stream().map(x -> x.getFofoId()).distinct().collect(Collectors.toList());

        Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

        Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
                .filter(x -> x != null).collect(Collectors.toList()).stream()
                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
        model.addAttribute("customRetailersMap", customRetailersMap);

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

        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItems, 0);

        model.addAttribute("pendingOrderItems", (List<PendingOrderItem>) map.get("pendingOrderItems"));
        model.addAttribute("partnerInventoryMap", map.get("partnerInventoryMap"));

        model.addAttribute("isAdmin", isAdmin);
        return "online-order-item";
    }

    @RequestMapping(value = "/franchiseeSalesReport", method = RequestMethod.GET)
    public String getFranchiseeSalesReport(HttpServletRequest request, Model model)
            throws ProfitMandiBusinessException {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusDays(30).toLocalDate().atStartOfDay();
        FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoDetails.getFofoId());

        List<FocoSaleReportModel> focoSaleReportList = fofoOrderRepository.selectFocoSaleReport(fofoDetails.getFofoId(),
                fs.getCode(), currentStartMonth, currentDate);

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

        model.addAttribute("startDate", currentDate.minusDays(30).toLocalDate());
        model.addAttribute("endDate", LocalDate.now());
        model.addAttribute("focoSaleReportList", focoSaleReportList);
        return "foco-sale-report";
    }

    @RequestMapping(value = "/downloadFranchiseeSales", method = RequestMethod.GET)
    public ResponseEntity<?> getdownloadFranchiseeSales(HttpServletRequest request,
                                                        @RequestParam(name = "startDate", required = true, defaultValue = "") LocalDate startDate,
                                                        @RequestParam(name = "endDate", required = true, defaultValue = "") LocalDate endDate, Model model)
            throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
        List<List<?>> rows = new ArrayList<>();

        FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoDetails.getFofoId());
        List<FocoSaleReportModel> focoSaleReportList = fofoOrderRepository.selectFocoSaleReport(fofoDetails.getFofoId(),
                fs.getCode(), startDate.atStartOfDay(), endDate.atStartOfDay());
        LOGGER.info("FocoSaleReportList {}", focoSaleReportList);

        for (FocoSaleReportModel fsr : focoSaleReportList) {

            rows.add(Arrays.asList(fsr.getCode(), fsr.getName(), fsr.getCity(), fsr.getState(), fsr.getRegion(),
                    fsr.getItemId(), fsr.getBrand(), fsr.getModelName(), fsr.getModelNumber(), fsr.getColor(),
                    fsr.getQuantity(), fsr.getDp(), fsr.getSellingPrice(), fsr.getMop(), fsr.getSerialNumber(),
                    FormattingUtils.format(fsr.getCreateDate()), fsr.getCustomerName(), fsr.getCustomerPhone(),
                    fsr.getCustomerCity(), fsr.getCustomerPincode(), fsr.getInvoiceNumber(), fsr.getPurchaseReference(),
                    fsr.getCustomerGstNumber(), FormattingUtils.format(fsr.getCancelledTimestamp()),
                    FormattingUtils.format(fsr.getGrnCompleteDate()), fsr.getHygieneRating(), fsr.getRating(),
                    fsr.getStatus(), fsr.getRemark(), FormattingUtils.format(fsr.getCreatedTimestamp()),
                    FormattingUtils.format(fsr.getDisposedTimestamp()),
                    FormattingUtils.format(fsr.getNextTimestamp()),
                    FormattingUtils.format(fsr.getActivationTimestamp()),
                    FormattingUtils.format(fsr.getActivationTimestamp()), fsr.getLabel()));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
                Arrays.asList("Code", "Name", "City", "State", "Region", "Item Id", "Brand", "Model Name",
                        "Model Number", "Color", "Quantity", "Dp", "Selling_Price", "mop", "Serial Number",
                        "Create Date", "Customer Name", "Customer Phone", "Customer City", " Customer Pincode",
                        "Invoice  Number", "Purchase Reference", "Customer Gst Number", " Cancelled Timestamp",
                        "GRN Complete Date", "Hygiene Rating", "Rating", "Status", "Remark", "Created Timestamp",
                        "Disposed Timestamp", " Next Timestamp", "Activation Timestamp", "Create Timestamp", "Label"),
                rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, "Franchisee Sales Report");

        return responseEntity;

    }

    @RequestMapping(value = "/downloadWalletSummaryReport", method = RequestMethod.GET)
    public ResponseEntity<?> getDownloadWalletSummaryReport(HttpServletRequest request,
                                                            @RequestParam(name = "startDate", required = true, defaultValue = "") LocalDate startDate,
                                                            @RequestParam(name = "endDate", required = true, defaultValue = "") LocalDate endDate, Model model)
            throws Exception {

        List<List<?>> rows = new ArrayList<>();
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
        List<WalletSummaryReportModel> walletSummartList = fofoOrderRepository.selectWalletSummaryReport(
                fofoDetails.getFofoId(), startDate.atStartOfDay(), endDate.atTime(LocalTime.MAX));
        LOGGER.info("walletSummartList {}", walletSummartList);
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");

        for (WalletSummaryReportModel walletSummary : walletSummartList) {

            rows.add(Arrays.asList(walletSummary.getId(), walletSummary.getCode(), walletSummary.getName(),
                    walletSummary.getEmail(), walletSummary.getPhone(), walletSummary.getAmount(),
                    walletSummary.getRefundableAmount(), walletSummary.getReference(), walletSummary.getReferenceType(),
                    FormattingUtils.format(walletSummary.getBusinessTimestamp())));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil
                .getCSVByteStream(Arrays.asList("Id", "Code", "Name", "Email", "Phone", "Amount", "Refundable_amount",
                        "Reference", "Reference_type", "Business_timestamp", "Description"), rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, "Wallet Statement Report");

        return responseEntity;

    }

    @RequestMapping(value = "/walletSummaryReport", method = RequestMethod.GET)
    public String getWalletSummaryReport(HttpServletRequest request, Model model) throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusDays(30).toLocalDate().atStartOfDay();

        List<WalletSummaryReportModel> walletSummartList = fofoOrderRepository
                .selectWalletSummaryReport(fofoDetails.getFofoId(), currentStartMonth, currentDate);
        LOGGER.info("walletSummartList {}", walletSummartList);

        model.addAttribute("startDate", currentDate.minusDays(30).toLocalDate());
        model.addAttribute("endDate", LocalDate.now());
        model.addAttribute("walletSummartList", walletSummartList);

        return "wallet-summary-report";
    }

    @RequestMapping(value = "/pendingIndentReport", method = RequestMethod.GET)
    public String getPendingIndentReport(HttpServletRequest request, Model model) throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(2).toLocalDate().atStartOfDay();

        List<PendingIndentReportModel> pendingIndentReports = fofoOrderRepository
                .selectPendingIndentReport(fofoDetails.getFofoId(), currentStartMonth, currentDate);
        LOGGER.info("pendingIndentReports {}", pendingIndentReports);

        model.addAttribute("startDate", currentDate.minusMonths(2).toLocalDate());
        model.addAttribute("endDate", LocalDate.now());
        model.addAttribute("pendingIndentReports", pendingIndentReports);

        return "pending-indent-report";
    }

    @RequestMapping(value = "/pendingIndentReportDownload", method = RequestMethod.GET)
    public ResponseEntity<?> getPendingIndentReportDownload(HttpServletRequest request, Model model) throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(2).toLocalDate().atStartOfDay();
        List<List<?>> rows = new ArrayList<>();
        List<PendingIndentReportModel> pendingIndentReports = fofoOrderRepository
                .selectPendingIndentReport(fofoDetails.getFofoId(), currentStartMonth, currentDate);
        LOGGER.info("pendingIndentReports {}", pendingIndentReports);
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");

        for (PendingIndentReportModel pir : pendingIndentReports) {

            rows.add(Arrays.asList(pir.getTransactionId(), pir.getOrderId(),
                    pir.getCreatTimestamp().format(dateTimeFormatter), pir.getItemId(), pir.getBrand(),
                    pir.getModelName(), pir.getModelNumber(), pir.getColor(), pir.getQuantity(), pir.getUnitPrice(),
                    pir.getWalletAmount(), pir.getStatus(), pir.getInvoiceNumber(),
                    pir.getBillingTimestamp().format(dateTimeFormatter)));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(Arrays.asList(
                "Transaction Id", "Order Id", "Created_At", "Item_Id", "Brand", "Model Name", "Model Number", "Color",
                "Quantity", "Unit Price", "Wallet Deduction", "Status", "Invoice Number", "Billing Timestamp"), rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, "Order Status Summary Report");

        return responseEntity;
    }

    @RequestMapping(value = "/schemePayoutReport", method = RequestMethod.GET)
    public String getSchemePayoutReport(HttpServletRequest request, Model model) throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime startDate = currentDate.minusMonths(3).toLocalDate().atStartOfDay();

        List<SchemePayoutReportModel> schemePayoutReports = fofoOrderRepository
                .selectSchemePayoutReport(fofoDetails.getFofoId(), startDate, currentDate);
        LOGGER.info("schemePayoutReports {}", schemePayoutReports);

        model.addAttribute("startDate", currentDate.minusMonths(3).toLocalDate());
        model.addAttribute("endDate", LocalDate.now());
        model.addAttribute("schemePayoutReports", schemePayoutReports);

        return "scheme-payout-report";
    }

    @RequestMapping(value = "/selectPartnerBillingSummaryReport", method = RequestMethod.GET)
    public String getselectPartnerBillingSummaryReport(HttpServletRequest request, Model model) throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(3).toLocalDate().atStartOfDay();

        List<PartnerBillingSummaryModel> partnerBillingSummaryReports = fofoOrderRepository
                .selectPartnerBillingSummaryReport(fofoDetails.getFofoId(), currentStartMonth, currentDate);

        model.addAttribute("startDate", currentDate.minusMonths(3).toLocalDate());
        model.addAttribute("endDate", LocalDate.now());
        model.addAttribute("partnerBillingSummaryReports", partnerBillingSummaryReports);

        return "partner-billing-summary-report";
    }

    @RequestMapping(value = "/priceDropReport", method = RequestMethod.GET)
    public String getSelectPriceDropReport(HttpServletRequest request, Model model) throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(3).toLocalDate().atStartOfDay();

        List<PriceDropReportModel> priceDropReports = orderRepository.selectPriceDropReport(fofoDetails.getFofoId(),
                currentStartMonth, currentDate);

        model.addAttribute("startDate", currentDate.minusMonths(3).toLocalDate());
        model.addAttribute("endDate", LocalDate.now());
        model.addAttribute("priceDropReports", priceDropReports);

        return "price-drop-report";
    }

    @RequestMapping(value = "/downloadPriceDropReport", method = RequestMethod.GET)
    public ResponseEntity<?> getSelectDownloadPriceDropReport(HttpServletRequest request,
                                                              @RequestParam(name = "startDate", required = true, defaultValue = "") LocalDate startDate,
                                                              @RequestParam(name = "endDate", required = true, defaultValue = "") LocalDate endDate, Model model)
            throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        List<List<?>> rows = new ArrayList<>();
        List<PriceDropReportModel> priceDropReports = orderRepository.selectPriceDropReport(fofoDetails.getFofoId(),
                startDate.atStartOfDay(), endDate.atTime(LocalTime.MAX));

        for (PriceDropReportModel pdr : priceDropReports) {

            rows.add(Arrays.asList(pdr.getCode(), pdr.getId(), pdr.getBrand(), pdr.getModelName(), pdr.getModelNumber(),
                    pdr.getAffectedOn(), pdr.getAmount(), pdr.getPartnerPayout(), pdr.getImei(), pdr.getStatus(),
                    pdr.getUpdateTimestamp(), pdr.getRejectionReason()));

        }
        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil
                .getCSVByteStream(Arrays.asList("code", "Price_Drop_Id", "brand", "model_name", "model_number",
                        "affected_on", "amount", "partner_payout", "Imei", "status", "processed_on", "Reason"), rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, "price drop report");

        return responseEntity;

    }

    @RequestMapping(value = "/downloadPartnerBillingSummaryReport", method = RequestMethod.GET)
    public ResponseEntity<?> getdownloadPartnerBillingSummaryReport(HttpServletRequest request,
                                                                    @RequestParam(name = "startDate", required = true, defaultValue = "") LocalDate startDate,
                                                                    @RequestParam(name = "endDate", required = true, defaultValue = "") LocalDate endDate, Model model)
            throws Exception {

        List<List<?>> rows = new ArrayList<>();
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(3).toLocalDate().atStartOfDay();

        List<PartnerBillingSummaryModel> partnerBillingSummaryReports = fofoOrderRepository
                .selectPartnerBillingSummaryReport(fofoDetails.getFofoId(), startDate.atStartOfDay(),
                        endDate.atTime(LocalTime.MAX));

        for (PartnerBillingSummaryModel pbsr : partnerBillingSummaryReports) {

            rows.add(Arrays.asList(pbsr.getId(),
                    FormattingUtils.format(pbsr.getCreateTimestamp()),
                    FormattingUtils.format(pbsr.getBillingTimestamp()),
                    FormattingUtils.format(pbsr.getDeliveryTimestamp()),
                    FormattingUtils.format(pbsr.getPartnerGrnTimestamp()),
                    pbsr.getTransactionId(),
                    pbsr.getLogisticsTransactionId(), pbsr.getAirwayBillNumber(), pbsr.getStatusSubGroup(),
                    pbsr.getStatusName(), pbsr.getRetailerId(), pbsr.getRetailerName(), pbsr.getItemId(),
                    pbsr.getBrand(), pbsr.getModelName(), pbsr.getModelNumber(), pbsr.getColor(), pbsr.getUnitPrice(),
                    pbsr.getQuantity(), pbsr.getTotalPrice(), pbsr.getInvoiceNumber(), pbsr.getIgstRate(),
                    pbsr.getCgstRate(), pbsr.getSgstRate()));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(Arrays.asList("OrderId",
                "Created On", "Billed On", "Delivered On", "Grned On", "Transaction_id", "master_order_id",
                "airwaybill_no", "statusSubGroupp", "statusName", "customer_id", "customer_name", "Item_Id", "brand",
                "model_name", "model_number", "color", "selling_price", "Quantity", "total_price", "invoice_number",
                "igstrate", "cgstrate", "sgstrate"), rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, "Billing Statement Report");

        return responseEntity;

    }

    @RequestMapping(value = "/invoiceSchemeOutSummaryReport", method = RequestMethod.GET)
    public String getInvoiceSchemeOutSummaryReport(HttpServletRequest request, Model model) throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(3).toLocalDate().atStartOfDay();

        List<FocoSchemeOutReportModel> focoSchemeOutReports = fofoOrderRepository
                .selectInvoiceSchemeOutSummaryReport(fofoDetails.getFofoId(), currentStartMonth, currentDate);
        LOGGER.info("focoSchemeOutReportModel {}", focoSchemeOutReports);

        model.addAttribute("startDate", currentDate.minusMonths(3).toLocalDate());
        model.addAttribute("endDate", LocalDate.now());
        model.addAttribute("focoSchemeOutReports", focoSchemeOutReports);

        return "invoicewise-scheme-out-report";
    }

    @RequestMapping(value = "/downloadInvoiceSchemeOutSummaryReport", method = RequestMethod.GET)
    public ResponseEntity<?> getDownloadInvoiceSchemeOutSummaryReport(HttpServletRequest request, Model model)
            throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        List<List<?>> rows = new ArrayList<>();
        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(3).toLocalDate().atStartOfDay();

        List<FocoSchemeOutReportModel> focoSchemeOutReports = fofoOrderRepository
                .selectInvoiceSchemeOutSummaryReport(fofoDetails.getFofoId(), currentStartMonth, currentDate);
        LOGGER.info("focoSchemeOutReportModel {}", focoSchemeOutReports);

        for (FocoSchemeOutReportModel fsor : focoSchemeOutReports) {
            rows.add(Arrays.asList(fsor.getInvoiceNumber(), fsor.getQuantity(), fsor.getBrand(), fsor.getModelName(),
                    fsor.getModelNumber(), fsor.getColor(), fsor.getAmount()));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
                Arrays.asList("InvoiceNumber", "Quantity", "Brand", "Model Name", "Model Number", "Color", "Amount"),
                rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows,
                "invoice wise scheme out Summary Report");

        return responseEntity;
    }

    @RequestMapping(value = "/schemePayoutReportDownload", method = RequestMethod.GET)
    public ResponseEntity<?> getSchemePayoutReportDownload(HttpServletRequest request,
                                                           @RequestParam(name = "startDate", required = true, defaultValue = "") LocalDate startDate,
                                                           @RequestParam(name = "endDate", required = true, defaultValue = "") LocalDate endDate, Model model)
            throws Exception {
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        List<List<?>> rows = new ArrayList<>();
        LocalDateTime currentDate = LocalDate.now().atStartOfDay();
        LocalDateTime currentStartMonth = currentDate.minusMonths(3).toLocalDate().atStartOfDay();

        List<SchemePayoutReportModel> schemePayoutReports = fofoOrderRepository
                .selectSchemePayoutReport(fofoDetails.getFofoId(), currentStartMonth, currentDate);
        LOGGER.info("schemePayoutReports {}", schemePayoutReports);

        for (SchemePayoutReportModel spr : schemePayoutReports) {

            rows.add(Arrays.asList(spr.getId(), spr.getSerialNumber(), spr.getBrand(), spr.getModelName(),
                    spr.getModelNumber(), spr.getColor(), spr.getSchemeInDp(), spr.getSchemeOutDp(), spr.getSchemeId(),
                    spr.getName(), spr.getType(), spr.getAmountType(), spr.getPurchaseReference(),
                    spr.getInvoiceNumber(), spr.getSioAmount(), spr.getStatus(), spr.getStatusDescription(),
                    spr.getCreateTimestamp(), spr.getRolledBackTimestamp()));

        }
        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(Arrays.asList("Item_Id",
                "serial_number", "Brand", "Model Name", "Model Number", "Color", "Scheme_IN_DP", "Scheme_out_dp",
                "Scheme_Id", "Name", "Type", "amount", "Purchase_Invoice", "SALE_INOVOICE", "Amount", "status",
                "description", "create_timestamp", "rolled_back_timestamp"), rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, "Scheme Payout Summary Report");

        return responseEntity;
    }

    @GetMapping("/getAllOnlineOrder")
    public String getAllOrders(HttpServletRequest request, @RequestParam(required = false) LocalDate date, Model model)
            throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
        if (date == null) {
            date = LocalDate.now().minusDays(3);
        }

        LOGGER.info("date" + date);
        List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
                .collect(Collectors.toList());

        Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

        Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
                .filter(x -> x != null).collect(Collectors.toList()).stream()
                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

        model.addAttribute("customRetailersMap", customRetailersMap);

        List<PendingOrderItem> pendingOrderItem = null;

        pendingOrderItem = pendingOrderItemRepository.selectAll(date.atStartOfDay(), LocalDateTime.now());

        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, 0);

        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
        model.addAttribute("partnerInventoryMap", map.get("partnerInventoryMap"));
        model.addAttribute("date", date);
        model.addAttribute("isAdmin", isAdmin);
        return "online-all-order-item";
    }
}