Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.time.LocalDateTime;

import java.time.temporal.ChronoUnit;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.PutMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import com.google.gson.Gson;

import com.spice.profitmandi.common.enumuration.SearchType;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.CartFofo;

import com.spice.profitmandi.common.model.CreateOrderRequest;

import com.spice.profitmandi.common.model.CreditNotePdfModel;

import com.spice.profitmandi.common.model.CustomCustomer;

import com.spice.profitmandi.common.model.CustomRetailer;

import com.spice.profitmandi.common.model.FofoItemIdAmountModel;

import com.spice.profitmandi.common.model.FoiBadReturnRequest;

import com.spice.profitmandi.common.model.PartnerOptionsAndItemAmountModel;

import com.spice.profitmandi.common.model.PaymentOptionTransactionModel;

import com.spice.profitmandi.common.model.PdfModel;

import com.spice.profitmandi.common.model.PriceModel;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.common.util.PdfUtils;

import com.spice.profitmandi.common.util.StringUtils;

import com.spice.profitmandi.common.web.util.ResponseSender;

import com.spice.profitmandi.dao.entity.catalog.Item;

import com.spice.profitmandi.dao.entity.catalog.TagListing;

import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;

import com.spice.profitmandi.dao.entity.dtr.InsuranceProvider;

import com.spice.profitmandi.dao.entity.dtr.PaymentOptionTransaction;

import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;

import com.spice.profitmandi.dao.entity.fofo.Customer;

import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;

import com.spice.profitmandi.dao.entity.fofo.CustomerCreditNote;

import com.spice.profitmandi.dao.entity.fofo.CustomerReturnItem;

import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;

import com.spice.profitmandi.dao.entity.fofo.FofoOrder;

import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;

import com.spice.profitmandi.dao.entity.fofo.PaymentOption;

import com.spice.profitmandi.dao.entity.fofo.PendingOrder;

import com.spice.profitmandi.dao.entity.fofo.PendingOrderItem;

import com.spice.profitmandi.dao.entity.user.Address;

import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;

import com.spice.profitmandi.dao.enumuration.transaction.OrderStatus;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;

import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;

import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;

import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;

import com.spice.profitmandi.dao.repository.dtr.PaymentOptionTransactionRepository;

import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;

import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;

import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;

import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;

import com.spice.profitmandi.dao.repository.fofo.CustomerReturnItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoPartnerPaymentOptionRepository;

import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;

import com.spice.profitmandi.dao.repository.fofo.PendingOrderItemRepository;

import com.spice.profitmandi.dao.repository.fofo.PendingOrderRepository;

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.integrations.zest.InsuranceService;

import com.spice.profitmandi.service.integrations.zest.MobileInsurancePlan;

import com.spice.profitmandi.service.order.OrderService;

