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

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

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

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

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

	}

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

	}

}