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(60).

		isAfter(LocalDateTime.now().truncatedTo(ChronoUnit.DAYS));

	}

	private boolean markDefective(FofoOrder fofoOrder) {

		return fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS).plusDays(30).

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

	}

}