Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
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.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

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.CartFofo;
import com.spice.profitmandi.common.model.CreateOrderRequest;
import com.spice.profitmandi.common.model.CreditNotePdfModel;
import com.spice.profitmandi.common.model.CustomCustomer;
import com.spice.profitmandi.common.model.CustomRetailer;
import com.spice.profitmandi.common.model.FofoItemIdAmountModel;
import com.spice.profitmandi.common.model.FoiBadReturnRequest;
import com.spice.profitmandi.common.model.PartnerOptionsAndItemAmountModel;
import com.spice.profitmandi.common.model.PaymentOptionTransactionModel;
import com.spice.profitmandi.common.model.PdfModel;
import com.spice.profitmandi.common.model.PriceModel;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
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.CurrentInventorySnapshot;
import com.spice.profitmandi.dao.entity.fofo.Customer;
import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
import com.spice.profitmandi.dao.entity.fofo.CustomerCreditNote;
import com.spice.profitmandi.dao.entity.fofo.CustomerReturnItem;
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
import com.spice.profitmandi.dao.entity.fofo.PaymentOption;
import com.spice.profitmandi.dao.entity.fofo.PendingOrder;
import com.spice.profitmandi.dao.entity.fofo.PendingOrderItem;
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.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;
import com.spice.profitmandi.dao.repository.dtr.PaymentOptionTransactionRepository;
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
import com.spice.profitmandi.dao.repository.fofo.CustomerReturnItemRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoPartnerPaymentOptionRepository;
import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;
import com.spice.profitmandi.dao.repository.fofo.PendingOrderItemRepository;
import com.spice.profitmandi.dao.repository.fofo.PendingOrderRepository;
import com.spice.profitmandi.dao.repository.inventory.StateRepository;
import com.spice.profitmandi.dao.repository.user.AddressRepository;
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.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import com.spice.profitmandi.web.util.MVCResponseSender;

@Controller
@Transactional(rollbackFor = Throwable.class)
public class OrderController {

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

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

        @Autowired
        private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

        @Autowired
        private ResponseSender<?> responseSender;

        @Autowired
        private PendingOrderRepository pendingOrderRepository;

        @Autowired
        private PendingOrderItemRepository pendingOrderItemRepository;

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        @Autowired
        private RetailerService retailerService;

        @Autowired
        private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

        @Autowired
        private TagListingRepository tagListingRepository;

