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.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.PathVariable;
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.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.FoiBadReturnRequest;
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.util.Utils;
import com.spice.profitmandi.common.web.util.ResponseSender;
import com.spice.profitmandi.dao.entity.catalog.Item;
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.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.PrebookingOrderItem;
import com.spice.profitmandi.dao.entity.user.Address;
import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
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.CustomerAddressRepository;
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
import com.spice.profitmandi.dao.repository.fofo.CustomerReturnItemRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
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.PrebookingOrderItemRepository;
import com.spice.profitmandi.dao.repository.user.AddressRepository;
import com.spice.profitmandi.service.authentication.RoleManager;
import com.spice.profitmandi.service.order.OrderService;
import com.spice.profitmandi.service.pricing.PricingService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;

@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 CustomerReturnItemRepository customerReturnItemRepository;
        
        @Autowired
        private FofoOrderItemRepository fofoOrderItemRepository;

        @Autowired
        private PaymentOptionRepository paymentOptionRepository;
        
        @Autowired
        private ItemRepository itemRepository;

        @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 PrebookingOrderItemRepository prebookingOrderItemRepository;
        
        @Autowired
        private ResponseSender<?> responseSender;
        
        @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", Utils.getAllStateNames());
                model.addAttribute("retailerStateName", address.getState());
                model.addAttribute("cartObj", cartItems);
                model.addAttribute("mopPriceMap", mopPriceMap);
                model.addAttribute("paymentOptions", paymentOptions);
                model.addAttribute("accessoriesDeals", accessoriesDeals);
                return "order-index";
        }
        
        
        @RequestMapping(value = "/insurancePrices", method = RequestMethod.GET)
        public ResponseEntity<?> getInsurancePrices(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.PRICE) float price) throws ProfitMandiBusinessException{
                LOGGER.info("Request received at url : {}", request.getRequestURI());
                Set<Float> prices = new HashSet<>();
                prices.add(price);
                return responseSender.ok(pricingService.getInsurancePrices(prices, ProfitMandiConstants.GADGET_COPS));
        }
        
        
        @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);
                List<PrebookingOrderItem> prebookingOrderItems = prebookingOrderItemRepository.selectByOrderId(orderId);
                Map<Integer, PrebookingOrderItem> itemIdPrebookingOrderItemMap = this.prebookingOrderItemToItemIdPrebookingOrderItem(prebookingOrderItems);
                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);
                model.addAttribute("itemIdPrebookingOrderItemMap", itemIdPrebookingOrderItemMap);
                return "order-details";
        }
        
        @RequestMapping(value = "/generateOtp", method = RequestMethod.POST)
        public ResponseEntity<?> generateOtp(@RequestBody Map<Integer, Float> itemIdAdvanceAmount, @RequestParam(name = ProfitMandiConstants.CUSTOMER_EMAIL_ID) String customerEmailId, @RequestParam(name = ProfitMandiConstants.CUSTOMER_MOBILE_NUMBER) String customerMobileNumber)
                        throws ProfitMandiBusinessException{
                        
                int response = orderService.generatePrebookingOrdersOtp(customerEmailId, customerMobileNumber, itemIdAdvanceAmount);
                
                return responseSender.ok(response);
        }
        
        @RequestMapping(value = "/validateOtp", method = RequestMethod.GET)
        public ResponseEntity<?> validateOtp(@RequestParam(name = ProfitMandiConstants.CUSTOMER_EMAIL_ID) String customerEmailId,
                        @RequestParam(name = ProfitMandiConstants.CUSTOMER_MOBILE_NUMBER) String customerMobileNumber,
                        @RequestParam("otpId") int otpId, @RequestParam("otpValue") String otpValue)
                        throws ProfitMandiBusinessException{
                        
                String responseString = orderService.validateOtp(customerEmailId, customerMobileNumber, otpId, otpValue);
                
                return responseSender.ok(responseString);
        }
        
        
        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);
                
                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);
                Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);
                List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
                this.addInsuranceProvider(insurancePolicies);
                List<PrebookingOrderItem> prebookingOrderItems = prebookingOrderItemRepository.selectByOrderId(orderId);
                Map<Integer, PrebookingOrderItem> itemIdPrebookingOrderItemMap = this.prebookingOrderItemToItemIdPrebookingOrderItem(prebookingOrderItems);
                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());
                        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("itemIdPrebookingOrderItemMap", itemIdPrebookingOrderItemMap);
                model.addAttribute("markDoa", this.markDoa(fofoOrder));
                model.addAttribute("markDefective", this.markDefective(fofoOrder));
                return "sale-details";
        }
        
        private boolean markDoa(FofoOrder fofoOrder) {
                return fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS).plusDays(90).
                isAfter(LocalDateTime.now().truncatedTo(ChronoUnit.DAYS));
        }
        
        private boolean markDefective(FofoOrder fofoOrder) {
                return fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS).plusDays(90).
                isAfter(LocalDateTime.now().truncatedTo(ChronoUnit.DAYS));
                
        }
        
        @RequestMapping(value = "/getSearchOrder")
        public String getSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException{
                return "search-order";
        }
        
        
        @RequestMapping(value = "/customerDetails", method = RequestMethod.PUT)
        public String updateCustomerDetails(HttpServletRequest request, @RequestBody CustomCustomer customCustomer, @RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)
                        throws ProfitMandiBusinessException{
                        
                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 ProfitMandiBusinessException{
                
                FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
                List<FofoOrderItem> fofoLineItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
                Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
                CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
                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);
                List<PrebookingOrderItem> prebookingOrderItems = prebookingOrderItemRepository.selectByOrderId(fofoOrder.getId());
                Map<Integer, PrebookingOrderItem> itemIdPrebookingOrderItemMap = this.prebookingOrderItemToItemIdPrebookingOrderItem(prebookingOrderItems);
                model.addAttribute("fofoOrder", fofoOrder);
                model.addAttribute("fofoLineItems", fofoLineItems);
                model.addAttribute("customer", customer);
                model.addAttribute("customerAddress", customerAddress);
                model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);
                model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);
                model.addAttribute("insurancePolicies", insurancePolicies);
                model.addAttribute("itemIdPrebookingOrderItemMap", itemIdPrebookingOrderItemMap);
                model.addAttribute("stateNames", Utils.getAllStateNames());
                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, PrebookingOrderItem> prebookingOrderItemToItemIdPrebookingOrderItem(List<PrebookingOrderItem> prebookingOrderItems){
                Map<Integer, PrebookingOrderItem> itemIdPrebookingOrderItem = new HashMap<>();
                for(PrebookingOrderItem prebookingOrderItem : prebookingOrderItems) {
                        itemIdPrebookingOrderItem.put(prebookingOrderItem.getItemId(), prebookingOrderItem);
                }
                return itemIdPrebookingOrderItem;
        }
        

        @RequestMapping(value = "/create-order", method = RequestMethod.POST)
        public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest, Model model)  throws ProfitMandiBusinessException{
                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 = 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(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 = "/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="/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";
        }

}