import com.spice.profitmandi.service.pricing.PricingService;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class OrderController {

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

	@Autowired

	private CustomerRepository customerRepository;

	private boolean accessoriesDeals = true;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private Gson gson;

	@Autowired

	private CustomerReturnItemRepository customerReturnItemRepository;

	@Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

	private PaymentOptionRepository paymentOptionRepository;

	@Autowired

	private StateRepository stateRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private InsuranceService insuranceService;

	@Autowired

	private FofoOrderRepository fofoOrderRepository;

	@Autowired

	private CustomerAddressRepository customerAddressRepository;

	@Autowired

	private InsurancePolicyRepository insurancePolicyRepository;

	@Autowired

	private InsuranceProviderRepository insuranceProviderRepository;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private PricingService pricingService;

	@Autowired

	private OrderService orderService;

	@Autowired

	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

	private AddressRepository addressRepository;

	@Autowired

	private PaymentOptionTransactionRepository fofoOrderPaymentOptionRepository;

	@Autowired

	private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	private PendingOrderRepository pendingOrderRepository;

	@Autowired

	private PendingOrderItemRepository pendingOrderItemRepository;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

	private TagListingRepository tagListingRepository;

	@RequestMapping(value = "/order")

	public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		;

		int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());

		Address address = addressRepository.selectById(addressId);

		List<CartFofo> cartItems = orderService.cartCheckout(cartData);

		Set<Integer> itemIds = new HashSet<>();

		for (CartFofo cartFofo : cartItems) {

			itemIds.add(cartFofo.getItemId());

		}

		Map<Integer, PriceModel> mopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIds,

				loginDetails.getFofoId());

		List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository

				.selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());

		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new HashSet<>(paymentOptionIds));

		LOGGER.info("mopPriceMap {}", mopPriceMap);

		model.addAttribute("stateNames",

				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));

		model.addAttribute("retailerStateName", address.getState());

		model.addAttribute("cartItems", cartItems);

		model.addAttribute("mopPriceMap", mopPriceMap);

		model.addAttribute("paymentOptions", paymentOptions);

		model.addAttribute("accessoriesDeals", accessoriesDeals);

		return "order-index";

	}

	@RequestMapping(value = "/checkplans", method = RequestMethod.GET)

	public String getInsurancePrices(HttpServletRequest request, @RequestParam float price, Model model,

			@RequestParam int itemId) throws ProfitMandiBusinessException {

		LOGGER.info("Request received at url : {}", request.getRequestURI());

		try {

			String response = mvcResponseSender.createResponseString(this.getPlans(price, itemId));

			model.addAttribute("response", response);

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			throw new ProfitMandiBusinessException("Plans", "Plans API", "Error formatting insurance plans");

		}

		return "response";

	}

	@RequestMapping(value = "/get-order", method = RequestMethod.GET)

	public String getOrder(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId,

			Model model) throws ProfitMandiBusinessException {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);

		List<FofoOrderItem> fofoLineItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

		customerAddress.setPhoneNumber(customer.getMobileNumber());

		List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository

				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());

		this.addInsuranceProvider(insurancePolicies);

		model.addAttribute("fofoOrder", fofoOrder);

		model.addAttribute("fofoLineItems", fofoLineItems);

		model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));

		model.addAttribute("customerBillingAddressObj", customerAddress);

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

		model.addAttribute("insurancePolicies", insurancePolicies);

		return "order-details";

	}

	private Map<Integer, InsuranceProvider> toInsuranceProviderIdInsuranceProvider(

			List<InsuranceProvider> insuranceProviders) {

		Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = new HashMap<>();

		for (InsuranceProvider insuranceProvider : insuranceProviders) {

			insuranceProviderIdInsuranceProviderMap.put(insuranceProvider.getId(), insuranceProvider);

		}

		return insuranceProviderIdInsuranceProviderMap;

	}

	private void addInsuranceProvider(List<InsurancePolicy> insurancePolicies) {

		if (insurancePolicies.isEmpty()) {

			return;

		}

		Set<Integer> insuranceProviderIds = new HashSet<>();

		for (InsurancePolicy insurancePolicy : insurancePolicies) {

			insuranceProviderIds.add(insurancePolicy.getProviderId());

		}

		LOGGER.info("insuranceProviderIds {}", insuranceProviderIds);

		List<InsuranceProvider> insuranceProviders = insuranceProviderRepository.selectByIds(insuranceProviderIds);

		Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = this

				.toInsuranceProviderIdInsuranceProvider(insuranceProviders);

		for (InsurancePolicy insurancePolicy : insurancePolicies) {

			insurancePolicy

					.setInsuranceProvider(insuranceProviderIdInsuranceProviderMap.get(insurancePolicy.getProviderId()));

		}

	}

	@RequestMapping(value = "/saleDetails", method = RequestMethod.GET)

	public String getSaleDetails(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) throws Exception {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		boolean isAdmin = roleManager.isAdmin(fofoDetails.getRoleIds());

		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);

		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

		List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository

				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);

		// Added Migration info as we lost it.

		if (paymentOptionTransactions == null || paymentOptionTransactions.size() == 0) {

			PaymentOptionTransaction pot = new PaymentOptionTransaction();

			pot.setAmount(fofoOrder.getTotalAmount());

			pot.setCreateTimestamp(fofoOrder.getCreateTimestamp());

			// Mark it paid through cash

			pot.setPaymentOptionId(1);

			pot.setReferenceType(PaymentOptionReferenceType.ORDER);

			fofoOrderPaymentOptionRepository.persist(pot);

			paymentOptionTransactions.add(pot);

			LOGGER.info("Added to get invoice");

		}

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());

		this.addInsuranceProvider(insurancePolicies);

		Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {

			try {

				return itemRepository.selectById(x.getItemId());

			} catch (ProfitMandiBusinessException e) {

				// TODO Auto-generated catch block

				return null;

			}

		}));

		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()

				.collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));

		Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()

				.collect(Collectors.toMap(foi -> foi.getId(),

						foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));

		Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();

		for (FofoOrderItem foi : fofoOrderItems) {

			for (FofoLineItem fli : foi.getFofoLineItems()) {

				inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());

			}

			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

					.selectAllByOrderItemId(foi.getId());

			this.markDoa(fofoOrder, foi, isAdmin);

			for (CustomerReturnItem customerReturnItem : customerReturnItems) {

				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

						inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);

			}

		}

		LOGGER.info("fofoOrderItemIdLineItemMap {}", fofoOrderItemIdLineItemMap);

		model.addAttribute("fofoOrder", fofoOrder);

		model.addAttribute("itemsMap", itemsMap);

		model.addAttribute("fofoOrderItemIdLineItemsMap", StringUtils.toString(fofoOrderItemIdLineItemMap));

		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

		model.addAttribute("fofoOrderItems", fofoOrderItems);

		model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));

		model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));

		model.addAttribute("customerBillingAddressObj", customerAddress);

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

		model.addAttribute("insurancePolicies", insurancePolicies);

		model.addAttribute("markDefective", this.markDefective(fofoOrder));

		return "sale-details";

	}

	private void markDoa(FofoOrder fofoOrder, FofoOrderItem foi, boolean isAdmin) {

		if (isAdmin) {

			foi.setDoa(true);

			return;

		}

		LocalDateTime buyDate = fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS);

		LocalDateTime curDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);

		if (buyDate.isAfter(curDate.minusDays(45))) {

			foi.setDoa(true);

		} else

			foi.setDoa(

					foi.getBrand().equals("Nokia") && foi.getCost() < 4990 && buyDate.isAfter(curDate.minusYears(1)));

	}

	private boolean markDefective(FofoOrder fofoOrder) {

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

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

	}

	@RequestMapping(value = "/getSearchOrder")

	public String getSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		return "search-order";

	}

	@RequestMapping(value = "/getInvoiceSearchOrder")

	public String getInvoiceSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		return "invoices-cancel";

	}

	@RequestMapping(value = "/customerDetails", method = RequestMethod.PUT)

	public String updateCustomerDetails(HttpServletRequest request, @RequestBody CustomCustomer customCustomer,

			@RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)

			throws Exception {

		orderService.updateCustomerDetails(customCustomer, invoiceNumber);

		return this.getSearchOrderDetails(request, invoiceNumber, model);

	}

	@RequestMapping(value = "/searchOrderDetails", method = RequestMethod.GET)

	public String getSearchOrderDetails(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)

			throws Exception {

		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

		List<Integer> fofoPartnerPaymentOptions = fofoPartnerPaymentOptionRepository

				.selectPaymentOptionIdsByFofoId(fofoOrder.getFofoId());

		Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {

			try {

				return itemRepository.selectById(x.getItemId());

			} catch (ProfitMandiBusinessException e) {

				// TODO Auto-generated catch block

				return null;

			}

		}));

		LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);

		List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository

				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);

		LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

				.paymentOptionIdPaymentOptionMapUsingPaymentOptions(fofoPartnerPaymentOptions);

		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

				.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

		LOGGER.info("paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());

		this.addInsuranceProvider(insurancePolicies);

		model.addAttribute("fofoOrder", fofoOrder);

		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

			fofoOrderItem.setDoa(true);

		}

		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()

				.collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));

		Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()

				.collect(Collectors.toMap(foi -> foi.getId(),

						foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));

		Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();

		for (FofoOrderItem foi : fofoOrderItems) {

			for (FofoLineItem fli : foi.getFofoLineItems()) {

				inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());

			}

			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

					.selectAllByOrderItemId(foi.getId());

			for (CustomerReturnItem customerReturnItem : customerReturnItems) {

				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

						inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);

			}

		}

		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

		model.addAttribute("fofoOrderItems", fofoOrderItems);

		model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));

		model.addAttribute("fofoOrderItemIdLineItemsMap", StringUtils.toString(fofoOrderItemIdLineItemMap));

		model.addAttribute("itemsMap", itemsMap);

		model.addAttribute("markDefective", true);

		model.addAttribute("customer", customer);

		model.addAttribute("customerAddress", customerAddress);

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

		model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);

		model.addAttribute("insurancePolicies", insurancePolicies);

		model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);

		model.addAttribute("totalNumberOfPaymentOptionId", fofoPartnerPaymentOptions.size());

		model.addAttribute("stateNames",

				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));

		return "search-order-details";

	}

	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(

			List<PaymentOptionTransaction> paymentOptionTransactions) {

		Set<Integer> paymentOptionIds = new HashSet<>();

		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

			paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());

		}

		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(paymentOptionIds);

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();

		for (PaymentOption paymentOption : paymentOptions) {

			paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);

		}

		return paymentOptionIdPaymentOptionMap;

	}

	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(

			List<Integer> fofoPartnerPaymentOptions) {

		List<PaymentOption> paymentOptions = paymentOptionRepository

				.selectByIds(new HashSet<>(fofoPartnerPaymentOptions));

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();

		for (PaymentOption paymentOption : paymentOptions) {

			paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);

		}

		return paymentOptionIdPaymentOptionMap;

	}

	private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(

			List<PaymentOptionTransaction> paymentOptionTransactions) {

		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = new HashMap<>();

		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

			paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),

					paymentOptionTransaction);

		}

		return paymentOptionIdPaymentOptionTransactionMap;

	}

	@RequestMapping(value = "/create-order", method = RequestMethod.POST)

	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest,

			Model model) throws ProfitMandiBusinessException {

		// throw new ProfitMandiBusinessException("Billing is on hold temporarily",

		// "Billing is on hold temporarily", "Billing is on hold temporarily");

		LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		int fofoOrderId = orderService.createOrder(createOrderRequest, fofoDetails.getFofoId(), accessoriesDeals);

		LOGGER.info("Order has been created successfully...");

		return "redirect:/get-order/?orderId=" + fofoOrderId;

	}

	@RequestMapping(value = "/order/bad_return", method = RequestMethod.POST)

	public ResponseEntity<?> badReturn(HttpServletRequest request, @RequestBody FoiBadReturnRequest foiBadReturnRequest,

			Model model) throws ProfitMandiBusinessException {

		LOGGER.info("request at uri {} body {}", request.getRequestURI(), foiBadReturnRequest);

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		CustomerCreditNote custmoerCreditNote;

		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

			FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());

			FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());

			custmoerCreditNote = orderService.badReturn(fo.getFofoId(), foiBadReturnRequest);

		} else {

			custmoerCreditNote = orderService.badReturn(fofoDetails.getFofoId(), foiBadReturnRequest);

		}

		return responseSender.ok(custmoerCreditNote.getId());

	}

	@RequestMapping(value = "/generateInvoice")

	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,

			@RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId) throws ProfitMandiBusinessException {

		LOGGER.info("Request received at url {} with params [{}={}] ", request.getRequestURI(),

				ProfitMandiConstants.ORDER_ID, orderId);

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		PdfModel pdfModel = null;

		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

			pdfModel = orderService.getInvoicePdfModel(orderId);

		} else {

			pdfModel = orderService.getInvoicePdfModel(fofoDetails.getFofoId(), orderId);

		}

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);

		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);

		final HttpHeaders headers = new HttpHeaders();

		headers.setContentType(MediaType.APPLICATION_PDF);

		headers.set("Content-disposition", "inline; filename=invoice-" + pdfModel.getInvoiceNumber() + ".pdf");

		headers.setContentLength(byteArrayOutputStream.toByteArray().length);

		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

	}

	@RequestMapping(value = "/generateInvoices")

	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,

			@RequestParam LocalDateTime startDate, @RequestParam LocalDateTime endDate, @RequestParam int partnerId)

			throws ProfitMandiBusinessException {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		List<PdfModel> pdfModels = new ArrayList<>();

		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

			List<Integer> orderIds = fofoOrderRepository.selectByFofoId(partnerId, startDate, endDate, 0, 0).stream()

					.map(x -> x.getId()).collect(Collectors.toList());

			for (int orderId : orderIds) {

				pdfModels.add(orderService.getInvoicePdfModel(orderId));

			}

			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

			PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

			LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);

			final HttpHeaders headers = new HttpHeaders();

			headers.setContentType(MediaType.APPLICATION_PDF);

			headers.set("Content-disposition", "inline; filename=invoice-" + partnerId + ".pdf");

			headers.setContentLength(byteArrayOutputStream.toByteArray().length);

			final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

			final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

			return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

		} else {

			throw new ProfitMandiBusinessException("Auth", fofoDetails.getEmailId(), "Unauthorised access");

		}

	}

	@RequestMapping(value = "/saleHistory")

	public String saleHistory(HttpServletRequest request,

			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,

			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,

			@RequestParam(required = false) LocalDateTime startTime,

			@RequestParam(required = false) LocalDateTime endTime,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,

				startTime, endTime, offset, limit);

		model.addAllAttributes(map);

		return "sale-history";

	}

	@RequestMapping(value = "/downloadInvoices")

	public ResponseEntity<?> downloadInvoices(HttpServletRequest request,

			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,

			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,

			@RequestParam(required = false) LocalDateTime startTime,

			@RequestParam(required = false) LocalDateTime endTime,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,

				startTime, endTime, offset, 100);

		List<FofoOrder> fofoOrders = (List<FofoOrder>) map.get("saleHistories");

		if (fofoOrders.size() == 0) {

			throw new ProfitMandiBusinessException("Search criteria", "", "No orders found for criteria");

		}

		final HttpHeaders headers = new HttpHeaders();

		headers.setContentType(MediaType.APPLICATION_PDF);

		headers.set("Content-disposition", "inline; filename=invoices.pdf");

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		List<PdfModel> pdfModels = new ArrayList<>();

		for (FofoOrder fofoOrder : fofoOrders) {

			try {

				pdfModels.add(orderService.getInvoicePdfModel(fofoOrder.getId()));

			} catch (Exception e) {

				LOGGER.info("could not create invoice for {}, invoice number {}", fofoOrder.getId(),

						fofoOrder.getInvoiceNumber());

			}

		}

		PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

		headers.setContentLength(byteArrayOutputStream.toByteArray().length);

		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

	}

	@RequestMapping(value = "/credit-note/{creditNoteId}")

	public ResponseEntity<?> downloadCreditNote(HttpServletRequest request, @PathVariable int creditNoteId)

			throws ProfitMandiBusinessException {

		CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		PdfUtils.generateAndWriteCustomerCreditNotes(Arrays.asList(creditNotePdfModel), byteArrayOutputStream);

		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);

		final HttpHeaders headers = new HttpHeaders();

		headers.setContentType(MediaType.APPLICATION_PDF);

		headers.set("Content-disposition",

				"inline; filename=invoice-" + creditNotePdfModel.getCreditNoteNumber() + ".pdf");

		headers.setContentLength(byteArrayOutputStream.toByteArray().length);

		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

	}

	@RequestMapping(value = "/getPaginatedSaleHistory")

	public String getSaleHistoryPaginated(HttpServletRequest request,

			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,

			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,

			@RequestParam(required = false) LocalDateTime startTime,

			@RequestParam(required = false) LocalDateTime endTime,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = orderService.getSaleHistoryPaginated(loginDetails.getFofoId(), searchType,

				searchValue, startTime, endTime, offset, limit);

		model.addAllAttributes(map);

		return "sale-history-paginated";

	}

	@PutMapping(value = "/updatePaymentTransaction")

	public String updateTransactionDetails(HttpServletRequest request, @RequestParam String referenceType,

			@RequestParam int fofoId, @RequestParam int referenceId,

			@RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,

			@RequestParam float totalAmount, Model model) throws Exception {

		List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel

				.getPaymentOptionTransactionModel();

		LOGGER.info(paymentOptionTransactionModels);

		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, referenceId);

		LOGGER.info("sdssd" + fofoOrder);

		fofoOrder.setTotalAmount(totalAmount);

		List<FofoItemIdAmountModel> fofoItemIdAmountModel = partnerOptionsAndItemAmountModel.getItemAmountModel();

		for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {

			LOGGER.info("fim" + fim.getFofoItemId());

			Item item = itemRepository.selectById(fim.getItemId());

			TagListing tagListing = tagListingRepository.selectByItemId(item.getId());

			FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(fim.getFofoItemId());

			if (item.getCategoryId() == 10006) {

				if (fofoOrderItem.getMop() >= fim.getAmount()) {

					if (tagListing.getMrp() <= fim.getAmount() || tagListing.getMrp() == 0) {

						fofoOrderItem.setSellingPrice(fim.getAmount());

					} else {

						throw new ProfitMandiBusinessException("Amount", fim.getAmount(),

								"Sum of amount is not less than  to MRP");

					}

					LOGGER.info("fofoOrderItem2" + fofoOrderItem);

				}

			} else {

				fofoOrderItem.setSellingPrice(fim.getAmount());

				LOGGER.info("fofoOrderItem1" + fofoOrderItem);

			}

			LOGGER.info("fofoOrderItem" + fofoOrderItem);

		}

		/*

		 * for (PaymentOptionTransactionModel paymentOptionTransactionModel :

		 * paymentOptionTransactionModels) { amount = amount +

		 * paymentOptionTransactionModel.getAmount(); } LOGGER.info("FofoOrder amount" +

		 * fofoOrder.getTotalAmount() + "amount" + amount); if (amount ==

		 * fofoOrder.getTotalAmount()) {

		 */

		if (paymentOptionTransactionModels.size() > 0) {

			List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository

					.selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);

			Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

					.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

			LOGGER.info(

					"paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

			for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {

				if (paymentOptionIdPaymentOptionTransactionMap

						.containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {

					PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap

							.get(paymentOptionTransactionModel.getPaymentOptionId());

					if (paymentOptionTransactionModel.getAmount() == 0) {

						fofoOrderPaymentOptionRepository.delete(paymentOptionTransaction);

						LOGGER.info("deleted successfully");

					} else {

						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

						fofoOrderPaymentOptionRepository.persist(paymentOptionTransaction);

						LOGGER.info("updated successfully");

					}

				} else {

					if (paymentOptionTransactionModel.getAmount() > 0) {

						PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();

						paymentOptionTransaction.setReferenceId(referenceId);

						paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);

						paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());

						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

						paymentOptionTransaction.setFofoId(fofoId);

						paymentOptionTransaction.setCreateTimestamp(fofoOrder.getCreateTimestamp());

						fofoOrderPaymentOptionRepository.persist(paymentOptionTransaction);

						LOGGER.info("inserted successfully");

					}

				}

			}

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

		}

		/*

		 * else

		 * 

		 * { throw new ProfitMandiBusinessException("Amount", amount,

		 * "Sum of amount is not equal to total amount"); }

		 */

		return "response";

	}

	private Map<String, List<MobileInsurancePlan>> getPlans(float sellingPrice, int itemId)

			throws ProfitMandiBusinessException {

		try {

			Map<String, List<MobileInsurancePlan>> productDurationPlans = insuranceService.getAllPlans(itemId,

					sellingPrice);

			return productDurationPlans;

		} catch (Exception e) {

			e.printStackTrace();

			throw new ProfitMandiBusinessException("Fetch Insurance Plans", "Insurance",

					"Could not fetch insurance Plans");

		}

	}

	@GetMapping("/insuranceDetails")

	public String getInsuranceDetails(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		long size = 0;

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),

				offset, limit);

		size = insurancePolicyRepository.selectCountByRetailerId(loginDetails.getFofoId());

		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository

				.selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))

				.stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));

		if (size < limit) {

			model.addAttribute("end", offset + size);

		} else {

			model.addAttribute("end", offset + limit);

		}

		model.addAttribute("start", offset + 1);

		model.addAttribute("size", size);

		model.addAttribute("insurancePolicies", insurancePolicies);

		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);

		return "insurance-details";

	}

	@GetMapping("/insuranceDetailsPaginated")

	public String getInsuranceDetailsPaginated(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),

				offset, limit);

		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository

				.selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))

				.stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));

		model.addAttribute("insurancePolicies", insurancePolicies);

		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);

		return "insurance-details-paginated";

	}

	@GetMapping("/pendingOrders")

	public String getPendingOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())

				.collect(Collectors.toList());

		if (isAdmin) {

			Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);

			model.addAttribute("customRetailersMap", customRetailersMap);

		}

		List<PendingOrder> pendingOrders = null;

		if (isAdmin) {

			pendingOrders = pendingOrderRepository.selectAllByStatus(OrderStatus.PENDING);

		} else {

			pendingOrders = pendingOrderRepository.selectByFofoId(loginDetails.getFofoId(), OrderStatus.PENDING);

		}

		if (!pendingOrders.isEmpty()) {

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

			Map<Integer, Customer> customersMap = customerRepository.selectAllByIds(customerIds).stream()

					.collect(Collectors.toMap(x -> x.getId(), x -> x));

			pendingOrders.stream().forEach(x -> {

				x.setCustomer(customersMap.get(x.getCustomerId()));

			});

		}

		model.addAttribute("pendingOrder", pendingOrders);

		model.addAttribute("isAdmin", isAdmin);

		return "pending_fofo_order";

	}

	@GetMapping("/getPendingOrderItem")

	public String getPendingOrderItem(HttpServletRequest request, @RequestParam int orderId, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<Integer, Item> itemMap = new HashMap<>();

		Map<Integer, CurrentInventorySnapshot> inventoryMap = new HashMap<>();

		PendingOrder pendingPO = pendingOrderRepository.selectById(orderId);

		Customer customer = customerRepository.selectById(pendingPO.getCustomerId());

		List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(orderId);

		for (PendingOrderItem pendingOrderItem : pendingOrderItems) {

			Item item = itemRepository.selectById(pendingOrderItem.getItemId());

			CurrentInventorySnapshot cis = currentInventorySnapshotRepository

					.selectByItemAndFofoId(pendingOrderItem.getItemId(), loginDetails.getFofoId());

			itemMap.put(pendingOrderItem.getItemId(), item);

			LOGGER.info("cis" + cis);

			inventoryMap.put(pendingOrderItem.getItemId(), cis);

		}

		LOGGER.info("inventoryMap" + inventoryMap);

		model.addAttribute("pendingOrderItems", pendingOrderItems);

		model.addAttribute("itemMap", itemMap);

		model.addAttribute("inventoryMap", inventoryMap);

		model.addAttribute("pendingPO", gson.toJson(pendingPO));

		model.addAttribute("pendingPOCustomer", gson.toJson(customer));

		model.addAttribute("isAdmin", roleManager.isAdmin(loginDetails.getRoleIds()));

		return "pending-order-item";

	}

	@RequestMapping(value = "/cancelPendingOrder", method = RequestMethod.POST)

	public String cancelPendingOrder(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		PendingOrder pendingOrder = pendingOrderRepository.selectById(id);

		List<PendingOrderItem> pendingOrderItem = pendingOrderItemRepository.selectByOrderId(id);

		for (PendingOrderItem poi : pendingOrderItem) {

			poi.setStatus(OrderStatus.CANCELLED);

			poi.setStatusDescription(loginDetails.getEmailId());

		}

		pendingOrder.setStatus(OrderStatus.CLOSED);

		pendingOrderRepository.persist(pendingOrder);

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

		return "response";

	}

	@RequestMapping(value = "/cancelPendingOrderItem", method = RequestMethod.POST)

	public String cancelPendingOrderItem(HttpServletRequest request, @RequestParam int id, Model model)

			throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);

		pendingOrderItem.setStatus(OrderStatus.CANCELLED);

		pendingOrderItem.setStatusDescription(loginDetails.getEmailId());

		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());

		List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()

				.map(x -> x.getStatus()).collect(Collectors.toList());

		if (!status.contains(OrderStatus.PENDING)) {

			pendingOrder.setStatus(OrderStatus.CLOSED);

		}

		pendingOrderItemRepository.persist(pendingOrderItem);

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