        @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<>();
                for (CartFofo cartFofo : cartItems) {
                        itemIds.add(cartFofo.getItemId());
                }
                Map<Integer, PriceModel> mopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIds,
                                loginDetails.getFofoId());
                List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository
                                .selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());
                List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new HashSet<>(paymentOptionIds));
                LOGGER.info("mopPriceMap {}", mopPriceMap);
                model.addAttribute("stateNames",
                                stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));
                model.addAttribute("retailerStateName", address.getState());
                model.addAttribute("cartItems", cartItems);
                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("response", response);
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        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 = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
                Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
                customerAddress.setPhoneNumber(customer.getMobileNumber());
                List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
                                .selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
                Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
                                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);
                List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
                                .selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
                this.addInsuranceProvider(insurancePolicies);

                model.addAttribute("fofoOrder", fofoOrder);
                model.addAttribute("fofoLineItems", fofoLineItems);
                model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));
                model.addAttribute("customerBillingAddressObj", customerAddress);
                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 = fofoOrderPaymentOptionRepository
                                .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);
                        fofoOrderPaymentOptionRepository.persist(pot);
                        paymentOptionTransactions.add(pot);
                        LOGGER.info("Added to get invoice");
                }
                Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
                                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);
                List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
                                .selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), 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("fofoOrderItems", fofoOrderItems);
                model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));
                model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));
                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;
                }
                LocalDateTime buyDate = fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS);
                LocalDateTime curDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);
                if (buyDate.isAfter(curDate.minusDays(45))) {
                        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());
                List<Integer> fofoPartnerPaymentOptions = fofoPartnerPaymentOptionRepository
                                .selectPaymentOptionIdsByFofoId(fofoOrder.getFofoId());
                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 = fofoOrderPaymentOptionRepository
                                .selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
                LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);
                Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
                                .paymentOptionIdPaymentOptionMapUsingPaymentOptions(fofoPartnerPaymentOptions);
                Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this
                                .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);
                LOGGER.info("paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
                List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
                                .selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), 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...");
                return "redirect:/get-order/?orderId=" + fofoOrderId;
        }

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

        @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);
                PdfModel 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.set("Content-disposition", "inline; filename=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>(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<PdfModel> 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<PdfModel> 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());
                        Item item = itemRepository.selectById(fim.getItemId());
                        TagListing tagListing = tagListingRepository.selectByItemId(item.getId());
                        FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(fim.getFofoItemId());

                        if (item.getCategoryId() == 10006) {
                                if (fofoOrderItem.getMop() >= fim.getAmount()) {

                                        if (tagListing.getMrp() <= fim.getAmount() || tagListing.getMrp() == 0) {
                                                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 {
                                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.getTotalAmount() + "amount" + amount); if (amount ==
                 * fofoOrder.getTotalAmount()) {
                 */
                if (paymentOptionTransactionModels.size() > 0) {
                        List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
                                        .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) {
                                                fofoOrderPaymentOptionRepository.delete(paymentOptionTransaction);
                                                LOGGER.info("deleted successfully");
                                        } else {

                                                paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());
                                                fofoOrderPaymentOptionRepository.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());
                                                fofoOrderPaymentOptionRepository.persist(paymentOptionTransaction);
                                                LOGGER.info("inserted successfully");
                                        }
                                }

                        }

                        model.addAttribute("response", 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) {
                        e.printStackTrace();
                        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("/pendingOrders")
        public String getPendingOrders(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());

                if (isAdmin) {
                        Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
                        model.addAttribute("customRetailersMap", customRetailersMap);
                }
                List<PendingOrder> pendingOrders = null;
                if (isAdmin) {
                        pendingOrders = pendingOrderRepository.selectAllByStatus(OrderStatus.PENDING);
                } else {
                        pendingOrders = pendingOrderRepository.selectByFofoId(loginDetails.getFofoId(), OrderStatus.PENDING);
                }

                if (!pendingOrders.isEmpty()) {
                        List<Integer> customerIds = pendingOrders.stream().map(x -> x.getCustomerId()).collect(Collectors.toList());

                        Map<Integer, Customer> customersMap = customerRepository.selectAllByIds(customerIds).stream()
                                        .collect(Collectors.toMap(x -> x.getId(), x -> x));
                        pendingOrders.stream().forEach(x -> {
                                x.setCustomer(customersMap.get(x.getCustomerId()));
                        });

                }

                model.addAttribute("pendingOrder", pendingOrders);
                model.addAttribute("isAdmin", isAdmin);
                return "pending_fofo_order";
        }

        @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(), loginDetails.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 = "/cancelPendingOrder", method = RequestMethod.POST)
        public String cancelPendingOrder(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                PendingOrder pendingOrder = pendingOrderRepository.selectById(id);

                List<PendingOrderItem> pendingOrderItem = pendingOrderItemRepository.selectByOrderId(id);
                for (PendingOrderItem poi : pendingOrderItem) {
                        poi.setStatus(OrderStatus.CANCELLED);
                        poi.setStatusDescription(loginDetails.getEmailId());
                }
                pendingOrder.setStatus(OrderStatus.CLOSED);

                pendingOrderRepository.persist(pendingOrder);
                model.addAttribute("response", mvcResponseSender.createResponseString(true));

                return "response";
        }

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

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

                pendingOrderItem.setStatus(OrderStatus.CANCELLED);
                pendingOrderItem.setStatusDescription(loginDetails.getEmailId());
                PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());

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

                if (!status.contains(OrderStatus.PENDING)) {
                        pendingOrder.setStatus(OrderStatus.CLOSED);
                }
                pendingOrderItemRepository.persist(pendingOrderItem);
                model.addAttribute("response", 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("response", mvcResponseSender.createResponseString(true));

                return "response";
        }

}