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

                // 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);
                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(180)
                                .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";
        }

}