Subversion Repositories SmartDukaan

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

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

	private static final List<String> offlineOrders = Arrays.asList("EMIOD", "POD");

    private static final List<String> offlineOrders = Arrays.asList("EMIOD", "POD");

	private static final List<String> allowedDoaImeis = Arrays.asList("863903054378477");

    private static final List<String> allowedDoaImeis = Arrays.asList("863903054378477");

	@Autowired

    @Autowired

	NotificationService notificationService;

    NotificationService notificationService;

	@Autowired

    @Autowired

	private CustomerRepository customerRepository;

    TransactionApprovalRepository transactionApprovalRepository;

	private boolean accessoriesDeals = true;

    @Autowired

	@Autowired

    LineItemRepository lineItemRepository;

	private RoleManager roleManager;

    @Autowired

	@Autowired

    AuthRepository authRepository;

	private Gson gson;

    @Autowired

	@Autowired

    TransactionService transactionService;

	private CustomerReturnItemRepository customerReturnItemRepository;

    @Autowired

	@Autowired

    BulkOrderService bulkOrderService;

	private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

	@Autowired

    private CustomerRepository customerRepository;

	private PaymentOptionRepository paymentOptionRepository;

    private boolean accessoriesDeals = true;

	@Autowired

    @Autowired

	private StateRepository stateRepository;

    private RoleManager roleManager;

	@Autowired

    @Autowired

	private ItemRepository itemRepository;

    private Gson gson;

	@Autowired

    @Autowired

	private MVCResponseSender mvcResponseSender;

    private CustomerReturnItemRepository customerReturnItemRepository;

	@Autowired

    @Autowired

	private InsuranceService insuranceService;

    private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

    @Autowired

	private FofoOrderRepository fofoOrderRepository;

    private PaymentOptionRepository paymentOptionRepository;

	@Autowired

    @Autowired

	private CustomerAddressRepository customerAddressRepository;

    private StateRepository stateRepository;

	@Autowired

    @Autowired

	private InsurancePolicyRepository insurancePolicyRepository;

    private ItemRepository itemRepository;

	@Autowired

    @Autowired

	private InsuranceProviderRepository insuranceProviderRepository;

    private MVCResponseSender mvcResponseSender;

	@Autowired

    @Autowired

	private CookiesProcessor cookiesProcessor;

    private InsuranceService insuranceService;

	@Autowired

    @Autowired

	private PricingService pricingService;

    private FofoOrderRepository fofoOrderRepository;

	@Autowired

    @Autowired

	private OrderService orderService;

    private CustomerAddressRepository customerAddressRepository;

	@Autowired

    @Autowired

	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    private InsurancePolicyRepository insurancePolicyRepository;

	@Autowired

    @Autowired

	private AddressRepository addressRepository;

    private InsuranceProviderRepository insuranceProviderRepository;

	@Autowired

    @Autowired

	private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

    private CookiesProcessor cookiesProcessor;

	@Autowired

    @Autowired

	private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

    private PricingService pricingService;

	@Autowired

    @Autowired

	private ResponseSender<?> responseSender;

    private OrderService orderService;

	@Autowired

    @Autowired

	private PendingOrderRepository pendingOrderRepository;

    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

    @Autowired

	private OrderRepository orderRepository;

    private AddressRepository addressRepository;

	@Autowired

    @Autowired

	private PendingOrderItemRepository pendingOrderItemRepository;

    private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

	@Autowired

    @Autowired

	private FofoStoreRepository fofoStoreRepository;

    private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

	@Autowired

    @Autowired

	private RetailerService retailerService;

    private ResponseSender<?> responseSender;

	@Autowired

    @Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    private PendingOrderRepository pendingOrderRepository;

	@Autowired

    @Autowired

	private TagListingRepository tagListingRepository;

    private OrderRepository orderRepository;

	@Autowired

    @Autowired

	private PendingOrderService pendingOrderService;

    private PendingOrderItemRepository pendingOrderItemRepository;

	@Autowired

    @Autowired

	private EmailService emailService;

    private FofoStoreRepository fofoStoreRepository;

	@Autowired

    @Autowired

	private SolrService commonSolrService;

    private RetailerService retailerService;

	@Autowired

    @Autowired

	private MouRepository mouRepository;

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

	@Autowired

    private TagListingRepository tagListingRepository;

	private WhatsappMessageService whatsappMessageService;

    @Autowired

    private PendingOrderService pendingOrderService;

	@RequestMapping(value = "/order")

    @Autowired

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

    private EmailService emailService;

			throws ProfitMandiBusinessException {

    @Autowired

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

    private SolrService commonSolrService;

    @Autowired

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

    private MouRepository mouRepository;

		Address address = addressRepository.selectById(addressId);

    @Autowired

    private WhatsappMessageService whatsappMessageService;

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

    @Autowired

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

    private TransactionRepository transactionRepository;

		List<Integer> poIds = new ArrayList<>();

		List<Integer> poItemIds = new ArrayList<>();

    @RequestMapping(value = "/order")

		for (CartFofo cartFofo : cartItems) {

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

			itemIds.add(cartFofo.getItemId());

            throws ProfitMandiBusinessException {

			if (cartFofo.getPoId() != 0) {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

				poIds.add(cartFofo.getPoId());

				poItemIds.add(cartFofo.getPoItemId());

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

			}

        Address address = addressRepository.selectById(addressId);

		}

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

		PendingOrder po = null;

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

		Customer customer = null;

        List<Integer> poIds = new ArrayList<>();

		PendingOrderItem poi = null;

        List<Integer> poItemIds = new ArrayList<>();

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

        for (CartFofo cartFofo : cartItems) {

				loginDetails.getFofoId());

            itemIds.add(cartFofo.getItemId());

		List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository

            if (cartFofo.getPoId() != 0) {

				.selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());

                poIds.add(cartFofo.getPoId());

                poItemIds.add(cartFofo.getPoItemId());

		if (!poIds.isEmpty()) {

            }

			po = pendingOrderRepository.selectById(poIds.get(0));

        }

			customer = customerRepository.selectById(po.getCustomerId());

			if (!offlineOrders.contains(po.getPayMethod())) {

        PendingOrder po = null;

				paymentOptionIds.add(23);

        Customer customer = null;

			}

        PendingOrderItem poi = null;

		}

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

                loginDetails.getFofoId());

		if (!poItemIds.isEmpty()) {

        List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository

			poi = pendingOrderItemRepository.selectById(poItemIds.get(0));

                .selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());

		}

        if (!poIds.isEmpty()) {

		// List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new

            po = pendingOrderRepository.selectById(poIds.get(0));

		// HashSet<>(paymentOptionIds));

            customer = customerRepository.selectById(po.getCustomerId());

            if (!offlineOrders.contains(po.getPayMethod())) {

		List<PaymentOption> paymentOptions = paymentOptionRepository.selectActiveOption();

                paymentOptionIds.add(23);

            }

		LOGGER.info("pendingOrder" + po);

        }

		LOGGER.info("pendingOrderItem" + poi);

        if (!poItemIds.isEmpty()) {

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

            poi = pendingOrderItemRepository.selectById(poItemIds.get(0));

		model.addAttribute("stateNames",

        }

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

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

        // List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new

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

        // HashSet<>(paymentOptionIds));

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

        List<PaymentOption> paymentOptions = paymentOptionRepository.selectActiveOption();

		model.addAttribute("cartItems", cartItems);

		model.addAttribute("pendingOrder", po);

        LOGGER.info("pendingOrder" + po);

		model.addAttribute("pendingOrderItem", poi);

        LOGGER.info("pendingOrderItem" + poi);

		model.addAttribute("mopPriceMap", mopPriceMap);

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

		model.addAttribute("paymentOptions", paymentOptions);

        model.addAttribute("stateNames",

		model.addAttribute("accessoriesDeals", accessoriesDeals);

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

		return "order-index";

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

	}

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

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

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

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

        model.addAttribute("cartItems", cartItems);

									 @RequestParam int itemId) throws ProfitMandiBusinessException {

        model.addAttribute("pendingOrder", po);

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

        model.addAttribute("pendingOrderItem", poi);

		try {

        model.addAttribute("mopPriceMap", mopPriceMap);

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

        model.addAttribute("paymentOptions", paymentOptions);

			model.addAttribute("response1", response);

        model.addAttribute("accessoriesDeals", accessoriesDeals);

		} catch (Exception e) {

        return "order-index";

			// TODO Auto-generated catch block

    }

			LOGGER.info(e.getMessage(), e);

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

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

		}

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

                                     @RequestParam int itemId) throws ProfitMandiBusinessException {

		return "response";

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

	}

        try {

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

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

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

            model.addAttribute("response1", response);

						   Model model) throws ProfitMandiBusinessException {

        } catch (Exception e) {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

            // TODO Auto-generated catch block

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

            LOGGER.info(e.getMessage(), e);

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

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

		CustomerAddress customerAddress = null;

        }

		if (fofoOrder.getCustomerAddressId() != 0) {

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

        return "response";

		}

    }

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

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

		if (customerAddress != null) {

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

			customerAddress.setPhoneNumber(customer.getMobileNumber());

                           Model model) throws ProfitMandiBusinessException {

		}

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		LOGGER.info("Added to get invoice - {}, {}", customer, 123);

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

		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

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

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

        CustomerAddress customerAddress = null;

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

        if (fofoOrder.getCustomerAddressId() != 0) {

				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

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

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

        }

				.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

		this.addInsuranceProvider(insurancePolicies);

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

        if (customerAddress != null) {

		model.addAttribute("fofoOrder", fofoOrder);

            customerAddress.setPhoneNumber(customer.getMobileNumber());

		model.addAttribute("fofoLineItems", fofoLineItems);

        }

		if (customerAddress != null) {

        LOGGER.info("Added to get invoice - {}, {}", customer, 123);

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

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

		} else {

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

			model.addAttribute("customerBillingAddress", "");

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

		}

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

		model.addAttribute("customerBillingAddressObj", customerAddress);

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

		model.addAttribute("customerDetailsObj", customer);

        this.addInsuranceProvider(insurancePolicies);

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

        model.addAttribute("fofoOrder", fofoOrder);

		model.addAttribute("insurancePolicies", insurancePolicies);

        model.addAttribute("fofoLineItems", fofoLineItems);

		return "order-details";

        if (customerAddress != null) {

	}

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

        } else {

	private Map<Integer, InsuranceProvider> toInsuranceProviderIdInsuranceProvider(

            model.addAttribute("customerBillingAddress", "");

			List<InsuranceProvider> insuranceProviders) {

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

        }

		for (InsuranceProvider insuranceProvider : insuranceProviders) {

        model.addAttribute("customerBillingAddressObj", customerAddress);

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

        model.addAttribute("customerDetailsObj", customer);

		}

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

		return insuranceProviderIdInsuranceProviderMap;

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

	}

        model.addAttribute("insurancePolicies", insurancePolicies);

        return "order-details";

	private void addInsuranceProvider(List<InsurancePolicy> insurancePolicies) {

    }

		if (insurancePolicies.isEmpty()) {

			return;

    private Map<Integer, InsuranceProvider> toInsuranceProviderIdInsuranceProvider(

		}

            List<InsuranceProvider> insuranceProviders) {

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

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

		for (InsurancePolicy insurancePolicy : insurancePolicies) {

        for (InsuranceProvider insuranceProvider : insuranceProviders) {

			insuranceProviderIds.add(insurancePolicy.getProviderId());

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

		}

        }

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

        return insuranceProviderIdInsuranceProviderMap;

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

    }

		Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = this

				.toInsuranceProviderIdInsuranceProvider(insuranceProviders);

    private void addInsuranceProvider(List<InsurancePolicy> insurancePolicies) {

		for (InsurancePolicy insurancePolicy : insurancePolicies) {

        if (insurancePolicies.isEmpty()) {

			insurancePolicy

            return;

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

        }

		}

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

	}

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

            insuranceProviderIds.add(insurancePolicy.getProviderId());

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

        }

	public String getSaleDetails(HttpServletRequest request,

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

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

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

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = this

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

                .toInsuranceProviderIdInsuranceProvider(insuranceProviders);

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

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

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

            insurancePolicy

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

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

		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

        }

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

    }

		// Added Migration info as we lost it.

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

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

    public String getSaleDetails(HttpServletRequest request,

			PaymentOptionTransaction pot = new PaymentOptionTransaction();

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

			pot.setAmount(fofoOrder.getTotalAmount());

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

			pot.setCreateTimestamp(fofoOrder.getCreateTimestamp());

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

			// Mark it paid through cash

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

			pot.setPaymentOptionId(1);

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

			pot.setReferenceType(PaymentOptionReferenceType.ORDER);

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

			paymentOptionTransactionRepository.persist(pot);

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

			paymentOptionTransactions.add(pot);

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

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

		}

        // Added Migration info as we lost it.

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

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

				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

            PaymentOptionTransaction pot = new PaymentOptionTransaction();

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

            pot.setAmount(fofoOrder.getTotalAmount());

				.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

            pot.setCreateTimestamp(fofoOrder.getCreateTimestamp());

		this.addInsuranceProvider(insurancePolicies);

            // Mark it paid through cash

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

            pot.setPaymentOptionId(1);

			try {

            pot.setReferenceType(PaymentOptionReferenceType.ORDER);

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

            paymentOptionTransactionRepository.persist(pot);

			} catch (ProfitMandiBusinessException e) {

            paymentOptionTransactions.add(pot);

				// TODO Auto-generated catch block

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

				return null;

        }

			}

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

		}));

                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

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

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

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

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        this.addInsuranceProvider(insurancePolicies);

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

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

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

            try {

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

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

            } catch (ProfitMandiBusinessException e) {

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

                // TODO Auto-generated catch block

                return null;

		for (FofoOrderItem foi : fofoOrderItems) {

            }

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

        }));

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

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

			}

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

			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

					.selectAllByOrderItemId(foi.getId());

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

			this.markDoa(fofoOrder, foi, isAdmin);

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

			for (CustomerReturnItem customerReturnItem : customerReturnItems) {

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

				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

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

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

			}

		}

        for (FofoOrderItem foi : fofoOrderItems) {

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

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

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

		model.addAttribute("fofoOrder", fofoOrder);

            }

		model.addAttribute("itemsMap", itemsMap);

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

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

                    .selectAllByOrderItemId(foi.getId());

		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

            this.markDoa(fofoOrder, foi, isAdmin);

				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

            for (CustomerReturnItem customerReturnItem : customerReturnItems) {

		model.addAttribute("fofoOrderItemIdLineItemMap", fofoOrderItemIdLineItemMap);

                inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

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

		model.addAttribute("fofoOrderItems", fofoOrderItems);

            }

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

        }

		if (customerAddress != null) {

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

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

        model.addAttribute("fofoOrder", fofoOrder);

		} else {

        model.addAttribute("itemsMap", itemsMap);

			model.addAttribute("customerBillingAddress", "");

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

        model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

		}

                StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

		model.addAttribute("customerBillingAddressObj", customerAddress);

        model.addAttribute("fofoOrderItemIdLineItemMap", fofoOrderItemIdLineItemMap);

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

        model.addAttribute("fofoOrderItems", fofoOrderItems);

		model.addAttribute("insurancePolicies", insurancePolicies);

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

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

        if (customerAddress != null) {

		return "sale-details";

	}

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

        } else {

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

            model.addAttribute("customerBillingAddress", "");

		if (isAdmin) {

			foi.setDoa(true);

        }

			return;

        model.addAttribute("customerBillingAddressObj", customerAddress);

		}

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

		boolean isImei = foi.getFofoLineItems().stream()

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

				.anyMatch(x -> org.apache.commons.lang3.StringUtils.isNotEmpty(x.getSerialNumber())

        model.addAttribute("insurancePolicies", insurancePolicies);

						&& allowedDoaImeis.contains(x.getSerialNumber()));

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

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

        return "sale-details";

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

    }

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

			foi.setDoa(true);

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

		} else

        if (isAdmin) {

			foi.setDoa(

            foi.setDoa(true);

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

            return;

	}

        }

        boolean isImei = foi.getFofoLineItems().stream()

	private boolean markDefective(FofoOrder fofoOrder) {

                .anyMatch(x -> org.apache.commons.lang3.StringUtils.isNotEmpty(x.getSerialNumber())

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

                        && allowedDoaImeis.contains(x.getSerialNumber()));

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

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

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

	}

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

            foi.setDoa(true);

	@Autowired

        } else

	BulkOrderService bulkOrderService;

            foi.setDoa(

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

	@RequestMapping(value = "/getBulkOrder")

    }

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

		return "bulk_order";

    private boolean markDefective(FofoOrder fofoOrder) {

	}

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

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

	@PostMapping(value = "/bulkOrder/upload")

	public String uploadCatalog(HttpServletRequest request, @RequestPart("file") MultipartFile file, Model model)

    }

			throws Exception {

		bulkOrderService.parseBulkOrders(file);

    @RequestMapping(value = "/getSearchOrder")

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

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

        return "search-order";

		return "response";

    }

	}

    @RequestMapping(value = "/getInvoiceSearchOrder")

	@RequestMapping(value = "/getSearchOrder")

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

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

        return "invoices-cancel";

		return "search-order";

    }

	}

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

	@RequestMapping(value = "/getInvoiceSearchOrder")

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

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

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

		return "invoices-cancel";

            throws Exception {

	}

        orderService.updateCustomerDetails(customCustomer, invoiceNumber);

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

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

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

    }

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

			throws Exception {

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

    public String getSearchOrderDetails(HttpServletRequest request,

		orderService.updateCustomerDetails(customCustomer, invoiceNumber);

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

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

            throws Exception {

	}

        FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

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

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

	public String getSearchOrderDetails(HttpServletRequest request,

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

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

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

			throws Exception {

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = paymentOptionRepository.selectActiveOption().stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        List<Integer> fofoPartnerPaymentOptions = new ArrayList<>(paymentOptionIdPaymentOptionMap.keySet());

		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

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

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

            try {

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

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

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

            } catch (ProfitMandiBusinessException e) {

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = paymentOptionRepository.selectActiveOption().stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                // TODO Auto-generated catch block

		List<Integer> fofoPartnerPaymentOptions = new ArrayList<>(paymentOptionIdPaymentOptionMap.keySet());

                return null;

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

            }

			try {

        }));

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

        LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);

			} catch (ProfitMandiBusinessException e) {

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

				// TODO Auto-generated catch block

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

				return null;

        LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);

			}

		}));

        Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

		LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);

                .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

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

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

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

		LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        this.addInsuranceProvider(insurancePolicies);

		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

        model.addAttribute("fofoOrder", fofoOrder);

				.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

        for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

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

            fofoOrderItem.setDoa(true);

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

        }

				.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

		this.addInsuranceProvider(insurancePolicies);

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

		model.addAttribute("fofoOrder", fofoOrder);

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

		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

			fofoOrderItem.setDoa(true);

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

		}

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

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

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

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

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

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

        for (FofoOrderItem foi : fofoOrderItems) {

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

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

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

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

            }

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

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

                    .selectAllByOrderItemId(foi.getId());

		for (FofoOrderItem foi : fofoOrderItems) {

            for (CustomerReturnItem customerReturnItem : customerReturnItems) {

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

                inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

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

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

			}

            }

			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

        }

					.selectAllByOrderItemId(foi.getId());

        model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

			for (CustomerReturnItem customerReturnItem : customerReturnItems) {

                StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

        model.addAttribute("fofoOrderItems", fofoOrderItems);

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

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

			}

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

		}

        model.addAttribute("itemsMap", itemsMap);

		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

        model.addAttribute("markDefective", true);

				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

        model.addAttribute("customer", customer);

		model.addAttribute("fofoOrderItems", fofoOrderItems);

        model.addAttribute("customerAddress", customerAddress);

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

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

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

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

		model.addAttribute("itemsMap", itemsMap);

        model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);

		model.addAttribute("markDefective", true);

        model.addAttribute("insurancePolicies", insurancePolicies);

		model.addAttribute("customer", customer);

        model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);

		model.addAttribute("customerAddress", customerAddress);

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

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

        model.addAttribute("stateNames",

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

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

		model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);

        return "search-order-details";

		model.addAttribute("insurancePolicies", insurancePolicies);

    }

		model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);

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

    private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(

		model.addAttribute("stateNames",

            List<PaymentOptionTransaction> paymentOptionTransactions) {

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

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

		return "search-order-details";

        for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

	}

            paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());

        }

	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(

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

			List<PaymentOptionTransaction> paymentOptionTransactions) {

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

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

        for (PaymentOption paymentOption : paymentOptions) {

		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

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

			paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());

        }

		}

        return paymentOptionIdPaymentOptionMap;

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

    }

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

		for (PaymentOption paymentOption : paymentOptions) {

    private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(

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

            List<Integer> fofoPartnerPaymentOptions) {

		}

        List<PaymentOption> paymentOptions = paymentOptionRepository

		return paymentOptionIdPaymentOptionMap;

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

	}

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

        for (PaymentOption paymentOption : paymentOptions) {

	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(

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

			List<Integer> fofoPartnerPaymentOptions) {

        }

		List<PaymentOption> paymentOptions = paymentOptionRepository

        return paymentOptionIdPaymentOptionMap;

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

    }

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

		for (PaymentOption paymentOption : paymentOptions) {

    private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(

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

            List<PaymentOptionTransaction> paymentOptionTransactions) {

		}

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

		return paymentOptionIdPaymentOptionMap;

        for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

	}

            paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),

                    paymentOptionTransaction);

	private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(

        }

			List<PaymentOptionTransaction> paymentOptionTransactions) {

        return paymentOptionIdPaymentOptionTransactionMap;

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

    }

		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

			paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),

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

					paymentOptionTransaction);

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

		}

                              Model model) throws ProfitMandiBusinessException {

		return paymentOptionIdPaymentOptionTransactionMap;

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

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

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

							  Model model) throws ProfitMandiBusinessException {

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

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

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

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

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

        try {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

            this.sendWhatsappInvoice(fofoOrderRepository.selectByOrderId(fofoOrderId));

        } catch (Exception e) {

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

            LOGGER.info("Could not send whatsapp message");

            e.printStackTrace();

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

        }

		try {

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

			this.sendWhatsappInvoice(fofoOrderRepository.selectByOrderId(fofoOrderId));

    }

		} catch (Exception e) {

			LOGGER.info("Could not send whatsapp message");

    private void sendWhatsappInvoice(FofoOrder fofoOrder) throws Exception {

			e.printStackTrace();

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

		}

        CustomRetailer retailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());

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

        String message = String.format("Dear %s,\n" +

	}

                "Thank you for your purchase from SmartDukaan store - %s, %s.\n" +

                "Your purchase invoice is attached for your reference.\n" +

	private void sendWhatsappInvoice(FofoOrder fofoOrder) throws Exception {

                "\n" +

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

                "Download our app for offers and updates on new products.\n" +

		CustomRetailer retailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());

                "https://www.smartdukaan.com/b2c\n" +

		String message = String.format("Dear %s,\n" +

                "\n" +

				"Thank you for your purchase from SmartDukaan store - %s, %s.\n" +

                "Best Regards\n" +

				"Your purchase invoice is attached for your reference.\n" +

                "SmartDukaan", customer.getFirstName(), retailer.getBusinessName(), retailer.getAddress().getCity());

				"\n" +

        boolean sentMessage = notificationService.isWhatMessageSend(customer.getMobileNumber());

				"Download our app for offers and updates on new products.\n" +

        if (sentMessage) {

				"https://www.smartdukaan.com/b2c\n" +

            notificationService.sendWhatsappMediaMessage(message, customer.getMobileNumber(), this.getPublicInvoiceUrl(fofoOrder.getInvoiceNumber()),

				"\n" +

                    this.getFileName(fofoOrder.getInvoiceNumber()), WhatsappMessageType.DOCUMENT);

				"Best Regards\n" +

        }

				"SmartDukaan", customer.getFirstName(), retailer.getBusinessName(), retailer.getAddress().getCity());

    }

		boolean sentMessage = notificationService.isWhatMessageSend(customer.getMobileNumber());

		if (sentMessage) {

    private String getFileName(String invoiceNumber) {

			notificationService.sendWhatsappMediaMessage(message, customer.getMobileNumber(), this.getPublicInvoiceUrl(fofoOrder.getInvoiceNumber()),

        return "INV-" + invoiceNumber.replace("/", "-") + ".pdf";

					this.getFileName(fofoOrder.getInvoiceNumber()), WhatsappMessageType.DOCUMENT);

    }

		}

	}

    private String getPublicInvoiceUrl(String invoiceNumber) {

        String base64Encoded = Base64.getMimeEncoder().encodeToString(invoiceNumber.getBytes(StandardCharsets.UTF_8));

	private String getFileName(String invoiceNumber) {

        String publicUrl = "https://partners.smartdukaan.com/wa-invoice-send/" + base64Encoded + ".pdf";

		return "INV-" + invoiceNumber.replace("/", "-") + ".pdf";

        LOGGER.info("Public Whatsapp Url for Invoice Message - {}", publicUrl);

	}

        return publicUrl;

    }

	private String getPublicInvoiceUrl(String invoiceNumber) {

		String base64Encoded = Base64.getMimeEncoder().encodeToString(invoiceNumber.getBytes(StandardCharsets.UTF_8));

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

		String publicUrl = "https://partners.smartdukaan.com/wa-invoice-send/" + base64Encoded + ".pdf";

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

		LOGGER.info("Public Whatsapp Url for Invoice Message - {}", publicUrl);

                                       Model model) throws ProfitMandiBusinessException {

		return publicUrl;

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

	}

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        CustomerCreditNote custmoerCreditNote;

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

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

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

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

									   Model model) throws ProfitMandiBusinessException {

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

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

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

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        } else {

		CustomerCreditNote custmoerCreditNote;

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

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

        }

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

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

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

    }

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

		} else {

    @GetMapping(value = "/wa-invoice-send/{invoiceHash}")

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

    public ResponseEntity<?> generateInvoice(@PathVariable String invoiceHash) throws ProfitMandiBusinessException {

		}

        String decodedInvoiceNumber = new String(Base64.getMimeDecoder().decode(invoiceHash));

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

        LOGGER.info("Invoice Hash {}", invoiceHash);

	}

	@GetMapping(value = "/wa-invoice-send/{invoiceHash}")

        FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(decodedInvoiceNumber);

	public ResponseEntity<?> generateInvoice(@PathVariable String invoiceHash) throws ProfitMandiBusinessException {

		String decodedInvoiceNumber = new String(Base64.getMimeDecoder().decode(invoiceHash));

        InvoicePdfModel pdfModel = orderService.getInvoicePdfModel(fofoOrder.getId());

		LOGGER.info("Invoice Hash {}", invoiceHash);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(decodedInvoiceNumber);

        final HttpHeaders headers = new HttpHeaders();

        //headers.setContentDispositionFormData("inline", number + ".pdf");

		InvoicePdfModel pdfModel = orderService.getInvoicePdfModel(fofoOrder.getId());

        headers.add(HttpHeaders.CONTENT_DISPOSITION, "inline;filename=" + pdfModel.getInvoiceNumber() + ".pdf");

        int contentLength = byteArrayOutputStream.toByteArray().length;

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		final HttpHeaders headers = new HttpHeaders();

        return ResponseEntity.ok()

		//headers.setContentDispositionFormData("inline", number + ".pdf");

                .headers(headers)

		headers.add(HttpHeaders.CONTENT_DISPOSITION, "inline;filename=" + pdfModel.getInvoiceNumber() + ".pdf");

                .contentLength(contentLength)

		int contentLength = byteArrayOutputStream.toByteArray().length;

                .contentType(MediaType.parseMediaType("application/pdf"))

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

                .body(inputStreamResource);

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

    }

		return ResponseEntity.ok()

				.headers(headers)

    @RequestMapping(value = "/wa-listen", method = RequestMethod.POST)

				.contentLength(contentLength)

    public ResponseEntity<?> listenWhatsappStatus(@RequestBody String whatsappJsonResponse) {

				.contentType(MediaType.parseMediaType("application/pdf"))

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

				.body(inputStreamResource);

        //jaihind

	}

        //  String jsonString = "[{\"srcAddr\":\"TESTSM\",\"channel\":\"WHATSAPP\",\"externalId\":\"4977024756456780043-180044363908187691\",\"cause\":\"SUCCESS\",\"errorCode\":\"000\",\"destAddr\":\"919813272029\",\"eventType\":\"DELIVERED\",\"eventTs\":1692848106000}]";

        JSONArray jsonArray = new JSONArray(whatsappJsonResponse);

	@RequestMapping(value = "/wa-listen", method = RequestMethod.POST)

        for (int i = 0; i < jsonArray.length(); i++) {

	public ResponseEntity<?> listenWhatsappStatus(@RequestBody String whatsappJsonResponse) {

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

            JSONObject jsonObject = jsonArray.getJSONObject(i);

		//jaihind

            String externalId = jsonObject.getString("externalId");

		//  String jsonString = "[{\"srcAddr\":\"TESTSM\",\"channel\":\"WHATSAPP\",\"externalId\":\"4977024756456780043-180044363908187691\",\"cause\":\"SUCCESS\",\"errorCode\":\"000\",\"destAddr\":\"919813272029\",\"eventType\":\"DELIVERED\",\"eventTs\":1692848106000}]";

            String destAddr = jsonObject.getString("destAddr");

		JSONArray jsonArray = new JSONArray(whatsappJsonResponse);

            String eventType = jsonObject.getString("eventType");

		for (int i = 0; i < jsonArray.length(); i++) {

            whatsappMessageService.setWhatsappResponse(externalId, destAddr, eventType);

        }

			JSONObject jsonObject = jsonArray.getJSONObject(i);

        //jaihind

			String externalId = jsonObject.getString("externalId");

        return responseSender.ok("Success");

			String destAddr = jsonObject.getString("destAddr");

			String eventType = jsonObject.getString("eventType");

    }

			whatsappMessageService.setWhatsappResponse(externalId, destAddr, eventType);

		}

    @RequestMapping(value = "/generateInvoice")

		//jaihind

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

		return responseSender.ok("Success");

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

	@RequestMapping(value = "/generateInvoice")

        InvoicePdfModel pdfModel = null;

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

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

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

            pdfModel = orderService.getInvoicePdfModel(orderId);

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

        } else {

				ProfitMandiConstants.ORDER_ID, orderId);

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

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        }

		InvoicePdfModel pdfModel = null;

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

			pdfModel = orderService.getInvoicePdfModel(orderId);

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

		} else {

        final HttpHeaders headers = new HttpHeaders();

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

        headers.setContentType(MediaType.APPLICATION_PDF);

		}

        headers.setContentDispositionFormData("inline", "invoice-" + pdfModel.getInvoiceNumber() + ".pdf");

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

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

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

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		final HttpHeaders headers = new HttpHeaders();

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

		headers.setContentType(MediaType.APPLICATION_PDF);

    }

		headers.setContentDispositionFormData("inline", "invoice-" + pdfModel.getInvoiceNumber() + ".pdf");

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

    @RequestMapping(value = "/generateInvoices")

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

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

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

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

            throws ProfitMandiBusinessException {

	}

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

	@RequestMapping(value = "/generateInvoices")

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

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

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

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

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

			throws ProfitMandiBusinessException {

            for (int orderId : orderIds) {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

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

            }

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

            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

            PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

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

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

			for (int orderId : orderIds) {

            final HttpHeaders headers = new HttpHeaders();

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

            headers.setContentType(MediaType.APPLICATION_PDF);

			}

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

			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

			PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

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

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

            final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

			final HttpHeaders headers = new HttpHeaders();

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

			headers.setContentType(MediaType.APPLICATION_PDF);

        } else {

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

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

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

		} else {

    public String saleHistory(HttpServletRequest request,

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

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

		}

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

	}

                              @RequestParam(required = false) LocalDateTime startTime,

                              @RequestParam(required = false) LocalDateTime endTime,

	@RequestMapping(value = "/saleHistory")

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

	public String saleHistory(HttpServletRequest request,

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

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

            throws ProfitMandiBusinessException {

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

							  @RequestParam(required = false) LocalDateTime startTime,

							  @RequestParam(required = false) LocalDateTime endTime,

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

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

                startTime, endTime, offset, limit);

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

        model.addAllAttributes(map);

			throws ProfitMandiBusinessException {

        return "sale-history";

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

    }

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

    @RequestMapping(value = "/downloadInvoices")

				startTime, endTime, offset, limit);

    public ResponseEntity<?> downloadInvoices(HttpServletRequest request,

		model.addAllAttributes(map);

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

		return "sale-history";

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

	}

                                              @RequestParam(required = false) LocalDateTime startTime,

                                              @RequestParam(required = false) LocalDateTime endTime,

	@RequestMapping(value = "/downloadInvoices")

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

	public ResponseEntity<?> downloadInvoices(HttpServletRequest request,

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

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

            throws ProfitMandiBusinessException {

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

											  @RequestParam(required = false) LocalDateTime startTime,

											  @RequestParam(required = false) LocalDateTime endTime,

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

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

                startTime, endTime, offset, 100);

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

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

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

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

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

        }

				startTime, endTime, offset, 100);

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

        final HttpHeaders headers = new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

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

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

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

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		}

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

        for (FofoOrder fofoOrder : fofoOrders) {

		final HttpHeaders headers = new HttpHeaders();

            try {

		headers.setContentType(MediaType.APPLICATION_PDF);

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

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

            } catch (Exception e) {

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

                        fofoOrder.getInvoiceNumber());

		for (FofoOrder fofoOrder : fofoOrders) {

            }

			try {

        }

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

        PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

			} catch (Exception e) {

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

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

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

						fofoOrder.getInvoiceNumber());

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

			}

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

		}

    }

		PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

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

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

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

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

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

            throws ProfitMandiBusinessException {

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

        CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);

	}

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

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

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

        final HttpHeaders headers = new HttpHeaders();

			throws ProfitMandiBusinessException {

        headers.setContentType(MediaType.APPLICATION_PDF);

		CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);

        headers.set("Content-disposition",

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

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

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

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

		final HttpHeaders headers = new HttpHeaders();

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		headers.setContentType(MediaType.APPLICATION_PDF);

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

		headers.set("Content-disposition",

    }

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

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

    @RequestMapping(value = "/getPaginatedSaleHistory")

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

    public String getSaleHistoryPaginated(HttpServletRequest request,

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

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

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

	}

                                          @RequestParam(required = false) LocalDateTime startTime,

                                          @RequestParam(required = false) LocalDateTime endTime,

	@RequestMapping(value = "/getPaginatedSaleHistory")

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

	public String getSaleHistoryPaginated(HttpServletRequest request,

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

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

            throws ProfitMandiBusinessException {

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

										  @RequestParam(required = false) LocalDateTime startTime,

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

										  @RequestParam(required = false) LocalDateTime endTime,

                searchValue, startTime, endTime, offset, limit);

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

        model.addAllAttributes(map);

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

        return "sale-history-paginated";

			throws ProfitMandiBusinessException {

    }

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

    @PutMapping(value = "/updatePaymentTransaction")

				searchValue, startTime, endTime, offset, limit);

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

		model.addAllAttributes(map);

                                           @RequestParam int fofoId, @RequestParam int referenceId,

		return "sale-history-paginated";

                                           @RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,

	}

                                           @RequestParam float totalAmount, Model model) throws Exception {

	@PutMapping(value = "/updatePaymentTransaction")

        List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel

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

                .getPaymentOptionTransactionModel();

										   @RequestParam int fofoId, @RequestParam int referenceId,

        LOGGER.info(paymentOptionTransactionModels);

										   @RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,

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

										   @RequestParam float totalAmount, Model model) throws Exception {

        LOGGER.info("sdssd" + fofoOrder);

        fofoOrder.setTotalAmount(totalAmount);

		List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel

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

				.getPaymentOptionTransactionModel();

        for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {

		LOGGER.info(paymentOptionTransactionModels);

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

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

		LOGGER.info("sdssd" + fofoOrder);

            LOGGER.info("fimAmount" + fim.getAmount());

		fofoOrder.setTotalAmount(totalAmount);

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

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

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

		for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {

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

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

            LOGGER.info("category" + item.getCategoryId());

            if (item.getCategoryId() == ProfitMandiConstants.MOBILE_CATEGORY_ID) {

			LOGGER.info("fimAmount" + fim.getAmount());

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

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

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

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

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

                        fofoOrderItem.setSellingPrice(fim.getAmount());

			LOGGER.info("category" + item.getCategoryId());

                    } else {

			if (item.getCategoryId() == ProfitMandiConstants.MOBILE_CATEGORY_ID) {

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

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

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

                    }

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

						fofoOrderItem.setSellingPrice(fim.getAmount());

                    LOGGER.info("fofoOrderItem2" + fofoOrderItem);

					} else {

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

                } else {

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

                    // TODO below mop condition need to added added

					}

                    fofoOrderItem.setSellingPrice(fim.getAmount());

                }

					LOGGER.info("fofoOrderItem2" + fofoOrderItem);

            } else {

				} else {

                fofoOrderItem.setSellingPrice(fim.getAmount());

					// TODO below mop condition need to added added

                LOGGER.info("fofoOrderItem1" + fofoOrderItem);

					fofoOrderItem.setSellingPrice(fim.getAmount());

				}

            }

            LOGGER.info("fofoOrderItem" + fofoOrderItem);

			} else {

				fofoOrderItem.setSellingPrice(fim.getAmount());

        }

				LOGGER.info("fofoOrderItem1" + fofoOrderItem);

        /*

			}

         * for (PaymentOptionTransactionModel paymentOptionTransactionModel :

			LOGGER.info("fofoOrderItem" + fofoOrderItem);

         * paymentOptionTransactionModels) { amount = amount +

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

		}

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

         * fofoOrder.getUnitPrice()) {

		/*

         */

		 * for (PaymentOptionTransactionModel paymentOptionTransactionModel :

        if (paymentOptionTransactionModels.size() > 0) {

		 * paymentOptionTransactionModels) { amount = amount +

            List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

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

                    .selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);

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

            Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

		 * fofoOrder.getUnitPrice()) {

                    .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

		 */

            LOGGER.info(

		if (paymentOptionTransactionModels.size() > 0) {

                    "paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

			List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

            for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {

					.selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);

                if (paymentOptionIdPaymentOptionTransactionMap

			Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

                        .containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {

					.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

			LOGGER.info(

                    PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap

					"paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

                            .get(paymentOptionTransactionModel.getPaymentOptionId());

			for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {

				if (paymentOptionIdPaymentOptionTransactionMap

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

						.containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {

                        paymentOptionTransactionRepository.delete(paymentOptionTransaction);

                        LOGGER.info("deleted successfully");

					PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap

                    } else {

							.get(paymentOptionTransactionModel.getPaymentOptionId());

                        paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

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

                        paymentOptionTransactionRepository.persist(paymentOptionTransaction);

						paymentOptionTransactionRepository.delete(paymentOptionTransaction);

                        LOGGER.info("updated successfully");

						LOGGER.info("deleted successfully");

					} else {

                    }

                } else {

						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

                    if (paymentOptionTransactionModel.getAmount() > 0) {

						paymentOptionTransactionRepository.persist(paymentOptionTransaction);

                        PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();

						LOGGER.info("updated successfully");

                        paymentOptionTransaction.setReferenceId(referenceId);

                        paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);

					}

                        paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());

				} else {

                        paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

					if (paymentOptionTransactionModel.getAmount() > 0) {

                        paymentOptionTransaction.setFofoId(fofoId);

						PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();

                        paymentOptionTransaction.setCreateTimestamp(fofoOrder.getCreateTimestamp());

						paymentOptionTransaction.setReferenceId(referenceId);

                        paymentOptionTransactionRepository.persist(paymentOptionTransaction);

						paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);

                        LOGGER.info("inserted successfully");

						paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());

                    }

						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

                }

						paymentOptionTransaction.setFofoId(fofoId);

						paymentOptionTransaction.setCreateTimestamp(fofoOrder.getCreateTimestamp());

            }

						paymentOptionTransactionRepository.persist(paymentOptionTransaction);

						LOGGER.info("inserted successfully");

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

					}

        }

				}

        /*

         * else

			}

         *

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

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

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

		}

         */